The obvious question about a production system run by one person is what stops it falling over. People are usually too polite to ask, so they assume the answer is nothing and quietly file you under hobbyist.
How does one person run a production system safely?
The answer is process, not heroics. Not more of it than a team would have. Less, but non-negotiable.
Reconnaissance before building
Read the live schema. Not the migration files, not what the code looked like last week, not what you remember deciding. The database is the only thing that knows what is true.
This sounds obvious and is the rule most often broken, because reading first feels like delay. It is the cheapest step in the whole sequence. Everything that goes wrong later goes wrong because something was assumed here.
Two instances, never one
One plans and verifies. One executes. They are never the same conversation.
A system that proposes its own work and then approves it has no review step, only the appearance of one. Separating them is the closest a single person gets to having a colleague, not because the second instance is smarter, but because it has not spent the last hour convincing itself the plan is good.
A named go for every irreversible action
Every write to live data. Every migration. Every push to the branch that is production.
Not a checkbox, not an implied yes from context. A person, by name, saying go. The moment that becomes a formality is the moment it stops working, so it has to stay slightly inconvenient.
Boring core, smart log
The database enforces integrity and permissions and nothing else. No process logic in triggers, no workflow encoded in constraints. Rules that live in the schema are invisible at the point where someone is trying to understand behaviour.
Measurement comes from append-only logging rather than from restricting what people can do. The instinct when you cannot supervise everything is to lock things down. The better move is to let people work and record what happened, because a restriction you got wrong stops work while a log you got wrong only costs you a query.
What this buys
Not safety. There is no version of one person running a production system that is as safe as a team running it, and pretending otherwise would be the actual risk.
What it buys is that the failures are recoverable. Nothing is destroyed without a named decision, nothing is changed without a record, and nothing is built on top of a guess about what the system currently does.
That is a lower bar than a team would set. It is also, in practice, higher than most teams clear.