From proto to production: how Seantral became autonomous
· 8 min · seantral, migrazione, agentic-coding, supabase, produzione
The first app in the lab to complete the cycle: born on the shared backend, it now lives on its own domain and backend. The agentic workflow that got it there, phase by phase, is now part of the method.
Seantral was born in here as a prototype: the Italian sea map, hour by hour, resting on the same foundation that holds up the rest of the lab. Shared accounts, shared backend, emails signed RiftSeed. For a prototype that is exactly right, and it is why prototypes here take days rather than months. Then a prototype starts having real users, its own domain, its own demands. At that point the shared foundation stops being a gift and becomes a debt: everything you touch for one risks touching the other.
At the end of August we completed the move: Seantral now runs on a backend entirely its own, with its own accounts, its own emails, its own Google sign-in, even the map tiles served from its own domain. The app is still alpha, and says so on screen: the scores are still being measured against the real sea. But the environment is no longer a corner of the workshop: it is external production, detached, walking on its own. It is the first time the lab’s full cycle, seed to production, has truly closed.
The workflow, phase by phase
The migration was not an improvised move: it was a workflow executed by AI agents, with me at the gates. Phase one, measure the coupling: how many tables belong to the app, how many of its rows live inside shared tables, and where the real welds are (identity, infrastructure, console). Phase two, build the dedicated project: schema extracted and reapplied, the real accounts migrated through the official API (ids and passwords preserved: nobody had to redo anything), data copied with ids intact, storage moved along with its policies.
Phase three, the external identity: a dedicated mail domain, templates rewritten with the right brand and tested live (an email only exists once it has arrived), Google sign-in on its own project. Phase four, the gate: data parity verified table by table in both directions, and a comparative test run: the same simulated-users suite, one hundred and twenty-three checks, executed against the old and the new the same evening. Only failures exclusive to the new side count as regressions. That evening there were zero.
The cut is a change of keys
The choice that made everything reversible had been made months earlier, unknowingly: the client reads the backend address and key from the build environment. So the actual cut consisted of changing two secrets in the pipeline and deploying. Had anything gone wrong, rolling back would have been the same gesture in reverse. No downtime, no maintenance window: users noticed nothing, which is the definition of a successful cut.
The part we learned the most from came after the first deploy: one origin serving two domains makes every hand-written address in server functions and HTML invisible. The bundle was clean, but the sitemap, the search-engine pages, the share proxy and the boot beacon still talked to the old backend. There is only one way to find them: interrogating the served product, not the code. Now every surface picks its backend from the domain serving it, through a single resolver.
Turning off the old, in the right order
The last phase is the one usually postponed forever: removing the app from the place where it was born. The order is strict and must be respected: first a locally verified, count-checked archive (and here the humblest lesson of the project: the automatic backup we were counting on had never run, due to a secret never set); then the doors, meaning every old address answering with a permanent redirect that preserves the path, embedded widgets included; then the moving parts, cron and functions; data last. Shared accounts are never touched: they are users of everything else too.
What the method keeps
The real value of the week is not the move: it is that the move is now a playbook. The phases, the traps already paid for, the ten lessons written in reusable form, all recorded in the project space and in the lab’s documentation. The next app that needs to graduate will rediscover nothing: it will open the document and execute. That is the lab’s pact with AI: agents do the work, the human decides at the gates, and everything learned becomes structure for the next time.
Seantral, meanwhile, is alive at seantral.com, in declared alpha, with its real users and its two hundred and twenty-seven coastal points refreshed every hour. If you want to see what a prototype looks like once it has grown up, it is there.