A separation-of-concerns architecture for a test-prep business that starts with PSAT / SAT / ACT — and is built from day one to extend into any subject, any market, any price point.
The current build collapses four very different jobs into a single codebase: authoring questions, deciding what to ask next, presenting the experience to a user, and owning the data. When those concerns share one body, every edit risks breaking everything, and none of them can be sold, scaled, or experimented with on their own.
This design pulls them apart into three layers that each version independently — a Reference Data authoring system, a stateless Engine, and a family of Clients — all feeding one accumulating data asset. Authors can churn on content without touching production. The adaptive logic can be upgraded without rewriting the apps. New market-specific apps can launch without endangering the moat.
A stateless decision engine with a defined input protocol. It holds no memory of its own — which is exactly what makes it powerful.
Because it carries no state, the engine is versionable (pin a client to v3 while v4 bakes), reproducible (same inputs always yield the same output), and infinitely scalable — spin up thousands of identical instances and tear them down freely.
State is a liability you push to the edges. The engine becomes a pure function over (config, history) → decision, which is what makes both replay and honest A/B-style counterfactuals even possible.
The apps users actually touch. Each one owns the journey history and can target a completely different market — without polluting the engine or the moat.
This is where the business model lives. The same core can power a free, data-hungry app, a tutor tool, and a $1,500 parent product — each with its own UX, features, and price — without any of them cannibalizing the others or leaking into the engine.
Want to chase a lower-income segment with a leaner interface? That's a new client, not a new platform.
| Client | Primary goal | What's special | Runs on |
|---|---|---|---|
| Free tier | Accumulate history at volume | Frictionless onboarding; data is the payment | stable |
| Tutor | B2B / professional use | Cohorts, assignments, intervention views | stable |
| Parent premium | Monetize at $1,500 | Progress monitoring, alerts, accountability | stable |
| Alpha | De-risk new logic | Isolated; can't touch production data | bleeding-edge |
Every client feeds one accumulating store. The engine emits events; nothing stays trapped inside an app. The data is the durable asset — and it compounds.
The founder is right that the data is the moat — but a moat only forms if the data isn't fragmented across apps and tangled with presentation logic. This architecture exists, in large part, to keep that asset clean, central, and growing while everything around it is free to change.
Eventually that asset is what you license, sell into, or build new products on top of.
Right now these requirements sit on top of one another, which is what makes the project feel like one impossibly large thing. Assigning each one to the layer that owns it is how the scope becomes buildable — and how we decide what's actually phase one.
| What the founder wants | Where it lives |
|---|---|
| “Questions that can be modified but still mean the same thing” | REFERENCE DATA Semantic variants + versioning in the authoring layer. |
| “Full replay history of a user's journey” | CLIENT ENGINE Client stores the chain; engine reconstructs it deterministically. |
| “Change the variables and see how the replay would have gone differently” | ENGINE Counterfactual replay — only possible because the engine is stateless. |
| “Bad day vs. a subject they're genuinely weak on” | ENGINE Diagnostic reasoning over the replayed pattern, not a single answer. |
| “The data is the moat” | DATA MOAT Central event store fed by every client. |
| “Different markets and price points (free, tutor, $1,500 parent)” | CLIENTS Each is its own app on a shared core. |
| “Extend beyond test prep into other subjects later” | ENGINE PROTOCOL AUTHORING New domains = new authored content + a client, not a rebuild. |
Authors edit, the engine upgrades, new apps launch — none of it breaks the others, because each layer versions on its own.
A stateless engine spins up to thousands of identical instances and back down — no coordination, no shared memory.
Free, tutor, premium, white-label — different price points and markets without rebuilding or cannibalizing.
Every interaction across every client deepens one central data asset that stays clean and sellable.