Forem: Yann_

How I Built a Legal Document Generator for French Small Businesses

Yann_ — Fri, 03 Apr 2026 20:49:29 +0000

I'm a solo developer shipping SaaS products for the French market. One of my recent builds is Auto-DUERP — a tool that generates a mandatory workplace risk assessment document (called "DUERP" in France) that every employer must have.

Here's the story of why I built it, and the technical decisions behind it.

The problem

In France, every company with at least one employee must produce a DUERP (Document Unique d'Evaluation des Risques Professionnels). It's a legal obligation since 2001.

The reality? Most small business owners either:

Pay 200-500 EUR to a consultant for a generic template
Download a random Word file from the internet and hope it's compliant
Simply don't have one (and risk fines up to 10,000 EUR)

I saw an opportunity for a self-service tool at 49 EUR — 4-10x cheaper than a consultant, but actually tailored to their specific industry.

The stack

I used the same monorepo setup I use for all my products:

Next.js 16 (App Router) with TypeScript
Tailwind CSS for styling
Prisma + PostgreSQL for data
Stripe for payments (one-shot, no subscription)
@react-pdf/renderer for PDF generation
Gemini API for AI-powered risk suggestions

The monorepo also hosts SCI Facile (a tool for creating French real estate companies) and LMNP Facile (rental property tax filing). Shared auth, shared Stripe integration, shared UI components.

How it works

1. Sector-specific data

I compiled risk data for 34 professional sectors from INRS (France's national occupational safety institute). Each sector has pre-filled risks, prevention measures, and severity ratings.

A restaurant owner doesn't see the same risks as an electrician. This is the key differentiator vs. generic templates.

2. The 5-step wizard

The user flow is intentionally simple:

Company info — name, SIRET, sector, employee count
Work units — define areas/departments
Risk identification — AI suggests risks based on sector, user validates/edits
Prevention measures — existing and planned measures
Review & generate — preview, pay, download PDF

No account required. Privacy-first: we don't store personal data after PDF generation.

3. PDF generation

The hardest part was making the PDF look professional. @react-pdf/renderer is powerful but has its quirks — no CSS grid, limited flexbox, font loading issues.

I ended up building a custom PDF template with:

Company header with logo
Risk matrix (severity x probability)
Color-coded risk levels
Prevention action plan with deadlines
Legal compliance footer

4. AI-assisted risk identification

When a user selects "Restaurant" as their sector, the AI pre-fills common risks (burns, slips, repetitive strain, etc.). But it also adapts based on the specifics — a restaurant with a terrace has different risks than one with only indoor seating.

I use Gemini for this because the cost per generation is negligible at our volume.

SEO as the growth engine

No ads budget. No sales team. Just SEO.

I built programmatic pages for:

Every sector (/secteur/restaurant, /secteur/electricien, etc.)
Major French cities (/ville/paris, /ville/lyon, etc.)
A glossary of workplace safety terms

This gives us ~500 indexable pages from day one. The same strategy I used for my comparison sites — but applied to a SaaS product.

Results so far

Live in production in 10 days from idea to launch
Indexed by Google within 48 hours (thanks to IndexNow)
First organic traffic within a week

The one-shot pricing (49 EUR) means no churn to worry about. Each customer is profitable from day one.

Lessons learned

Legal products need trust signals. Security headers, legal pages, HTTPS — the basics matter more when you're selling compliance tools.
PDF generation is underrated as a moat. Most competitors offer Word templates. A polished, auto-generated PDF feels 10x more professional.
Monorepo saves weeks. Sharing auth, payments, and UI across Auto-DUERP, SCI Facile, and LMNP Facile meant I only had to build the domain-specific logic.
AI is the seasoning, not the dish. The real value is the sector-specific data and the compliance structure. AI just makes the UX smoother.

If you're building for a regulated market, don't underestimate the power of "making the boring thing easy." Nobody wants to write a DUERP. But everybody has to.

That's where the money is.

I ship 15 web products solo — here's my AI-assisted workflow

Yann_ — Wed, 25 Mar 2026 12:48:12 +0000

I'm a solo developer running 15 web products in production. SaaS tools, programmatic SEO sites, an npm package, a brand kit generator. No team, no cofounder, no agency. Just me, a standardized stack, and Claude Code as a copilot embedded in every step of the pipeline.

This is not a "look how smart I am" post. Half of these products make zero revenue. But the system that lets me ship them fast, maintain them, and kill the losers early — that part works. Here's how.

The factory mindset

I call my system "L'Usine" (French for "the factory"). It's a monorepo of markdown files, shell scripts, checklists, and prompt templates that wraps around Claude Code. The idea is simple: standardize everything so the AI can be useful.

When every project uses the same stack (Next.js, TypeScript, Tailwind, Prisma, Stripe), the same file structure, and the same conventions, the LLM doesn't have to guess. It knows where the DB singleton lives. It knows "use client" goes on leaf components only. It knows select not include on listing pages.

The whole pipeline is one command: /build. It walks through phases — Discovery, Spec, Design, Scaffold, Code, QA, Ship — with a gate at each step. The AI proposes, I decide.

What a real session looks like

Here's an actual example. I needed LMNP Facile, a one-shot tool that generates French tax declarations for rental property owners. 49 EUR, no subscription, peak season in April-May.

Prompt I gave Claude Code:

/build new
SaaS one-shot 49 EUR. Generates LMNP tax declarations (cerfa 2031/2033) for French micro-BIC landlords. User inputs property info + rental income, app generates pre-filled PDFs ready to submit to tax authorities.
Target: non-accountant landlords who don't want to pay 500 EUR/year for an expert-comptable. Season: April-May.

Claude walked me through Oracle scoring (PAIN 22/25, MONEY 20/25), generated the brief, built the Prisma schema, scaffolded routes with the standard template. The whole spec-to-scaffold phase took about 90 minutes of interactive work.

Then for the code phase, Claude worked inside the project directory with its own AI-CONTEXT.md — a machine-readable spec file that keeps the LLM on track across sessions. No "remind me what this project does." The context is always there.

The multi-agent harness

For more ambitious builds, I use a multi-agent architecture: three separate Claude processes chained via a bash script.

Planner (1M context) → plan.md → Generator (1M context) → code → Evaluator (1M context)
↑ |
└── feedback if FAIL ──────────┘

Each agent gets a fresh 1M-token context window. No pollution between them. The planner generates an ambitious feature list. The generator builds it feature by feature. The evaluator runs npm run build, reads the code, and scores it across functional completeness, infrastructure (security headers, Prisma indexes, SEO setup), and design quality.

If the score is below threshold (default 7/10), the evaluator's feedback loops back to the generator for another round. If the score stagnates after two rounds, the system kills the loop — because a fresh context will do better than patching a degraded one.

This is not autonomous AGI magic. It's structured prompt engineering with file-based communication. But it lets me prototype a full SaaS in hours, not days.

The 682-line QA checklist

Here's the thing nobody tells you about AI-generated code: it compiles but it doesn't ship.

The LLM will forget security.txt. It will use <img> instead of next/image. It will slap shadow-2xl on every card and bg-gradient-to-r from-purple-500 to-pink-500 on every heading. It will skip @@index on your Prisma userId fields. It will put Stripe secret keys in NEXT_PUBLIC_ variables.

So I built a 682-line QA checklist organized in three tiers:

T1 BLOQUANT (24 items) — no deploy without these. Legal pages, security headers, robots.ts blocking AI bots, poweredByHeader: false, correct French accents in all data.
T2 CRITICAL (first week) — structured data, OG images, Prisma select on listings, font display: "swap", loading skeletons.
T3 GROWTH (month 1-3) — CRO, content scaling, domain authority.

The evaluator agent in the harness grades against this checklist automatically. In my manual workflow, I run /qc which loads the checklist and audits the project. It catches things like: "you have 437 occurrences of missing French accents in your data files" (true story from one of my programmatic SEO sites).

I also maintain a design knowledge base extracted from auditing Linear, Vercel, and Stripe. It defines exact shadow hierarchies (shadow-sm for cards, shadow-xl for modals only), radius rules, transition durations (150ms for color, 200ms for transforms), and a list of things elite products never do. This is what keeps the output from looking like a free template.

The `/sample` command: parallel exploration

When I need creative variation — landing pages, UI components, pricing sections — I use /sample. It launches N parallel Claude agents, each in an isolated git worktree, each with a different creative brief.

Example: /sample 3 "LP minimaliste SaaS facturation" generates three candidates:

A: Minimal radical (inspired by Resend, near-zero color)
B: Warm and accessible (inspired by Notion, serif headings)
C: Data-driven and dense (inspired by Linear, dark option)

After generation, deterministic checks run on each: build pass/fail, TypeScript errors, grep for AI-slop patterns (shadow-xl, hover:scale-105, animate-bounce). Then I compare and pick. Or cherry-pick elements from multiple candidates.

I used this heavily for LeCapybara, which is now my gold standard — every new project clones its patterns.

What actually works and what doesn't

Works great:

Scaffolding. Going from idea to running npm run dev with auth, DB, Stripe, SEO setup in under 2 hours.
Repetitive infrastructure. Security headers, sitemap generation, structured data — the LLM nails this when given a checklist.
Programmatic SEO at scale. I run 10 comparison sites covering French B2B software niches. Same template, different data. AI generates the initial content, Indxel (my own npm package / SEO crawler) validates quality.
Brand generation. OneMinuteBranding started as an internal tool to generate brand kits for my own projects. Then someone paid 49 EUR for it.

Doesn't work (yet):

Revenue. 147 EUR total across 15 products. The factory ships fast but distribution is the bottleneck.
Design taste. The LLM's default aesthetic is "startup template from 2022." Without the design KB and the anti-slop patterns, every output looks the same.
Complex business logic. Tax calculation rules, regulatory compliance, financial formulas — these need manual verification every time.

The uncomfortable truth

I built an elaborate system to ship products fast. But "shipping fast" is the easy part. Finding paying customers is the hard part, and no amount of AI assistance changes that.

The system does give me one advantage: I can afford to experiment. When you can go from idea to production in a weekend, you can test 15 ideas and see what sticks instead of betting everything on one. Two products have actual sales. Most have growing search traffic. The factory is young.

If you want to try something similar, start with the boring parts: standardize your stack, write down your conventions in a machine-readable format, build checklists for the things you keep forgetting. The AI gets dramatically better when it has guardrails.

You can find my work at yann-lephay.com. The factory keeps shipping.

I built a CLI that fails your build on broken SEO

Yann_ — Thu, 12 Feb 2026 11:14:00 +0000

Last week, I spent two hours copy-pasting data from Screaming Frog into my CLI so Claude could analyze the issues and suggest fixes. One page at a time. Like it was 2014.

Then I thought: there has to be an API for this. I found DataForSEO. Went to sign up. They asked me to explain why I wanted access — like I was applying for a loan, not an API key. I closed the tab.

That's when I decided to build my own tool.

The problem nobody talks about

Here's what happens to most developers: you ship a site, it looks great, traffic comes in. Then one day you refactor a layout, or you update a CMS, or you deploy a new page — and silently, without any warning:

A meta description disappears
An og:image starts returning 404
Structured data breaks because someone renamed a field
A page accidentally gets noindex

Nobody tells you. There's no error in the console. No failing test. No red CI badge.

Three weeks later, traffic drops. You check Google Search Console. Half your pages lost their rich snippets. The og:image that's been broken? That was your most shared page.

SEO breaks silently. That's the entire problem.

What if your build just... failed?

I wanted something dead simple. Like ESLint, but for SEO. You run a command, it tells you what's broken, and in CI mode it exits with code 1 so your build fails before broken SEO reaches production.

npx indxel check

  Found 12 pages

  /                 95/100  A
  /pricing          88/100  B
  /blog             91/100  A
  /blog/my-post     62/100  D
    ✗ Missing og:image
    ! Title too short (42 chars)
  /about            90/100  A

  Score: 85/100 (B)
  Pages: 11/12 pass
  1 critical issue.

30+ rules, zero config, 30 seconds. It checks title and meta description (presence + length), Open Graph tags, canonical URLs, structured data (JSON-LD), robots directives, Twitter cards, viewport meta, favicon, and hreflang for multi-language sites.

Each rule has a point value. Total score out of 100. Letter grade. You know exactly where you stand.

The CI/CD guard

This is the part I'm most proud of. One flag and your SEO is protected on every deploy:

npx indxel check --ci

It runs the same audit, but exits with code 1 if there are critical errors. Plug it into GitHub Actions:

name: SEO Check
on: [pull_request]
jobs:
  seo:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npx indxel check --ci

Or into your Vercel build:

{
  "scripts": {
    "build": "npx indxel check --ci && next build"
  }
}

Broken SEO never reaches production. That's the promise.

SEO diff between deploys

This one came from my own frustration. I'd fix 3 issues, deploy, then realize I'd introduced 2 new ones. So I added:

npx indxel check --diff

Score: 78 → 83 (+5)

IMPROVEMENTS (2):
  + /pricing  82 → 88
  + /about    85 → 90

REGRESSIONS (1):
  - /blog/my-post  70 → 62

Git diff, but for SEO. You see exactly what improved and what regressed since the last check.

It also works with AI

Indxel ships as an MCP server, which means Claude, Cursor, and other AI assistants can audit your SEO while you're editing code.

Instead of copy-pasting from Screaming Frog into your AI tool (like I was doing last week), you just ask:

"Check the SEO on /pricing"

Claude runs the audit and tells you your og:image is broken. Without leaving your editor.

{
  "mcpServers": {
    "indxel": {
      "command": "npx",
      "args": ["indxel-mcp"]
    }
  }
}

That's the full setup for Claude Desktop or Cursor. It's a small thing, but it closes the loop — the same tool that guards your CI also powers your AI assistant.

Why I'm sharing this

I use AI tools heavily, I build things to solve my own problems, and I ship fast. I built Indxel in 1 week.

I'm sharing this because the problem is real and I know I'm not the only one who's been burned by silent SEO regressions. If you've ever deployed a site and found out weeks later that half your pages had no meta tags — this is for you.

The npm package and CLI are MIT licensed, free forever. There's a paid dashboard for monitoring and indexation tracking, but the core tool will always be open source.

Try it now — takes 30 seconds, no signup:

npx indxel init

GitHub: github.com/indxel/indxel
npm: npmjs.com/package/indxel
Site: indxel.com

What SEO checks would you add? What did I miss? Drop a comment or open an issue on GitHub.