Building NichePressa: An AI Publishing Engine for Catalog-Based Websites

NichePressa is the biggest product I have built so far.

It started as a personal experiment. I wanted to understand whether I could use AI to build niche sites, publish useful articles, and get real SEO traffic without manually writing every page from scratch.

The first version was not a SaaS product. It was me, ChatGPT, images, Markdown files, and a lot of manual publishing. I started with Game Foundry because I was curious about gaming content and SEO. Then I created more gaming sites. At first, the workflow felt exciting. AI made content production faster, and I could test ideas quickly.

The experiment worked. Game Foundry went from zero to roughly 62k impressions in three months — real search traffic, not a slide-deck projection.

But after a while, the process became messy.

Each site had its own tone. Each article needed a content plan. Each image needed manual work. Each publish step took focus. The more sites I added, the more I realized that the hard part was not "write me an article." The hard part was building a repeatable editorial system.

So I started creating internal JSON content plans inside each blog. I used Cursor to generate drafts from those plans, refined the output with GPT, cleaned the content, and published manually. That helped, but it still lived inside scattered project folders and one-off workflows.

Then I started building more serious sites like WattMatch and Brew Ritual. Clients also started asking if they could use the tool behind the scenes. That changed the problem. I no longer needed a private hack for myself. I needed one internal system that could support many different sites, many voices, many catalogs, and many publishing flows.

After roughly six months of building, testing, breaking, and refining that process, I decided to turn the internal engine into NichePressa.

NichePressa is not a generic AI article writer. It is an AI-assisted publishing system for niche websites.

Generic AI writing tools are useful at the beginning. They are terrible as a long-term publishing system.

When I was only creating one article at a time, ChatGPT was enough. But once I had multiple sites, product data, different voices, reusable components, and SEO plans, the cracks became obvious.

The same problems kept coming back:

The voice drifted between articles. One post sounded sharp, another sounded generic, another sounded like default AI marketing copy.

Product facts were fragile. If an article mentioned specs, prices, features, or comparisons, I could not trust the model to stay inside the real data unless I carefully fed it the right context.

The work did not compound. Every new article felt like starting again. Product data, site tone, internal rules, and reusable components were not properly shared across the whole publishing workflow.

Publishing was still manual. Even if AI helped write the article, the final output still had to become MDX, include frontmatter, use the right components, and land inside the correct GitHub repo.

That was the real product problem.

I did not need "AI writes blog posts."

I needed a system that could understand a site, remember its voice, use structured catalog data, plan content before generation, produce MDX, preserve custom components, and push the final artifact to the owner's codebase.

I built NichePressa as a full-stack SaaS product, not a script wrapped in a UI.

The app uses Next.js, React, TypeScript, Tailwind, Supabase Auth, Supabase Postgres, Drizzle ORM, Stripe, Cloudflare R2, Sharp, Sentry, Octokit, and Render.

The important decision was not just the framework. It was the shape of the system.

NichePressa needed to support real workspaces, user authentication, billing, quotas, catalog imports, article states, prompt sections, model routing, media storage, GitHub publishing, and tenant isolation. That meant the architecture had to be clean enough to keep growing.

For the AI layer, I did not want feature code directly calling OpenAI, Anthropic, or Gemini everywhere. Every model call goes through a central LLM router. The app uses different prompt keys for different jobs: content generation, editorial pass, content planning, voice analysis, voice refinement, cover prompts, image generation, and onboarding prompt-section generation.

That gives the product flexibility. If one model is better for voice analysis and another is better for long-form generation, I can route them differently without rewriting the feature.

The goal was simple: make AI part of the system, not the system itself.

NichePressa is built around one core idea: separate the publishing workflow into clear layers.

The main layers are:

Voice → Catalog → Planning → Generation → Publishing

Each layer owns a different part of the process.

The voice layer captures the site's editorial identity: niche, audience, stance, vocabulary, persona, and writing rules. This becomes reusable context for future articles instead of being recreated from scratch every time.

The catalog layer stores structured items like products, games, tools, locations, services, or generic entities. For affiliate and product-driven sites, this is critical. A catalog should not be a messy blob dumped into an AI prompt. Fields need to be reviewed, mapped, and controlled.

The planning layer creates structured briefs before generation. This includes title, slug, keywords, search intent, outline, selected items, must-cover points, and component usage. The user reviews the plan before spending generation tokens.

The generation layer turns an approved brief into an article draft. It builds the prompt from workspace context, active prompt sections, selected catalog fields, planner instructions, and registered MDX components.

The publishing layer serializes the article and pushes it to GitHub. NichePressa is not trying to replace the user's website or CMS. It creates the content artifact and commits it to the customer's repo.

That flow matters because niche publishers do not only need content. They need control.

The hardest part was making AI reliable enough for a publishing workflow.

A normal AI tool can fail quietly. It can invent a product detail, leak prompt language, ignore a component rule, or produce an article that looks fine but does not match the site.

NichePressa needed guardrails around that.

The first major decision was catalog-first prompting. Instead of asking the AI to "write about these products" from a messy import, the app controls exactly which item fields enter the prompt. This reduces noise and keeps the model closer to approved data.

The second decision was planner before generator. I did not want the product to jump straight from idea to full article. The planning step gives the user a cheaper and safer review point. If the selected items, outline, or search intent are wrong, the user can fix the plan before generating a long draft.

The third decision was using registered MDX components as first-class content tools. A workspace can define custom components with tag names, prop schemas, and usage guidance. The planner can choose where components should appear, and the generator can embed them into the article. Validation then checks that the output uses allowed components and valid item slug props.

This is especially useful for sites like WattMatch, where articles are not just text. They can include comparison blocks, calculators, product cards, or other custom JSX-driven content.

The fourth decision was a central LLM router. Different AI tasks need different models. Voice synthesis, article writing, editorial cleanup, planning, and image generation are not the same job. Routing them through one layer keeps the product flexible and easier to operate.

The fifth decision was tenant isolation through Postgres RLS. I did not want workspace security to rely only on remembering to add workspace_id filters in application code. User-facing database paths run through a transaction wrapper that sets the authenticated role and workspace context. RLS policies enforce the boundary.

That added complexity, but it made the product safer.

NichePressa's AI pipeline is not one big prompt.

It is a set of smaller, controlled jobs.

Voice analysis creates the editorial identity. Prompt-section generation creates reusable instructions for system behavior, SEO, formatting, editorial rules, and cover image rules. Content planning creates structured briefs. Article generation creates the draft. The editorial pass improves the body without rewriting the frontmatter or breaking MDX. Cover generation creates a matching image.

The prompt builder assembles content from multiple layers:

- workspace context

- active prompt sections

- frontmatter template

- domain terms

- SEO and editorial context

- selected catalog items

- planner brief data

- registered component usage

It also marks user data as factual context, not instructions. That helps reduce prompt injection risk from imported catalog content.

After generation, the output goes through hardening steps. There is post-processing for frontmatter and formatting issues. There is a cleanup pass for pipeline meta-language, because strict anti-fabrication prompts can sometimes cause models to write awkward phrases like "based on the provided data" inside reader-facing content. There is also an editorial pass that protects frontmatter, MDX tags, links, and custom blocks.

This is the kind of problem that only appears when you build a real AI product. The demo works quickly. The production version needs cleanup, validation, and boring safeguards.

The main next step is making the content workflow even more unified.

Right now, manual article creation and planner-based article creation are separate enough that they create some product friction. I want one cleaner "create content" flow that still supports advanced control when needed.

I also want to improve internal linking. The brief schema can already reference internal links, but the product needs a stronger internal link registry so NichePressa can plan and place links in a controlled way, similar to how it handles MDX components.

Another area is article-format control. A glossary snippet and a long buying guide should not share the same generation limits. Per-format word ranges would make the product sharper.

Vocabulary handling also needs more runtime flexibility. Some vocabulary is baked into prompt sections during voice acceptance, but future edits should affect generation more directly.

These are not signs that the product is unfinished in a bad way. They are signs that the product is real. Real systems expose real tensions.

I designed and built NichePressa end to end.

That included the product concept, onboarding flow, workspace model, catalog system, import pipeline, content planner, article desk, AI routing layer, prompt assembly, post-generation cleanup, MDX validation, GitHub publishing, Stripe billing, quota system, media storage, authentication, RLS-based tenancy, admin model routing, and deployment setup.

I also used AI heavily while building it. Cursor and LLMs helped me move faster, generate code, explore architecture options, and handle repetitive implementation work.

But the important decisions were still engineering decisions.

AI could help write code. It could not decide the product boundaries. It could not decide that catalog fields need prompt permissions. It could not decide that planning should happen before generation. It could not decide how "published" should work when the real deployment belongs to the customer's GitHub pipeline.

That was my job: turning a messy AI-assisted workflow into a real product system.

NichePressa turned a scattered personal publishing workflow into a reusable SaaS platform.

What started as manual ChatGPT prompting, local content plans, Cursor-assisted drafts, and manual publishing became a full editorial system for niche sites.

The product now supports workspace onboarding, reusable voice capture, catalog imports, field-level prompt control, structured content planning, multi-model article generation, editorial cleanup, cover generation, MDX output, GitHub publishing, billing, quotas, and tenant isolation.

It is still evolving, but it is already far beyond a prototype.

The most important outcome is that NichePressa captures the full loop:

set up the site → define the voice → structure the data → plan the content → generate the draft → review the article → push it to the repo

That is the difference between an AI writing tool and a publishing system.