Zero to production

Zero is the smallest honest starting point: an empty repository and the single given component — the branded-id store. The store mints and decodes a typed id, and that is the whole system. Nothing is deployed, nothing is supervised, nothing is observed, and there is one surface: a function call inside a test.

Production is a deployed, supervised, multi-surface Portal: the store, an event-sourced engine behind one facade, a Phoenix web app, a Telegram bot, and a student dashboard. The word names a set of properties a running system must have, not a moment the code reaches. To call the Portal production, it must be deployed where students reach it, supervised so a failed part is restarted, multi-surface so it is reachable on more than one surface, observable so a failure is visible, and reliable as a consequence of the first four.

The distance from zero to production is not crossed in one leap. Each production property is its own thin rung — deploy the store, supervise it, add the web surface, add the bot, add the dashboard, make each observable — and production is reached only when every required rung has shipped. A single attempt to deliver the whole platform at once is the big-bang failure mode (A1.01.2): the work is unprovable until the end, so it is unprovable for too long.

Step through the rungs to fill the production-readiness bar. The readout shows how many rungs have shipped, what fraction that is, the next rung still owed, and whether production is reached. Production turns on at the last rung, not part-way: an almost-deployed, half-supervised Portal is not in production.

At zero, the only thing that works is the store, exercised in a test. It mints a typed id and decodes it back — one component, one surface, no deployment. Every production property is absent.

# Zero: the whole system is the branded-id store, called in a test.
id = Portal.ID.generate(:user)        # => "USR0NbAb1xcFCy"
decoded = Portal.ID.decode(id)
decoded.type                          # => :user
decoded.timestamp                     # the embedded mint time

# Production: the store is one of five components — engine behind one facade,
# Phoenix web, Telegram bot, dashboard — deployed, supervised, observable.
# Each property is its own rung; production is reached when every rung has shipped.

To reach production, each property is added as its own thin rung. Deploy the store; supervise it so a failed part is restarted; add the Phoenix web surface; add the Telegram bot; add the student dashboard; make each surface observable. Production is reached when every required rung has shipped — the same thin-increment discipline the whole course argues, run on one project end to end.

Zero is an empty repository plus the one given branded-id store: one component, one surface, no deployment. Production is a deployed, supervised, multi-surface, observable Portal — the store, the engine behind one facade, the Phoenix web app, the Telegram bot, and the dashboard. Production names a set of properties, not a moment, and the gap between the endpoints is closed rung by rung, reached only when every required rung has shipped. The next dive isolates the unit of that crossing: one rung at a time.

Primary sources for production as a set of properties reached by thin increments, and where it connects in the course.