NicheForge.
NICHE-FORGE-CORE V3.0. An autonomous POD design engine.

Six numbers. Every one of them traceable.

The forensic audit dated May 15, 2026 anchors every claim on this page to a file path or line number in the live NICHE-FORGE-CORE V3.0 codebase. These six headline numbers are the entry points. The remainder of the page walks down to the source — and unlike its two sibling case studies, NicheForge has verified production artifacts to back its operating claims.

Eight production dependencies: @google/genai 0.14.1, dexie 4.0.11, dexie-react-hooks 1.1.7, express 4.21.2, react 19.1.0, react-dom 19.1.0, react-markdown 10.1.0, lucide-react 0.487.0. TailwindCSS loaded via CDN. Inter font from Google Fonts. A 48-line Express proxy on port 3025 secures the Printful API credentials so they never touch the client bundle.

Verified production artifacts. Eight measured weeks.

This is the section that separates NicheForge from its two sibling case studies. Sovereign Orchestrator Pro and The Synthetic Director have projected operating numbers calculated from verified per-unit pricing. NicheForge has artifacts: actual production session payloads written to disk, with timestamps that prove commercial use across a measured window.

What the artifacts prove

What the artifacts do not prove

An honest read of the evidence requires noting what it does not establish on its own:

• The artifacts confirm commercial use; they do not by themselves confirm the marketing-grade claim that NicheForge has produced every POD design currently on ddsboston.com over a full 6-month window. That broader claim is operator testimony.
• The artifacts span an 8-week measured window. The "6+ months in production" claim extends past that window in both directions based on operator testimony, not artifact timestamps.
• No measured cost-ledger export is attached. The annual ~$1,898 figure is calculated from verified per-unit pricing in geminiService.ts:90-99, not from a logged transaction total.

The Vibe Academy standard requires this distinction to be visible. The technical claims about the code itself are verified at the file:line level. The operating cadence claims are calculated from verified inputs. The production-existence claim is verified from artifacts. The "every POD design over 6 months" extension is testimony from the operator who built and ran the system. All four bars matter. All four are different.

What this case study proves — and what it does not.

NicheForge has the strongest evidence base of all three DDS AGI Suite case studies, but every case study in this academy surfaces its evidence gaps honestly. Three disclosures apply here.

Why these disclosures lead the case study

Most builder-published case studies bury their evidence gaps or omit them entirely. This page treats them as the first thing a reader should know. NicheForge has the strongest production evidence of the three DDS AGI Suite flagships — a verified 8-week artifact window plus extensive code-anchored technical claims. It does not yet have a measured 26-week cost-ledger export to match. Both facts coexist. A solo builder studying this codebase should understand that "production artifacts on disk" and "fully measured 6-month financial snapshot" are two different bars, and that documenting which is which is part of audit-grade engineering.

The rest of this page presents the verified architecture, 6-step pipeline, model registry, creative IP inventory, cost discipline, commerce bridge, build-cost methodology, and risk factors. Each section cites either a file path with line number or a verified count from the May 15 forensic audit. Read the technical claims with confidence; read the cost projections with the qualifiers above; treat the 8-week production window as verified.

One client. One proxy. One forge.

NicheForge is a desktop-first React 19 single-page application paired with a 48-line Express proxy server. The frontend handles all AI orchestration, state management, IndexedDB persistence, and UI rendering. The Express server exists for one purpose: holding the Printful API credentials so they never reach the client bundle and bypassing CORS for the Printful Admin API. This is the leanest backend architecture in the entire DDS Sovereign AGI Suite.

State management — single-component owner

State lives in App.tsx (580 lines, 26,898 bytes), the root component. This is a deliberate architectural choice — there is no Redux, no Zustand, no Jotai, no Context provider hierarchy. The application uses React's built-in useState and useEffect patterns plus Dexie's useLiveQuery hook for reactive IndexedDB binding. For a single-operator tool, this is the right complexity level. Adding a state management library would be ceremony without benefit.

Persistence — IndexedDB via Dexie, single table

The database schema is defined in services/db.ts (12 lines) — a single assets table with an auto-incrementing primary key. Every generated design is written to this table as it is created. The UI uses Dexie's useLiveQuery hook at App.tsx:23 to subscribe to the asset list, which means the AssetLibrary component re-renders automatically whenever a new asset is written. A one-time migration in App.tsx:62-79 moves any legacy localStorage assets into IndexedDB on first load. Three small session values (current input form, current strategy text, running session cost) remain in localStorage as lightweight session state.

The Retry Engine — callGeminiWithRetry

The retry wrapper at geminiService.ts:28-71 guards every Gemini API call with three retries, exponential backoff (2 seconds, 4 seconds, 8 seconds), and a 60-second hard timeout per attempt. It catches HTTP 429 (rate limit), 5xx server errors, TimeoutError, and TypeError (network failures). The Zeitgeist Radar has an additional fallback path at geminiService.ts:380-384 that returns internal heuristic data flagged with isFallback: true, allowing the pipeline to continue even when Google Search grounding is unreachable. The UI surfaces this state with an amber warning banner at App.tsx:567-572.

The Express Proxy — server.js

48 lines on port 3025 (server.js:1-56). Its only job is to inject the VITE_PRINTFUL_ACCESS_TOKEN server-side so the secret never enters the client bundle, and to bypass browser CORS restrictions on the Printful Admin API. Vite's dev proxy configuration at vite.config.ts:12-20 rewrites /api/printful requests through this proxy. The result: a fully client-side React application that can still securely call commerce-grade APIs.

Six autonomous steps. Niche input to product draft.

Every design that NicheForge produces follows the same six-step pipeline, orchestrated by App.tsx and executed by exported functions in geminiService.ts. Each step has a verified entry function, a verified model assignment, and a verified file:line citation. The full pipeline takes approximately 8 minutes end to end for a single design at default settings.

Four Gemini models. Each one chosen for purpose.

NicheForge wires fewer models than its siblings — 4 versus the 14 in The Synthetic Director — because the pipeline is narrower and more opinionated. Every Gemini variant deployed here is selected for its specific cost-and-quality tradeoff, verified in geminiService.ts. The cascade is what allows operators to draft at $0.04 per image and commit to commercial production at $0.32 per image without changing any pipeline logic.

The 4-Model Registry

Google Search Grounding — the differentiator

Both the Zeitgeist Radar (geminiService.ts:360) and the Smart Collection Scan (geminiService.ts:597) enable the native googleSearch tool in the Gemini SDK with tools: [{ googleSearch: {} }]. This means the system can return live trend data and grounding source URLs in its output — it is not generating from static training data. This is what makes NicheForge a research engine rather than a static prompt-completion tool.

The IP lives in the constants.

The real value of NicheForge is not in the React components or the API wiring — it is in the prompt engineering constants. Every system instruction, every archetype, every creative mutation, and every brand-voice rule lives in code as a hardcoded constant. The combinatorial output space these constants define is approximately 8.2 billion unique strategy configurations. The math: choose 10 from 30 archetypes (30,045,015) multiplied by choose 2 from 15 creative mutations (105) multiplied by 7 search angles multiplied by 13 art styles.

How the entropy system works

A naive AI generator produces the same kind of output regardless of how many times you run it — the model collapses toward its mean. NicheForge defeats this in three architecturally enforced ways:

• Archetype shuffle. Before each Strategy call, the system shuffles all 30 archetypes and selects the top 10 (geminiService.ts:397-399). Two different runs at the same niche will see a different 10-archetype slice.
• Mutation injection. Two of 15 creative mutations are selected (geminiService.ts:402-404) and injected as required style-twist constraints into the prompt.
• Entropy seed. A unique value derived from Date.now() plus a random integer is injected at geminiService.ts:477 so even identical input parameters produce different runs.

The architectural enforcement of diversity is what separates this from a generic AI art generator. The system refuses to produce homogeneous output by design.

The Subject Diversity Mandate

At geminiService.ts:470-475 the Strategy Engine enforces a 5-category subject-diversity mandate. Among the 10 concepts in any single Strategy run, the system must produce concepts spanning multiple subject categories — not 10 variations of the same idea. This is hardcoded in the system instruction, not optional.

Strategy Extension — extendStrategy()

If the operator wants more than 10 concepts, extendStrategy() at geminiService.ts:513 generates 10 additional prompts numbered 11 through 20 using the archetypes that were not selected in the first round. Temperature is raised to 0.95 (geminiService.ts:554) to push for higher-variance output. The "Add 10 More Designs" button in StrategyDisplay.tsx:124-141 wires this in the UI.

Every call priced at the source.

The RATES constant at geminiService.ts:90-99 is the financial source of truth for the entire system. The cost calculator at geminiService.ts:102-109 applies the formula (input_tokens / 1M × rate.INPUT) + (output_tokens / 1M × rate.OUTPUT) to every text call. Image and mockup calls use flat per-render pricing. The running session cost is tracked in localStorage under nicheforge_cost and displayed live in the Sidebar.

Verified pricing constants

Image pricing — flat per render

Per-design cost — calculated from verified inputs

Each complete design run executes 4 to 6 sequential AI calls plus 3 parallel mockup calls. Token estimates below are derived from measured prompt lengths in the source code.

Scaled projections — at 20 designs per day, 2K image, no mockups

From AI render to Printful draft. One click.

This is the architectural feature that distinguishes NicheForge from the other two DDS AGI Suite flagships. Sovereign Orchestrator Pro publishes social content. The Synthetic Director produces creative output for human review. NicheForge pushes commerce-ready product drafts directly into the fulfillment pipeline. The bridge is built from three pieces: the Express proxy, the Printful service module, and the verified product catalog.

Piece 1: server.js — the 48-line Express proxy

Running on port 3025, server.js (48 lines) handles every Printful API call. Its two jobs:

• Credential security. The VITE_PRINTFUL_ACCESS_TOKEN is loaded into the server process from environment variables and attached to outgoing Printful requests server-side. It never enters the React bundle. Verified at server.js:10-15.
• CORS bypass. The Printful Admin API does not allow direct browser calls. Vite's dev proxy configuration at vite.config.ts:12-20 rewrites /api/printful through the Express server, which has no such restriction.

Piece 2: printfulService.ts — the API client

The Printful integration module at src/services/printfulService.ts (235 lines, 11,104 bytes) handles store discovery, canvas resizing for print-area dimensions, and product draft creation. When the operator clicks "Publish" in the AssetLibrary UI, this module:

• Looks up the target product in src/constants/printfulCatalog.ts to retrieve the exact print-area dimensions in pixels at 150 DPI.
• Resizes the AI-generated design canvas to match the print area without distortion.
• Constructs the JSON payload required by the Printful product-draft endpoint, including all SEO metadata generated in step S6a.
• Sends the payload through the Express proxy.
• Returns the Printful draft ID to the React app for display.

Piece 3: printfulCatalog.ts — the 6-product catalog

The catalog at src/constants/printfulCatalog.ts (60 lines) maps 6 verified DDS products to their Printful catalog IDs and exact print-area dimensions at 150 DPI:

The Shopify path — indirect

NicheForge does not call the Shopify Admin API directly. Instead, the Printful product draft includes a Shopify push configuration that lives on the Printful side. When the draft is approved on Printful, Printful's own integration handles the push to the connected Shopify storefront. This is a deliberate architectural choice: the operator owns one authentication context (Printful) and one API surface, not two. Shopify push happens, but through Printful's webhook system rather than direct API call.

Image Validation Guardrails

Before any image is allowed to reach the Printful draft step, it passes through src/services/validationService.ts (76 lines). The validator enforces:

• Minimum dimension of 1,500 pixels — below this, the image will not print acceptably at apparel scale.
• Transparency detection — ensures the background is either pure white or transparent, depending on product type.

This is the guardrail that prevents low-quality drafts from reaching the fulfillment pipeline. An image that fails validation is rejected with a user-visible error before any Printful API call is made.

What it would cost to rebuild this from scratch.

The forensic audit estimates rebuild cost across three builder profiles. This is methodology, not a real contractor quote. Every estimate covers code authoring only and excludes the iterative prompt-engineering refinement that defines the system's actual IP. A reader should adjust each tier to their local market — the math is transparent enough that doing so takes minutes.

The leverage ratio against human capital

NicheForge replaces four distinct professional roles across the design and commerce pipeline. Salary estimates are US national medians sourced from BLS and Glassdoor for mid-level positions. Each role is anchored to a specific function in the codebase.

Six known scaling limitations. None of them hidden.

The forensic audit Section 10 (Security Model) and Section 13 (Scaling Vectors) document the limitations of NicheForge as designed. None of these are flaws — they are the architectural consequences of building a single-operator, browser-first tool. Each one becomes a load-bearing decision when planning a transition to multi-user, multi-instance deployment.

Five architectural decisions worth studying.

NicheForge is the third case study in the DDS Vibe Academy curriculum. The first two (Sovereign Orchestrator Pro, The Synthetic Director) document different single-operator AGI patterns. This one documents the commerce-attached pattern. Five decisions in this codebase are worth studying for any apprentice building their own first AGI-grade tool.

Lesson 1: Pick the right abstraction layer

Browser-native IndexedDB eliminates database hosting costs entirely. The system has no AWS RDS, no Supabase, no Firestore — just a single auto-incrementing assets table in the operator's browser. This is a deliberate constraint that pays for itself every month. The smallest backend that fits the problem is almost always the right backend. A second operator on a second machine would change this calculus — but until then, a 12-line db.ts outperforms a hosted database in every metric the operator cares about.

Lesson 2: Treat prompt engineering as the actual IP

The React components are interchangeable. The 30 archetypes, 15 mutations, and 56-line Brand Bible in geminiService.ts are not. The constants are the moat. An apprentice should spend more time iterating on these constants than on the surrounding UI. The signal-to-noise ratio of refinement work is dramatically higher in the prompts than in the components.

Lesson 3: Cascade your models

One model for everything is a beginner pattern. Four models tiered by cost and quality is a production pattern. Draft cheaply. Validate at mid-tier. Commit at top tier. The same niche input that produces a $0.04 Draft image during ideation produces a $0.32 4K render at commit time, with zero code changes. The cascade gives the operator a 8x operating-cost range purely through model selection in the UI.

Lesson 4: Build resilience into the pipeline, not around it

The retry engine at geminiService.ts:28-71 wraps every Gemini call, not just the ones the developer remembered to wrap. The Zeitgeist Radar has a heuristic fallback. The Error Boundary catches unhandled React errors. The Express proxy handles Printful CORS without leaking secrets. Resilience is not a feature you add later — it is the spine the application is built around. An apprentice who skips this step ships a tool that breaks on the first 429 response.

Lesson 5: Document your evidence honestly

This case study has a verified production-artifact window (8 weeks) and an extended testimony window (6 months). It distinguishes between the two on the page rather than collapsing them. "Some evidence is stronger than other evidence" is not a flaw to hide — it is a methodology to publish. An apprentice publishing their own case study should label each claim with the evidence tier (Verified / Calculated / Inferred / Testimony) and let the reader weigh them accordingly. The DDS Vibe Academy refuses the bury-the-gaps approach common to builder marketing because it produces case studies that survive forensic audit.

Fifteen questions. Every answer traceable to file:line.

Each answer below mirrors the FAQPage JSON-LD schema in the page head exactly, so search engines and AI assistants pull the same content the page presents. Each one is anchored to either a verified file path or the Antigravity Forensic Audit dated May 15, 2026.