P/03 · Pre-launch · MIT # AstroEdge: Landing pages that know who's visiting — personalized at the edge. Landing pages personalized per visitor at the edge. - Pre-launch - Built in the open - Cloudflare Pages - Cloudflare D1 - MIT license What is AstroEdge? AstroEdge is a landing page engine that runs on Cloudflare's edge network. You describe a page in plain language, and it composes one from a locked set of sections and design tokens. Visitor personalization — name, A/B variant — happens in the response stream before the browser receives the HTML. No flicker, no client script, no server to manage. Describe a page or pick a template. AstroEdge composes it from seven locked sections and a single design token file, then personalizes it per visitor in the edge response — ?firstName=Mike becomes "Hi, Mike" before the HTML reaches the browser. No flicker. No drift. No server to manage. Honest note: AstroEdge is pre-launch. The engine works end to end. What you won't find here is a wall of customer logos — there aren't any yet. This is a real product, built in the open, still early. The problem ## AI is good at writing a landing page once. It's bad at writing the same page twice. Ask a model for a hero section three times and you get three different layouts, three color schemes, and a button that moved. That's fine for a mockup and a problem for a brand. Personalization makes it worse. The usual fix — swap text with client-side JavaScript — means the visitor sees the generic version first, then a flicker as it rewrites. Search engines and link previews see the generic version and cache it. AstroEdge takes a different path on both: the design kit is locked so the output stays consistent, and personalization runs in the edge response before the HTML reaches the browser. How it works ## Four steps. Describe, compose, configure, ship. ### Onboard your design Import a design you already have, or pick a starting palette from the gallery. Either way it lands as a locked set of tokens — colors, type, spacing, radii. ### Describe the page "A waitlist page for a coffee subscription, urgent tone, one testimonial." AstroEdge doesn't invent a layout — it composes one from seven locked sections. ### Drop in edge widgets Lead capture with spam protection and consent built in. A feedback board. An A/B test that runs at the edge with zero client JavaScript. ### Ship to the edge One command builds, lint-gates, and deploys. Personalization happens in the response stream itself — the visitor's first paint is already personalized. What's inside ## Personalization at the edge. Composition over creation. ### Personalization at the edge — not in the browser `?firstName=Mike` becomes "Hi, Mike" before the HTML reaches the browser, rewritten in the response stream by Cloudflare's HTMLRewriter. First paint is correct. No flash of generic content, no client script, nothing for a scraper to cache wrong. Every token is allow-listed, length-capped, and encoded — a name field can't smuggle in a script. ### Compose, don't create This is the core idea. Pages are assembled from seven locked sections — Header, Hero, Features, CTA, Testimonials, FAQ, Footer — each at a small set of approved variants, all sitting on one token-backed design system. Generation picks sections and variants. It never writes a novel layout, never invents a color, never reaches for an arbitrary pixel value. A lint gate fails the build if it tries. That's how you get AI speed without AI drift. ### A shelf of edge widgets — integrated, not bolted on Lead capture, a social-proof counter, a feedback board, edge A/B testing. Each one is consent-gated by default: no consent, no write, no exception. The A/B test buckets visitors deterministically and swaps content in the same stream as personalization — so there's no flicker and the analytics attribute correctly from the very first view. ### Consent the edge can enforce Most consent banners live in the browser and the server never hears about them. AstroEdge mirrors the visitor's choice into a first-party cookie the edge reads on every write. Default-deny: if the edge isn't sure, nothing gets stored. Lead capture, feedback, analytics linkage — all gated on a signal the server can verify. ### Per-link analytics, no third-party pixel Views and conversions log to your own database at the edge. Visitor IDs are anonymous and hashed; referrers are stored host-only; there's no personal data in the analytics path. You can see how a variant performs without renting a tracking script from anyone. ### Social assets, generated at the edge Open-graph images and carousel slides rendered on-brand from a page's own content, using the same design tokens. Pure JavaScript and WASM — no headless browser, no paid render service. (Honest caveat, stated plainly in the docs: personalized link previews are unreliable because platforms cache the canonical image and strip query params. The solid feature is downloadable, on-brand assets — not personalized unfurls.) ### One engine, many surfaces The whole product is a headless engine that runs on its own. A desktop cockpit, a template gallery, and a Chrome design-extractor all drive the same engine — none of them reimplements it. Build from the command line, from the desktop app, or by extracting the bones of a page you like. Same engine underneath. ### Runs on the free tier The default architecture fits inside Cloudflare's free limits, and every stage was checked against that budget. Static pages serve effectively unlimited; the edge functions are metered and the build was designed to stay well under the daily ceiling. Cheap to run is a feature, not an accident. Deep dive ## Compose-don't-create Most "AI website builder" tools let the model write whatever it wants and hope it looks good. It looks good once. Then you ask for a second page and the system has quietly drifted — new spacing, a slightly different blue, a font weight nobody chose. AstroEdge fixes that by making generation a composition problem instead of a creation problem: The result: pages that ship in minutes and still look like they came from the same company. - Tokens are the source of truth — One file defines the design. Change it once, every page updates. There is no second place a color can come from. - Sections are bounded — Seven of them, each with a handful of approved variants. The model picks from a menu; it doesn't paint on a blank canvas. - A lint gate is the hard stop — Arbitrary values, inline styles, raw hex codes, stray CSS — the build fails on all of them. Not a warning. A failed build. Designed for ## Three kinds of people this was built for If you've ever shipped an AI-built page and then spent an hour fixing the parts that drifted, this is the part that's different. ### Marketers who want personalized, on-brand landers without a ticket to engineering for every variant. ### Solo founders who need fast pages that don't look AI-generated and don't cost anything to run. ### Agencies that want a locked system so every page across every client stays on-brand. How I built it ## About the build AstroEdge was built solo, in the open, by one marketer who codes — not a team, not a funded startup. The interesting part is how: most of the code was written by Claude Code agents, but every decision — the architecture, the security model, the design lock, what to cut — was a human one. It ran as 44 stages, one commit each, with a named cast of agents at different capability tiers, phase gates that didn't open until the work behind them was verified, and a review step before every high-stakes change. Less "let the AI vibe a website" and more "manage AI like a team that needs a manager." If that approach is interesting to you — as a user, a collaborator, or otherwise — the door's open. FAQ ## Common questions ## faq **Is this another AI website builder?** Sort of, but backwards. Most of them let AI design freely and you clean up the drift. AstroEdge locks the design first and lets AI only compose within it. Speed of AI, consistency of a design system. **What does "at the edge" actually mean?** Your page is served from Cloudflare's network, close to the visitor, and the personalization happens in that same response — not in a round-trip to a server, not in the browser after load. It's fast because there's no second step. **Do I need to know how to code?** To use the engine through the plugin: you describe pages in plain language and pick templates. To self-host and ship: you'll run a couple of commands. It's not no-code, but it's close to describe-and-ship. **Is my visitors' data safe?** Writes are consent-gated by default-deny, SQL is parameterized, personalization input is sanitized and encoded, visitor IDs are anonymous and hashed, and referrers are stored host-only. There's no third-party tracking pixel in the default build. **What does it cost to run?** The default setup is built to fit Cloudflare's free tier. No server, no fixed monthly infra bill for normal volume. **Can I see real code?** Yes. The whole thing was built in the open, one commit per stage. **Is it production-ready?** The engine is deployed and the security, consent, and personalization paths are all tested end to end. It's pre-launch, which means there are no paying customers yet and the feature set is still growing — honest about that. If you want to be one of the first real users, the place to start is hello@fmillan.com. Want to talk it through? Email [hello@fmillan.com](mailto:hello@fmillan.com) or see the [contact page](https://fmillan.com/contact/). [previous project — P/02 CheckLLMs](https://fmillan.com/projects/checkllms/) [next project — P/04 Perch](https://fmillan.com/projects/perch/) [← back to the workbench](https://fmillan.com/projects/) [open in the 3D site →](https://fmillan.com/#p-astroedge)