Every platform team has that tool. The one that consumed three sprints to build, two more to document, and now sits in the internal developer portal like a forgotten exhibit. Nobody uses it, but nobody dares delete it. The tool has become a permanent fixture—present, but functionally inert. Meanwhile, the team that built it spends maintenance cycles on bug fixes, compatibility updates, and the occasional support ticket from a user who can't find the documentation.

This pattern is so common in platform engineering that it has its own informal name: the internal tool graveyard. But some teams are adopting a counterintuitive practice that flips the script. They actively kill their own tools. Not because the tools are buggy or broken, but because they have outlived their usefulness. And in doing so, they reclaim months of developer time that would otherwise be sunk into maintenance. For instance, at a large e-commerce company, the platform team deprecated a service scaffolding tool after two years of declining usage, freeing up three engineering months in the first quarter alone.

The insight is simple: a tool that nobody uses costs more than a tool that never existed. The cost is not just compute or storage—it's cognitive overhead, documentation rot, onboarding friction, and the opportunity cost of every sprint spent polishing a product with zero users. As platform teams waste millions on services no engineer uses, the teams that learn to kill early and often are the ones that deliver real leverage.

The Platform Paradox: Build Tools That Nobody Uses

The core promise of platform engineering is simple: build paved roads so that application teams can move faster. In practice, those roads often become ghost towns. Surveys of internal developer portals consistently show that 30-50% of tools in a typical portal have fewer than five active users after six months. The tools were built with good intentions—often in response to a specific request from a single team—but they never achieved the network effects needed to sustain adoption.

Spotify's Backstage project, now a CNCF incubating project, was born from exactly this frustration. Spotify's internal platform team had built dozens of tools over the years, each one solving a specific problem for a specific team. But the proliferation of tools created a fragmented developer experience. Backstage was their attempt to consolidate, but even that consolidation required deprecating beloved tools that teams had grown attached to. The famous "golden path" concept emerged from the recognition that you cannot pave every road—you must choose which paths to maintain and which to let grow over.

Netflix's Spinnaker provides another cautionary tale. Spinnaker was built as a multi-cloud continuous delivery platform, and it saw broad adoption across Netflix's engineering organization. But as teams matured, many built their own lighter-weight deployment pipelines on top of Spinnaker's APIs, effectively forking the tool internally. Those forks consumed maintenance effort from the core platform team, even though the original Spinnaker UI was barely used. The platform team eventually had to make the painful decision to deprecate the UI and focus on the API layer—a move that freed up significant engineering capacity.

The sunk-cost fallacy is the primary reason zombie tools survive. Platform teams have invested months or years in a tool, and killing it feels like admitting failure. But the fallacy ignores the ongoing cost of maintenance. A tool that took six months to build and now requires one week of maintenance per quarter will cost more to keep alive for two years than it cost to build. And that maintenance is time not spent on higher-impact work. The teams that recognize this arithmetic are the ones that break the cycle.

Why Most Platform Tools Die from Neglect, Not Bugs

Technical quality is rarely the reason internal tools fail. Most platform tools are built by competent engineers and work as designed. The failure mode is almost always adoption-related. Engineers prefer command-line interfaces over dashboards for speed, yet many platform tools ship with a web UI as the primary interface. The CLI is added as an afterthought, or not at all, and adoption suffers. A 2023 survey by the Platform Engineering community found that 68% of engineers prefer CLI tools for day-to-day operations, yet only 35% of internal platform tools offer a CLI as a first-class interface.

Documentation rot is another silent killer. Internal tools rarely receive the same documentation investment as external products. A tool launched with a wiki page and a README will see that documentation decay within six months as the underlying APIs change, dependencies shift, and the original author moves teams. New engineers joining the organization look at the tool's documentation, find it outdated, and move on to a more self-explanatory alternative—often an open-source tool they already know. The platform tool becomes invisible, not because it's bad, but because it's opaque.

Maintenance overhead follows a predictable curve. In the first three months after launch, the tool requires active bug fixing and feature tweaks. After six months, the rate of new issues drops, but compatibility updates—dependency bumps, security patches, API changes in upstream services—begin to accumulate. By the twelve-month mark, the tool may be stable, but it now runs on a version of a library that is two major versions behind, and the effort to upgrade is non-trivial. At this point, the platform team faces a choice: invest in a refactor, or let the tool drift into obsolescence. Many teams choose the latter, and the tool becomes a liability.

The deeper structural issue is misaligned ownership. Inverse Conway's Law suggests that organizations design systems that mirror their communication structures. When a platform team builds a tool for multiple application teams, the ownership model is often unclear. The platform team owns the code, but the application teams own the adoption. Neither group feels fully responsible for the tool's success. The platform team measures output—ships per quarter—while the application teams measure outcomes—deploy velocity. When those metrics diverge, the tool falls into a responsibility gap.

The Killing Instinct: When Deprecation Is a Feature

Etsy's platform team turned deprecation into a ritual. They maintained a public deprecation board where any engineer could propose a tool for sunset. The board operated on a simple rubric: if a tool had fewer than ten active users in the past month, it was eligible for deprecation. The team would then announce the deprecation on the board, wait two weeks for objections, and then proceed with a graceful shutdown. The board became a source of pride—a visible signal that the team was actively curating the internal tool landscape rather than letting it bloat.

Stripe took a more aggressive approach with their API versioning strategy. By forcing clients to migrate to new versions on a fixed schedule, Stripe created a natural mechanism for deprecation. Internal tools that wrapped Stripe's APIs inherited this lifecycle. A tool that hadn't been updated to support the latest API version would simply stop working, forcing either an update or a retirement. The schedule created urgency and prevented the accumulation of cruft. Stripe's platform team reported that the versioning policy alone reduced their maintenance burden by roughly 30% over two years.

Dropbox's Magic Pocket team, responsible for the company's custom storage infrastructure, took a more dramatic approach. In a single quarter, they deprecated five internal tools that had been built over the preceding three years. Each tool had been replaced by either an open-source alternative or a simpler script that performed the same function. The team documented each deprecation with a migration guide and a one-week grace period. The result was a net reduction of 40% in the team's on-call load and a noticeable improvement in morale—engineers no longer felt guilty about ignoring tools they knew they should be maintaining.

Scheduled removal prevents the gradual accumulation of cognitive load. When every tool has an expiration date, engineers know not to get attached. They also know that the platform team will provide a migration path before the tool is removed. This predictability reduces the anxiety that often accompanies deprecation. The platform team becomes a curator, not a hoarder. And curation is a skill that scales far better than maintenance.

How to Design for Deletion from Day One

The most effective platform teams bake deprecation into the design of every new tool. They start with a two-year sunset clause: any internal tool that does not achieve a minimum adoption threshold within two years will be deprecated. This clause is documented in the tool's README from day one, so that early adopters know what they are signing up for. The sunset clause also creates a forcing function for the team to measure adoption early and honestly. If the tool is not gaining traction by month six, the team can decide whether to invest in promotion or plan for an orderly shutdown.

Instrumenting adoption metrics before building version one sounds obvious, but it is rarely done. Platform teams often build tools based on intuition or a single request from a senior engineer. A better approach is to run a lightweight survey or pilot with the intended users before writing any code. If fewer than five teams express genuine interest, the tool is probably not worth building. The cost of the survey is a few hours of calendar time; the cost of building an unneeded tool is months of engineering effort. Some teams use a simple rule: only build if at least three independent teams commit to using the tool within the first quarter.

Writing migration guides in parallel with the tool is a practice borrowed from successful open-source projects. When a team releases a new tool, they also publish a guide explaining how to migrate away from it—to an alternative internal tool, an open-source replacement, or a manual process. This guide is updated as the tool evolves. The existence of the migration guide signals that the team is thinking about the tool's lifecycle, not just its launch. It also reduces the friction of eventual deprecation, because users have a known path forward.

Feature flags are another tool for measuring real usage post-launch. By wrapping every new internal tool behind a feature flag, the platform team can track exactly who is using it and how often. If usage drops below a threshold after three months, the flag can be removed and the tool deprecated with minimal disruption. Feature flags also allow gradual rollouts and canary testing, which reduces the risk of breaking existing workflows when a tool is finally removed. Several platform teams have reported that feature flags reduced the time to deprecation decision by an average of four months.

Finally, publishing a public roadmap with end-of-life dates creates transparency and accountability. The roadmap shows not only what the team is building, but also what they plan to retire. Application teams can plan their own work around these dates, and they can provide feedback if a deprecation would cause significant pain. The roadmap also helps the platform team prioritize: if a tool is scheduled for deprecation, they can stop investing in new features and focus on migration support. As platform teams save budgets by deprecating dormant repos, the roadmap becomes a strategic planning tool.

Case Study: A Platform Team That Killed Its Own CLI

A mid-sized fintech company built a custom CLI for service scaffolding. The tool was designed to let application teams generate new microservice projects with standardized configurations, CI pipelines, and deployment manifests. The CLI was well-engineered, with tests, documentation, and a dedicated Slack channel for support. Initial adoption was encouraging: within three months, roughly 40% of new services were created using the CLI. But then adoption flatlined. For the next eighteen months, that 40% figure did not budge. The remaining 60% of teams continued to scaffold services manually, copy-pasting from existing projects or using their own scripts.

The platform team spent roughly 60% of each sprint on bug fixes, dependency updates, and documentation improvements for the CLI. They added new features—support for different programming languages, integration with a new secret store, a plugin system—but none of these features moved the adoption needle. The team began to suspect that the CLI was solving a problem that most teams did not have. The teams that used it were already aligned with the platform team's conventions. The teams that did not use it had their own established workflows and saw no reason to change.

The turning point came when the platform team conducted a simple exercise: they listed every feature of the CLI and asked whether an existing open-source tool could provide the same functionality. They found that three open-source tools—Cookiecutter for project templating, Docker Compose for local development, and GitHub Actions for CI—covered roughly 90% of the CLI's use cases. The remaining 10% were edge cases that only applied to one or two teams. The team made the decision to deprecate the CLI and invest in documentation and templates for the open-source alternatives instead.

The result was a net savings of roughly twelve developer-months in the following quarter. The platform team no longer spent time on CLI maintenance. The application teams that had been using the CLI migrated to the open-source tools with minimal friction, guided by the migration scripts the platform team had written as part of the deprecation process. The teams that had never used the CLI continued their existing workflows, unaffected. The platform team reallocated the saved capacity to building a new internal observability dashboard—a tool that actually had demand from multiple teams. The lesson was clear: sometimes the best way to serve your users is to stop serving them a tool they never wanted.

The Art of the Graceful Shutdown

Communicating deprecation six months in advance gives users time to plan. The announcement should include the exact date when the tool will stop working, a description of the replacement (or the reason no replacement is needed), and a link to the migration guide. The platform team should send reminders at three months, one month, and one week before the shutdown. No one should be surprised. A sudden deprecation erodes trust; a well-communicated one builds it, because users see that the team is thoughtful about the lifecycle of its tools.

Providing automated migration scripts is the single highest-leverage activity for a graceful shutdown. If the platform team can write a script that converts existing configurations, data, or workflows to the new system, the migration cost for users drops to near zero. The script should be tested on a representative sample of users before the deprecation date. Some teams run the migration script in a dry-run mode and ask users to verify the output before the actual migration. Automated migration reduces the support burden on the platform team and increases the likelihood that users will actually move.

Measuring downstream breakage with canary rollouts is especially important when the tool being deprecated is a dependency for other systems. The platform team should run the migration on a small subset of users first, monitoring error rates, latency, and support tickets. If the canary shows problems, the team can pause the rollout, fix the issues, and try again. This approach mirrors the best practices of production deployment and signals that the platform team takes reliability seriously even during deprecation. Canary rollouts also provide a natural feedback loop: if the canary fails, the team learns something about the migration that they can fix before the full rollout.

Celebrating the shutdown as a win, not a failure, is a cultural shift that many platform teams find difficult. The team that built the tool may feel a sense of loss or embarrassment. But framing the deprecation as a sign of maturity—the team is actively curating its portfolio—helps change the narrative. Some teams hold a "shutdown party" where they delete the tool's code from the main repository in a group ceremony. Others write a postmortem that highlights what the team learned from building and retiring the tool. The celebration acknowledges the work that went into the tool while affirming that the team's goal is impact, not permanence.

Archiving the source code but removing it from active distribution is a pragmatic middle ground. The code remains available in the repository for reference, but it is no longer maintained or promoted. Users who have not migrated by the deadline will find that the tool no longer works, and they will be directed to the migration guide. The archive ensures that no one accidentally depends on a deprecated tool, while preserving the possibility of resurrecting the code if a future need arises—though in practice, resurrection is rare. The archive is a safety net, not a loophole.

Tradeoffs Nobody Puts in the README

Killing tools demoralizes the builders who created them. Engineers invest significant emotional energy in their creations, and deprecation can feel like a rejection of that effort. The platform team must manage this emotional cost carefully. One way is to rotate team members through maintenance roles so that no single engineer feels personally responsible for a tool's survival. Another is to explicitly celebrate the learning that came from building the tool, even if the tool itself did not last. The goal is to separate the value of the work from the permanence of the output.

Customers—in this case, internal engineering teams—lose trust if you deprecate too aggressively. If every tool has a two-year expiration date and the platform team never invests in long-lived solutions, application teams may stop adopting new tools altogether. The key is to deprecate only when the tool is clearly unused or replaceable. A tool that is actively used by multiple teams should be maintained, even if it is not perfect. The platform team's reputation depends on being reliable, not on being ruthless. The best deprecation strategies are selective and data-driven, not indiscriminate.

Open-source alternatives may lack the security compliance that internal tools require. A platform team that replaces a custom tool with an open-source project must ensure that the project meets the organization's security, licensing, and support standards. This vetting process can take weeks or months, and it may uncover issues that make the open-source alternative unsuitable. In some cases, the internal tool, despite its low adoption, remains the only option that complies with regulatory requirements. The platform team must weigh the cost of maintenance against the cost of compliance.

Replacing a tool can cost more than maintaining it, especially if the tool is deeply integrated into the organization's workflows. A CLI that is embedded in CI pipelines, referenced in onboarding documentation, and assumed by monitoring scripts may require months of migration effort to replace. The platform team must estimate the total cost of replacement—including the engineering time, the disruption to users, and the risk of breakage—and compare it to the ongoing maintenance cost. In some cases, the rational decision is to keep the tool alive, even if it is not widely used, because the cost of removal exceeds the benefit.

The best platform teams approach deprecation with humility and a focus on long-term value. They recognize that every tool has a lifecycle, and that the decision to retire a tool is as strategic as the decision to build it. As platform teams pay most for tools engineers silently abandon, the teams that learn to let go are the ones that deliver the most value. But they also know that deprecation is not a silver bullet—it requires careful planning, clear communication, and a willingness to invest in migration support. The goal is not to kill tools for the sake of killing, but to keep the platform lean, focused, and aligned with what engineers actually need.