> ## Content Index
> Fetch the complete content index at: https://alexeygolev.blog/llms.txt
> Use this file to discover other available public pages before exploring further.

# On Building Internal Tools: Why Good Software Goes Unused
- URL: https://alexeygolev.blog/on-building-internal-tools-why-good-software-goes-unused/
- Published: 2026-11-17T16:08:42.000Z
- Updated: 2026-11-17T16:08:42.000Z
- Description: A team can build an amazing internal tool and still end up with low adoption. This short post looks at the problems an engineer may face when delivering internal software, and why being close to your users helps but is far from enough.
- Author: Alexey Golev
- Tags: Internal Tools, Platform Engineering

A team could build an amazing internal tool which still has a low adoption. In this short post I explore some of the problems an engineer may face when delivering internal software. I would like to avoid defining an "internal tool", for the purpose of this article let's consider it as any software built to solve a company’s problem: from a simple CLI to a complex product with multiple use cases.

Here I would like to illustrate that although proximity to end users help, it is far from enough.

## Close is not the same as informed

A team building an external product at a large, mature company often can't talk to its users at scale. There are too many of them, they sit behind sales and support, and what reaches the team has been filtered twice. Big companies still run user tests and keep UX labs, but that is sampling, not conversation.

Startups have the opposite problem. The successful ones talk to their users constantly, because they are searching for product-market fit and have little else to go on.

An internal tool team has the startup's access inside the big company's structure. Your users share your chat, your stand-up and sometimes your lunch queue. You can borrow the startup habits: talk to them early, watch them work, change the product in small steps.

What you can't borrow is the assumption that access produces information. Proximity lets you ask anyone anything. It says nothing about what they will answer.

## Installed is not adopted

The developer portal Backstage started as Spotify's internal tool and was later open-sourced. In a 2023 interview, the head of engineering for Backstage at Spotify said she reckoned around 99% of Spotify's developers use it, about a year after it began to be rolled out internally. It isn't mandatory. Her list of what got it there is unglamorous: working on incentives, golden paths and templates for new hires, a short technology radar, and building out the platform incrementally. The same article puts adoption at companies outside Spotify at around 10%, but that is the writer's paraphrase and doesn't say what is being measured.

Treat all of those numbers as estimates from a single interview. The shape of the story is more reliable than the figures: the same software with very different adoption depending on what surrounds it.

The pattern is common enough that it needs a name. Installing a tool is an engineering outcome. Adopting it is a behavioural one, and it only happens when staying put costs more than switching. Until then, the tool is an option nobody has a reason to take. 

![](https://storage.ghost.io/c/e9/80/e980d4cb-1c2f-4112-8b4c-fb045047467d/content/images/2026/11/installed_vs_adopted.gif)

## What people say and what people do

Colleagues may not always tell you what they really think. Some are being polite, because you sit nearby and you built the thing. Some don't care enough to explain. In some organisations, telling a team its tool is poor is simply not done.

So "looks great, we'll try it" is not a signal. It can mean yes, or it can mean the conversation is over.

Watch behaviour instead, and count it where you can: how many times the tool was used, how many sessions, how many minutes, how many people came back a second week. A number that stays flat after the launch announcement tells you more than any survey comment.

Numbers can mislead too. Usage that is mandated looks the same as usage that is wanted, and a high session count can mean people are fighting the tool. Use the metrics to decide where to ask questions, not to skip the asking.

## Four ways internal tools quietly die

Building is just one part. Even a good product can die afterwards, and it rarely fails loudly. Nothing errors. Nobody complains. Usage just never arrives.

**Wrong problem.** The team solved the problem it could see, or the one that was easiest to describe, not the one people were losing hours to. Picture a platform team that automates a deployment step that takes ten minutes a week, while the real cost is waiting two days for an environment.

**No reason to change.** Every tool competes with the status quo, and the status quo has a head start: it is familiar, it works well enough, and everyone already knows where it breaks. If switching costs more than staying, people stay. Better is not a reason by itself.

**Misunderstood feedback.** Silence gets read as satisfaction. "Nice idea" gets read as demand. A workaround gets read as a quirk, when it is the most honest feedback you will receive.

**Clashing incentives.** Your tool may ask another team to do extra work now for a benefit that lands on someone else's roadmap. That team will be polite about it and do nothing. The same applies upwards: a project that exists to support a promotion case and a project that exists to fix a real pain may look identical on a slide but they behave very differently after launch.

Two more are less about design and more about organisations. Selling the tool internally is part of the job, not a sign it is weak. And priorities move. A project cancelled for reasons unrelated to its quality still leaves users with something half-supported. If a tool is truly dead, the honest move is to stop investing in it, not to keep it on life support.

## What adopted tools did differently

Google's Tricorder is a useful example, with the caveat that it is old: the published paper dates from 2015 and the book chapter from 2020\. It grew out of several failed attempts to bolt static analysis onto the developer workflow. What changed was where the results appear. Findings show up inside the code review that developers already use so nobody has to go and look for them.

Then the team treated trust as a product requirement. New checks have to stay under 10% effective false positives and the overall rate is reported as just below 5%. Every finding has a "Not useful" button that files a bug against the analyzer's author and analyzers that don't improve get switched off. More than a hundred analyzers exist, most contributed by people outside the team.

None of that is extraordinary. It lowers the cost of using the tool to nearly zero, makes feedback a mechanism rather than a favour, and lets users see that someone is listening.

## What I'd do before building

1. **Ask what people do today.** Not what they want. Watch the current workflow and find where the hours go.
2. **Name the cost of staying put.** If you can't say what the status quo costs, you can't say why anyone should move.
3. **Put the tool where the work already happens.** Every extra tab, login or habit is a tax on adoption.
4. **Measure behaviour from day one.** Uses, sessions, minutes and repeat users, with a few conversations to explain them.
5. **Build the feedback loop into the tool.** A button that reaches an owner beats a survey that reaches a folder.
6. **Know whose incentives you are touching.** Including your sponsor's.

Internal tooling is a product problem and a people problem, and in most companies it is an organisational one as well. The code is the part you have highest control of. Whether anyone uses it depends mostly on the rest.

## Sources

- The New Stack, [How Spotify achieved a voluntary 99% internal platform adoption rate](https://thenewstack.io/how-spotify-achieved-a-voluntary-99-internal-platform-adoption-rate/?ref=alexeygolev.blog) (September 2023)
- Software Engineering at Google, [chapter 20: static analysis](https://abseil.io/resources/swe-book/html/ch20.html?ref=alexeygolev.blog)