• May 27, 2026
  • 6 min read

A Landing Page Pipeline That Refuses to Ship a Bad Offer

Part 1 of a three-part series. Next: above the fold in five seconds and a heat-pump sensor kit offer I never launched.

Most landing pages I’ve seen fail for reasons that have nothing to do with code. The offer is vague, there’s no guarantee, the hero describes the company instead of the result, and the form goes nowhere. A nicer template doesn’t fix any of that.

So in May 2026 I wrote down a pipeline that does it in the other order: fix the offer first, then let the page be generated from it. And if the offer can’t be fixed, don’t build the page at all.

The pipeline

flowchart TD
    I[00 Intake<br/>8 questions + 2 filters] --> H[01 Offer review<br/>7 moves]
    H -->|kill switch fires| X[Stop: fix the offer]
    H -->|go| S[02 site.md<br/>every word on the page]
    S --> P[03 Preset + 04 Scaffold]
    P --> C[05 Capture + 06 Deploy + 07 Security]
    C --> L[Live URL]

Eight Markdown files, one per step, each saying what goes in, what comes out, and how long it should take. The target was idea to live URL in under two hours, with filling in the copy as the slow part.

Step 0: two questions before anything else

The intake is eight ordinary questions: the offer in one sentence, revenue, pricing, channels, the founder’s strongest skill, the ideal customer as one real person, the obvious competitor, the biggest constraint. Two more questions decide whether to continue at all:

  • “If I doubled your leads tomorrow, could you handle them?” If not, the problem is delivery, not marketing, and a landing page is premature.
  • “Should I assume your position is right and tell you how to do it, or tell you what I actually think?” Someone who wants validation, not advice, won’t act on the review. Stop there.

The second one is a sorting question from Alex Hormozi’s material, and it’s the same filter I use in my ebooks funnel. It also sits next to the discovery questions I ask before any data project: find out what the person needs before building.

Step 1: review the offer, with a kill switch

The review is seven moves, adapted from Hormozi’s books on offers and leads:

  1. Shape: product, service, education or software. A page can only sell one.
  2. Five traits, scored 1–10: sticky, expensive, expanding market, low capital needed, unique.
  3. Ideal customer in one sentence, plus a pricing pick: cheap and templated, or premium. Not the middle.
  4. The offer: value equation, a specific name, a guarantee with real terms.
  5. Three tiers: an entry offer, the core, and a next step.
  6. The funnel as three steps, plus a lead magnet.
  7. Trust: a “most people do X, I do Y” contrast, damaging admissions, FAQ, and an honest inventory of proof.

Move 2 is where it can stop:

TotalDecision
35+build the page
30–34build, but say the weakness out loud on the page
under 30stop; redesign the offer first

And independently of the score, it stops if two or more fatal disqualifiers fire: no defined customer (“everyone”), mid-priced services for small businesses, a founder who won’t put a real guarantee in writing, plans to scale ad spend without attribution.

That’s the feature, not a limitation. A good-looking page on a broken offer wastes everyone’s time, including mine.

Step 2: one file drives the whole page

Everything a visitor reads comes from site.md: YAML front matter for the structured parts, Markdown sections for the prose.

hero:
  headline: "…the result, not the product"
  without:
    - "Without …"            # 2–4 specific pains
  cta_label: "Verb + outcome"
  risk_reversal: "…"         # the guarantee in 15 words or fewer

guarantee:
  type: "conditional"        # unconditional | conditional | anti
  terms:
    - "Outcome: …"
    - "Window: …"
    - "Failure: …"

pricing:                     # exactly three tiers
  - tier: "onramp"
  - tier: "core"
  - tier: "continuity"
## damaging_admissions

- **This isn't for you if…**

Change a headline, a price or an admission: edit one file, the page updates. The footer, the terms page and the privacy page come from Markdown too (tc.md, privacy.md), rendered in the same design, so the legal pages never look like an afterthought.

The rules the page has to pass

The point of putting the copy in a schema is that the schema can refuse it. A page doesn’t pass unless:

  • the offer has a specific name with all five parts;
  • the hero has 2–4 specific “without” pains;
  • the risk reversal is 15 words or fewer;
  • the guarantee has a type and at least one precise term;
  • there are three value cards and three funnel steps, none repeated;
  • there are exactly three pricing tiers, each with a value stack;
  • the damaging admissions section is not empty;
  • the footer links to the terms and privacy pages.

It’s the same idea as the validator in my Formbricks skill: an agent can write the copy, but a script decides whether it’s complete. Not vibes.

The boring must-haves

Things I’d written down from earlier landing pages, and put into the blueprint so I wouldn’t forget them again:

  • The dev server listens on the LAN, so I can check the page on a phone.
  • Every external link opens in a new tab.
  • Analytics is one environment variable. Empty means no script at all, with no console warnings. Umami, Plausible and similar tools all use the same data-website-id attribute, so the script URL is a second variable.
  • Security headers ship with the page (_headers: CSP, HSTS, no framing).
  • One command ships it: clean, build, deploy, print the URL. The share preview gets checked before the link goes anywhere.

What I actually built

One page, as a test: a sensor kit for homeowners weighing a heat pump. Vite, React, Tailwind and GSAP, deployable to Cloudflare Pages. It built cleanly, and building it fixed several things in the spec:

  • gray-matter doesn’t belong in the browser. It needs a Buffer polyfill and bloats the bundle. A five-line regex to split the front matter plus js-yaml does the same job.
  • Importing Markdown as text in strict TypeScript needs a vite-env.d.ts declaring *.md?raw, or the build fails.
  • One 700-line App.tsx with every section inline was easier to work in than a dozen component files, at this size.
  • About 165 kB gzipped with GSAP, Markdown rendering and icons. Over Vite’s warning, fine for a test page.
  • Every pricing button pointed at the same booking link. Separate links per tier would show which tier people actually click.

What’s still on paper

Being honest about the state of it:

  • The validator was specified, not written. The rules above are a checklist I applied by hand.
  • The capture layer was specified as Formbricks → Worker → PocketBase, and never built. By then I’d already started moving away from Formbricks; my forms later went to my own Worker and one lead store.
  • The two-hour target was never timed. The offer review alone takes longer than its 45-minute budget when the offer is new.
  • No template repo. The first page became the template: copy it, replace the content.

What I’d keep is the order: offer, then copy, then page. And a review that is allowed to say “don’t build this”.

Takeaways

  • Fix the offer before the page. Templates don’t fix offers.
  • Give the review a kill switch, and mean it.
  • Put every word in one file so a schema can check it.
  • Make the honest parts mandatory: a guarantee with terms, and damaging admissions.
  • Build one real page before writing the tooling. It corrected the spec in a day.