Every platform team knows the sinking feeling: you spend months building a beautiful internal service, complete with documentation, dashboards, and a Slack channel. You announce it at the all-hands. Then, crickets. A few curious engineers try it once, hit a snag, and never return. The service sits there, consuming cloud resources and maintenance hours, producing nothing of value. This scenario is shockingly common. Platform teams at companies large and small routinely waste millions of dollars on services that engineers silently abandon. The problem isn't laziness or poor engineering—it's a systemic mismatch between what platform teams build and what developers actually need.

The Empty Dashboard: Why Internal Services Gather Dust

The most common failure pattern is the service built without a clear user need. A platform team identifies a general problem—say, service discovery or configuration management—and builds a generic solution. They assume that if they build it, engineers will come. But developers are pragmatic. They already have workarounds: copy-pasted config files, hardcoded endpoints, or scripts that do the job well enough. A new platform service has to be not just good, but dramatically better than the existing friction. Most aren't.

Usage metrics often go unmonitored. Many platform teams track uptime and latency but not whether anyone actually uses the service. One mid-sized company I spoke with had an internal service mesh that ran for two years before someone noticed it had zero active users outside the platform team itself. The team had been proudly presenting uptime numbers at quarterly reviews, never realizing the service was a ghost town.

Engineers bypass official services daily. They copy code from an old project, paste a curl command from a colleague, or use a third-party SaaS tool that they expense. The platform team never sees this shadow usage. When they do survey developers, they hear polite excuses: "It's fine" or "I just haven't had time to migrate." The truth is that the official service adds complexity without solving a real pain point.

Netflix's internal experience with Spinnaker illustrates this. Spinnaker, an open-source continuous delivery platform originally built at Netflix, saw wide adoption externally but internally faced resistance. Many Netflix engineers preferred simpler, ad-hoc deployment pipelines. The platform team had to invest heavily in user research and simplification to drive internal adoption. Even then, not every team switched. The lesson: even a well-engineered service can fail if it doesn't match engineers' existing workflows.

Another example comes from a large financial services company that built an internal API gateway with dozens of features—rate limiting, authentication, logging, and more. After six months, only two teams had integrated with it. The rest continued using a simple nginx proxy. The platform team had spent over $2 million in engineering time and cloud resources. Eventually, they deprecated the gateway and replaced it with a lightweight wrapper that teams actually adopted. The key insight: they had over-engineered a solution for a problem that most teams didn't have.

The Build-Trap: How Internal Platforms Become Graveyards

The "build it and they will come" fallacy persists because it feels productive. Building a platform is tangible: you write code, deploy services, and produce artifacts. It's satisfying in a way that talking to users is not. But that satisfaction is deceptive. Every feature added without user feedback increases the surface area of the platform without increasing its value.

Internal developer portals are a prime example. Dozens of companies have built custom portals for service cataloging, environment management, and deployment. Many of these portals have zero active users outside the platform team. The team adds features—a new widget, a search bar, a dark mode—but no one visits. The portal becomes a monument to unvalidated assumptions.

Feature bloat compounds the problem. Without tight feedback loops, platform teams guess at what developers want. They add integrations, APIs, and configuration options. Each addition makes the service harder to learn and maintain. Developers who might have tried a simpler version are now intimidated by the complexity. The platform team, meanwhile, measures success by feature count, not usage.

Spotify's Backstage is often cited as a success, but even there adoption is not universal. Backstage, an open-source developer portal, has been adopted by many companies, but internally at Spotify, not every team uses it. Some teams prefer their own lightweight tools. The platform team acknowledges this and focuses on making Backstage optional and integrable rather than mandatory. The lesson: even a widely reused platform can have uneven adoption. The goal should be value, not ubiquity.

Trade-offs are inherent here. Platform teams must balance standardization with flexibility. A fully standardized platform reduces cognitive load but may stifle innovation. A flexible platform gives teams freedom but increases fragmentation. The key is to find the right balance through continuous user feedback. For example, Airbnb's platform team uses a "service template" approach: they provide a recommended stack but allow teams to deviate with justification. This has led to higher adoption because teams feel ownership rather than coercion.

The Cost of Useless Infrastructure: Real Dollars Wasted

The waste goes beyond developer frustration. A 20-person platform team costs roughly $3 million annually in salary, benefits, and overhead. If half the services they build are unused, that's $1.5 million down the drain each year. And that's just headcount. Cloud resources for unused services pile up: compute instances, data storage, network egress, monitoring pipelines. These costs are often invisible because they're buried in aggregate cloud bills.

Maintenance time dwarfs actual value delivery. Every unused service still requires security patches, dependency updates, incident response, and on-call rotations. The platform team spends hours keeping the lights on for services that produce zero value. This is toil in its purest form—work that is manual, repetitive, and automatable, but only if you kill the service first.

Dropbox provides a concrete example. In 2016, Dropbox embarked on a major infrastructure consolidation, moving away from public cloud to build their own data centers. As part of that effort, they audited internal tools and services. The result: they retired over 500 internal services and reduced cloud spend by 40%. A significant portion of those services had few or no active users. The savings came not from optimization but from deletion.

Some estimates put the total cost of unused internal software at 10–20% of a company's engineering budget. For a company with 500 engineers, that could be $5–10 million annually. These are real dollars that could go toward developer productivity tools that actually work, or back to the bottom line.

But not all waste is equally easy to eliminate. Some services are critical for compliance or security, even if they have low usage. For example, a centralized logging service may be used by only a few teams but is required for auditing. In such cases, the cost is justified. Platform teams must distinguish between genuinely unused services and those that serve a niche but essential function. A quarterly review with input from compliance and security teams can help make that call.

The Org Silos: When Platform Teams Don't Talk to Users

Why do platform teams keep building useless services? A big reason is organizational separation. Platform teams often sit in a different reporting line than product engineering. They have their own roadmaps, their own success metrics, and their own culture. They rarely embed with product teams to observe how engineers actually work.

Without embedded user research, platform teams make decisions based on architectural purity rather than need. They design systems that are elegant, scalable, and technically impressive—but solve problems that don't exist. A service mesh might be the right architectural choice, but if your engineers are happy with simple HTTP calls, it's an expensive solution in search of a problem.

Etsy's platform team learned this the hard way. In 2018, they conducted a comprehensive developer survey and discovered that the biggest pain point wasn't infrastructure at all—it was observability. Engineers couldn't easily debug production issues. The platform team had been investing in container orchestration and deployment tooling, but developers wanted better logging, tracing, and monitoring. The team pivoted, doubling down on observability tools, and developer satisfaction improved significantly.

The fix is simple: platform teams need to talk to their users regularly. Not through quarterly surveys, but through continuous conversation. Embed platform engineers in product teams for a few weeks. Shadow developers as they deploy and debug. Watch where they struggle. The insights from these interactions are worth more than any architectural diagram.

Counter-argument: Some platform teams argue that they cannot embed with every team due to size constraints. A practical alternative is to create a "developer advisory board" with representatives from different product teams. This board meets bi-weekly to discuss pain points and priorities. Atlassian uses a similar model for their internal tools, with each product team nominating a liaison. This scales well and ensures diverse input without requiring full-time embedding.

The Metrics That Matter: Measuring Actual Adoption

To avoid wasting millions, platform teams need to measure the right things. The most important metric is daily active engineers per service. How many unique developers used the service in the last week? If the number is below a threshold—say, three engineers for a general-purpose service—it's a candidate for retirement.

Time-to-first-successful-use is a leading indicator. How long does it take a new developer to accomplish their first meaningful task with the service? If it's more than 15 minutes, engineers will give up. This metric reveals friction early, before the service has a chance to fail silently.

Net Promoter Score (NPS) surveys for internal tools can reveal dissatisfaction that usage metrics miss. Engineers might use a service because they're forced to, but hate every minute of it. A low NPS signals that the service is a net negative, even if it has active users. Stripe's internal developer survey, for example, drove a 30% reduction in unused APIs. The team asked developers which APIs they actually used and which they found confusing. They then deprecated the low-usage ones, simplifying the platform for everyone.

Another useful metric is the ratio of support requests to active users. If a service has many users but also many support tickets, it's too complex. If it has few users but many tickets, it's broken. In either case, the platform team should invest in simplification or retirement, not new features.

However, metrics alone can be misleading. A service with low daily active users might still be critical for certain workflows that occur weekly or monthly. For example, a deployment pipeline that runs only on release day might have low daily usage but high impact. Platform teams should combine quantitative metrics with qualitative feedback to avoid killing services that are essential but infrequently used.

The Lean Platform: Ship Only What Gets Used

The antidote to wasted services is a lean platform approach. Start with a single adopter before generalizing. Instead of building a generic service, find one team with a real pain point and build a minimal solution for them. Once they're using it successfully, generalize and offer it to other teams. This approach, sometimes called "paved road" or "golden path," ensures that every service has at least one real user from day one.

Kill services with fewer than three active teams. Set a quarterly review where every internal service is evaluated on usage. If a service doesn't have at least three teams actively using it, schedule its deprecation. This sounds harsh, but it forces platform teams to focus on value. Engineers who lose a service will speak up if it's truly needed. Otherwise, it's dead weight.

Require a product manager for every platform service. Platform engineering is product engineering for internal users. A product manager owns the user research, the roadmap, and the success metrics. Without this role, platform teams default to building what's technically interesting rather than what's needed. The product manager's job is to say "no" to features that don't serve real users.

Slack's internal platform team exemplifies this discipline. They mandate usage quotas before scaling any new service. A service must be adopted by a certain number of teams before the platform team will invest in making it more robust or feature-rich. This prevents premature generalization and keeps the platform lean. As of late 2024, Slack's platform team maintains fewer than 30 core internal services, each with clear adoption metrics and a dedicated product manager.

None of this is easy. It requires platform teams to change their incentives, their culture, and their metrics. But the alternative—continuing to build services that no one uses—is a luxury that few companies can afford. The next time your platform team ships a new service, ask: who will use it on day one? If the answer is vague, you're probably building a graveyard.

In summary, platform teams must shift from a build-first mindset to a user-first mindset. That means embedding with product teams, measuring adoption rigorously, and having the courage to kill services that don't deliver value. The cost of doing otherwise is not just financial—it's the erosion of trust between platform teams and the engineers they aim to serve. By focusing on real user needs and ruthless prioritization, platform teams can turn their services from ghost towns into thriving ecosystems that developers actually appreciate.