There is a moment in every internal tool that works, and it has nothing to do with features.

Somebody in leadership asks, quietly, what happens if this breaks while I am travelling.
Nobody asks that about a prototype. They ask it the first time they notice that a real process now depends on the thing, and that the process no longer has a manual version anybody remembers how to run. My team at Aditi has built enough of these to recognise the question, and I have learned to treat it as the actual go-live, regardless of what the plan says.
What follows is what changed in one such system in the days around that question, because the changes are unglamorous and they are the entire difference between a demo and something people trust with a new employee’s first morning.
The gap is not features
The system runs a structured joining call: a new employee, a member of the HR team, and an AI that carries the scripted part of the conversation and answers questions from the company’s own documents. It worked in testing, and it worked in demos.
Nothing in the following list is a feature. Not one of them would appear in a release note. All of them were necessary before the thing could reasonably be depended on, and every one of them is a gap between “it works” and “it will keep working when I am not watching”.
That gap has a name I use with clients now, because it stops the conversation going in circles: the tool has to stop being something that works and start being something that fails predictably. Those are different engineering goals, and the second one is harder and much less satisfying to build.
The database that was not the database
Here is the one that would have caused a bad week:
fix: convert SQLite types to SQL Server in 4 migrations for Azure deploy
The system was built against a lightweight local database, which is a sensible way to move quickly. Production runs on SQL Server on Azure. Four migrations had been generated while the local provider was active, so they carried type definitions that were valid in one and not the other, plus a block of changes that tried to convert SQL Server types back to SQLite. On Azure, one of those changes tried to alter a column that a foreign key depended on, failed, and the application crashed on startup.
This is not an exotic failure. It is the most ordinary thing in the world, and it is worth naming precisely because of that. Everything ran locally. The migrations that passed there were written for a database that was not the database, and no amount of care at the application layer detects that, because the application layer cannot see it.
The fix was to write the migrations in SQL Server types and let one small translation layer turn them into SQLite types for local development, so both databases keep working from one set of migrations.
The lesson I keep relearning: the environment you develop against is a dependency you have not written down. It has a version, it has behaviour, and it is different from production in ways that are invisible until deployment. Every project I have run where this bit us, it bit us in the last fortnight, when the cost of finding it is highest.
Failing at startup instead of at midnight
Second change, and this one is a design position rather than a bug fix:
fix: remove env-var fallback and add ValidateOnStart for ElevenLabsOptions
There was a fallback. If a configuration value for the voice service was missing, the application would look somewhere else for it, and if that failed too, it would carry on and discover the problem later, when something actually needed the service.
That is the friendly behaviour, and it is wrong for infrastructure.
With the fallback removed and validation moved to startup, the application now refuses to start if its configuration is incomplete. Loudly, immediately, at deploy time, in front of the person who just deployed it.
The alternative is that it starts fine, passes its health check, and fails with a rejected request in the middle of a call. Which in this system means a new employee on their first morning, a voice that stops answering, and an error nobody on the call can interpret, from a system that appeared healthy.
A tool should be forgiving about configuration. Infrastructure should be brittle about it. Fail at startup, where the audience is a developer with context, rather than at use, where the audience is a user without any.
I did not always believe this. I have written plenty of graceful degradation into missing config, on the reasoning that a partly working system beats a stopped one. That reasoning holds right up until the partly working system is one that people have stopped checking, and then it inverts completely.
Keeping the production file out of the repository
chore: exclude appsettings.Production.json from source control
A few lines in a gitignore file, and the cheapest change in this list.
It is worth being exact about what it did here. The file held settings, not secrets: which database provider, which vector store, how long a joiner link lives. The secrets already lived in the host’s configuration and never in the repository. Taking the file out anyway means there is no place in the repository where a real value could land by accident.
That is the part I like. The change that protects you is made before there is anything to protect, and nothing breaks on the day it would have mattered, because there is no error. Production configuration in a repository is fine while the repository has three people in it and the values point at test accounts. It stops being fine the moment those values are real, and the transition is silent.
I raise this on every engagement now, and I raise it as a question rather than a finding, because in my experience nobody who has done it thinks they have. The question is: if I cloned this repository today, what would I have access to?
The self-hosted component that was not free
The last change is a reversal, and it is the one I would defend most carefully because it looks like a retreat.
The knowledge base the AI answers from sits in a vector store. The first plan, in April, put the production one in a container on the client’s own server, with a managed cloud service for development and demos. By the time the system went to production in May, the production setting named the managed service.
Not because the self-hosted version did not work. Both implementations are still in the code, behind one interface, and a single setting chooses between them. The argument that matters here is a different one: “free” is an accounting error when the cost has only moved. A container on the client’s own server costs nothing on any vendor’s invoice, and costs the client every month in somebody’s attention: patching, monitoring, and being the person called when it was the reason the AI could not answer.
For a client whose business is staffing, not running infrastructure, that trade is bad in a way that does not show up until the person who understood it is on holiday. Which is the question that started all of this.
I now put a line in every estimate for costs that do not appear on an invoice. The number is a guess. The line existing is the point, because it converts an invisible cost into one the client can argue with.
What I ask before calling something production ready
The list I use is shorter than most checklists and each item comes from having got it wrong.
Does it run against the real database, in the real shape, before go-live? Not a compatible one. The same one.
Does it refuse to start when misconfigured? If it starts and fails later, it will fail in front of a user.
If I cloned the repository right now, what would I have?
Which costs are invisible because somebody on the client’s side absorbs them? Name them and price them, even badly.
Who is called when it breaks, and do they know they are that person? This one is not technical and it is the most predictive. A system with a named owner degrades gracefully. A system without one is fine until it is suddenly a crisis with no obvious first responder.
What is the manual path, and does anyone still know it? Every process that gets automated loses its manual version within about six months. That is fine as long as somebody has decided it is fine.
The part that does not demo
None of this makes a good demonstration. There is no screen to show for “it now refuses to start when a key is missing”. The features that make something dependable are almost all invisible, and they are almost all about being unpleasant at the right moment instead of the wrong one.
This began as a joining call with an AI in it. It ended with a list that is mostly about databases, configuration and who gets the phone call, for a system that a new employee will meet on their first morning, every time, for years.
Most of the answer turned out to have nothing to do with the AI in it.
