Case study
We Built an Internal Tool in a Week. We Maintained It for Three Years.
Every codebase I audit as a consultant has at least one internal tool that started as a quick hack and became load-bearing infrastructure. The build cost was never the problem — the maintenance cost was.
Every codebase I audit has at least one. A script, a dashboard, a small internal app that someone built in a few days to solve an immediate problem. It worked. People started depending on it. And now, years later, it's a full-time job that nobody signed up for.
I'm not talking about internal developer platforms or big infrastructure projects. I mean the small stuff. The admin panel that lets the ops team fix customer records. The CSV import tool for the finance team. The Slack bot that pulls deployment status from three different systems. The little apps that fill gaps between your real products.
The pattern is always the same
A team has a manual process that takes too long. Someone builds a quick internal tool over a few days. Maybe a weekend. It works, people love it, and suddenly twenty people use it daily.
Then the requests start. "Can you add a filter for date range?" "Can we export this to Excel?" "The finance team wants access but they need different permissions." Each request is small. Each one makes sense. And each one adds surface area that somebody has to maintain.
At one client — a mid-size e-commerce company — I found an internal order management tool that a senior engineer had built in five days using Next.js and a direct database connection. That was two and a half years before I arrived. By the time I saw it, the tool had its own authentication system, role-based access for three departments, seventeen API endpoints, a reporting module, and a background job that synced data with their ERP every fifteen minutes.
The engineer who built it had left eighteen months ago. The team maintained it out of obligation. Nobody owned it formally. It had no tests. Its dependencies were eleven months behind. And the ops team processed 200 orders through it every day.
What nobody budgets for
The build cost of an internal tool is almost irrelevant. A week of one engineer's time is cheap. What's expensive is what comes after.
There's the maintenance tax: dependency updates, framework upgrades, bug fixes when upstream APIs change. For the order management tool, the ERP vendor changed their API twice in eighteen months. Each time, the sync broke, and someone had to drop their sprint work to fix it.
There's the feature creep: internal users are your most demanding customers because they can walk over to your desk. They know who built it. They know you can "just add" things. Saying no to a colleague is harder than saying no to an external feature request with a backlog and a product manager.
There's the knowledge concentration: the person who built it usually understands it alone. When they leave, the team inherits a codebase they didn't write, often without documentation, and with business logic that only the operations team can explain.
Note
The tools that survive
Not every internal tool becomes a burden. The ones that age well share a few traits I've noticed across engagements.
They're boring. The best internal tools use whatever the team already knows. If you're a Rails shop, the admin tool is Rails. If you're running Python services, it's a Django admin or a Streamlit app. The worst ones are the side projects where someone tried a new framework "because it's just an internal tool."
They have an owner. Not a team, not "everyone" — one person or one team with explicit responsibility in their sprint capacity. I've seen tools languish for months because six people each assumed someone else would handle the broken deploy.
They stay small. The order management tool should have been three separate tools, or better yet, features inside the existing admin system. When an internal tool starts growing its own auth system, that's the signal you've crossed a line.
They're documented enough. Not a wiki page nobody reads. Just a README that answers: what does this do, how do I run it locally, and what breaks if it goes down. That last one matters more than people think. At another client, an internal reporting tool went down for two days before anyone noticed — it turned out the finance team had switched to a spreadsheet workaround months ago and never told engineering.
What I actually recommend
When a client asks me whether they should build an internal tool, my first question is: "What happens in six months when the person who built it is working on something else?"
If the answer involves hand-waving about documentation or "the team will pick it up," I push back. Here's what I suggest instead:
First, check if a commercial tool covers 80% of the need. Retool, Airplane, or even a well-configured Metabase dashboard can replace a surprising number of custom admin panels. Yes, the last 20% won't be perfect. That's usually fine.
Second, if you do build, timebox aggressively — not just the initial build, but the feature additions. Set a maintenance budget in hours per month and stick to it. When the requests exceed the budget, that's your signal to either invest properly or migrate to a commercial tool.
Third, treat internal tools like production software from day one. That doesn't mean full CI/CD pipelines and 99.9% SLAs. It means: source control, at least one person who isn't the author can deploy it, and dependency updates on a schedule.
The irony is that internal tools exist because external tools don't quite fit. But the gap between "doesn't quite fit" and "worth maintaining a custom application for three years" is wider than most teams realize in the moment they're building it.
That admin panel you're sketching out this week — ask yourself honestly: who's going to update its dependencies next November?