Every microservice starts with a purpose. Somewhere, a team had a vision, wrote code, deployed to production, and moved on. A year later, that service is still running, still consuming CPU and memory, still accruing AWS bills—but nobody knows who owns it, what it does, or whether anyone still uses it. This is the ghost fleet of modern architecture, and it is costing companies hundreds of thousands of dollars each year.

Platform teams are uniquely positioned to hunt these ghosts. Unlike product teams focused on features, platform teams own the infrastructure, the deployment pipelines, and the observability tooling. They can see the services that no longer serve a purpose. And when they track and retire those services, the savings are dramatic.

The $150,000 Microservice Nobody Wants to Admit Exists

Consider a mid-size fintech company that had grown through acquisition. Over three years, the engineering organization ballooned from 50 to 300 people, and the number of microservices exploded from 60 to over 400. Each acquired company brought its own stack, its own services, and its own deployment practices. The platform team inherited a sprawling, poorly documented system.

During a routine cost audit, the platform team discovered 20 services that had not received a single API call in over six months. Some had not been deployed in more than a year. A handful had no documented owner—the teams that built them had been reorganized or dissolved. The annual cost of those 20 orphaned services? Roughly $400,000 in compute and storage alone, according to internal estimates shared at a 2024 industry conference. That does not include the indirect costs: security patching, dependency upgrades, and the cognitive load of maintaining code nobody understands.

This is not an isolated story. A 2023 survey by a major cloud provider found that nearly 30% of microservices in large organizations are either unused or underutilized. Platform teams that ignore this problem are effectively burning money. The first step is admitting the problem exists, and the second is building a system to track it.

Why Microservices Rot Faster Than Monoliths

Monoliths have a natural gravity. A single codebase, a single deployment, a single team—it is hard to lose track of the whole thing. Microservices, by contrast, are designed to be independent. That independence is a strength for scaling development, but it creates a blind spot. When a team reorganizes, the service they built does not disappear. It keeps running, quietly, until someone notices the bill.

Documentation often vanishes with employee turnover. A service that was well-documented two years ago might have no README after the original author leaves. Configuration files get stale. Dependencies grow outdated. The service still works, but nobody knows how to modify it safely. The platform team sees a black box that nobody wants to touch.

Observability gaps hide silent failures. A service that receives zero traffic might still be running health checks, logging errors, and consuming memory. Without cost-attribution dashboards or traffic analysis, those errors go unnoticed. The service is not failing loudly; it is failing quietly, draining resources.

Cognitive load pushes cleanup to the backlog forever. Every engineer has a list of things to do. Cleaning up a service that might be used by someone somewhere always ranks below shipping the next feature. The platform team can break this cycle by making abandonment visible and automating the retirement process.

The Discovery Phase: Finding Your Ghost Fleet

Finding orphaned services requires more than a hunch. The platform team needs data. The first place to look is the service mesh traffic logs. A service that has received zero requests in 30 days is a candidate. Zero requests in 90 days is a strong signal. At the fintech company mentioned earlier, the platform team exported traffic logs from Istio and found that 12% of services had not handled a single request in three months.

Deployment frequency is another indicator. A service that has not been deployed in 90 days is likely abandoned. Teams that actively maintain their services deploy frequently—weekly or daily. A service with no deployments in a quarter suggests the team has moved on. The platform team can query the CI/CD pipeline for last deployment timestamps and flag anything older than 90 days.

Talking to SREs is surprisingly effective. Site reliability engineers often know which services cause trouble and which are dormant. They see the alerts that nobody responds to, the dashboards that nobody looks at. In one case, an SRE pointed to a service that had been crashing nightly for six months, but the team responsible had been dissolved. The crashes were silently filling up logs and costing $2,000 per month in log storage alone.

Cost-attribution dashboards are the final piece. Most cloud providers offer tools to tag resources by team or service. If a service has no tags, or if the tags point to a team that no longer exists, that service is a candidate for decommissioning. The platform team can build a simple dashboard showing cost per service, sorted by age of last deployment. The orphans float to the top.

Case Study: How a Mid-Size SaaS Cut $600K in Cloud Waste

In 2023, a mid-size SaaS company with roughly 400 microservices undertook a systematic cleanup. The company had grown through two acquisitions, and the platform team suspected that many services were redundant or unused. They started with a traffic audit, using the service mesh logs to identify services with zero traffic over 90 days. They cross-referenced with deployment frequency and owner metadata from their internal developer platform.

The results were sobering: 48 services—12% of the total—had no active users. Some were internal APIs that had been replaced by newer versions. Others were data processing services that had been superseded by a unified pipeline. A few were experiments that never made it to production but were still running on expensive instances.

Decommissioning those 48 services took six months. The platform team created a standard retirement process: notify all potential stakeholders, archive the code repository, remove the service from the service mesh, delete the cloud resources, and update the documentation. Each retirement was celebrated with a small ritual—a Slack message, a virtual high-five—to reinforce the cultural value of cleanup.

The financial impact was significant. The company saved roughly $50,000 per month in compute and storage costs, or $600,000 annually. That is not counting the indirect savings: reduced security patching surface, fewer dependency upgrades, and less cognitive load for the platform team. The cleanup also made it easier to onboard new engineers, who no longer had to navigate a sea of irrelevant services.

Trade-Offs: When Not to Retire a Service

Not every unused service should be retired immediately. There are legitimate reasons to keep a service running even if it receives zero traffic. For example, a service might be a dependency for batch jobs that run quarterly. If the batch job is critical for financial reporting, retiring the service prematurely could break the reporting process. The platform team must distinguish between truly abandoned services and those that are dormant for valid reasons.

Another trade-off involves compliance. Some services store data that must be retained for regulatory purposes, even if the service itself is no longer in active use. In such cases, the data might need to be migrated to a long-term archive before the service can be decommissioned. The platform team should coordinate with legal and compliance teams to ensure data retention policies are followed.

There is also the cost of decommissioning itself. Retiring a service takes engineering time—time spent on notifications, code archiving, resource deletion, and documentation updates. For a service that costs only $10 per month, the decommissioning effort might not be worth it. The platform team should set a cost threshold: for example, only decommission services that cost more than $100 per month, or that have no owner and no traffic for 90 days. Smaller services can be left running until a more efficient cleanup cycle.

Finally, there is the risk of breaking unknown dependencies. Even with traffic logs, it is possible that a service is called by another service that is not instrumented. A cautious approach is to first disable the service (e.g., remove it from the service mesh) and monitor for any breakage for two weeks before fully deleting it. This staged retirement reduces the risk of unintended outages.

The Playbook for Systematic Service Retirement

Retiring services at scale requires process, not heroics. The first step is defining ownership rules. Every service must have a team and an owner. If a service has no owner after a reorganization, the platform team should be notified automatically. Some organizations use a service catalog that requires a valid team ID; if the team is removed, the service is flagged.

Automated deprecation warnings are the next layer. When a service has received zero traffic for N days—say, 30—the platform team should send a warning to the last known owner. If there is no response within another 30 days, the service enters a deprecation queue. After 90 days of zero traffic, the service is automatically retired, with a final notification window for anyone to object.

A 'zombie kill switch' in the CI/CD pipeline can prevent new dead services from accumulating. For example, every service must deploy at least once every 90 days or it is automatically removed from the service mesh. This forces teams to either maintain their services or explicitly declare them obsolete. The kill switch can be configured with exceptions for seasonal services, but the default should be removal.

Celebrating removals is important. Platform teams that track abandoned microservices often create a 'decommissioned' dashboard that shows the number of services retired each month. Some teams give out digital badges or small rewards for the most impactful removals. The goal is to make cleanup as visible as shipping, and to reduce the entropy that accumulates in any large system.

Measure What Matters: Tracking Abandonment Metrics

To sustain cleanup over time, the platform team needs a dashboard. The most important metric is cost per service, updated weekly. A service that costs $500 per month might not seem like much, but 100 such services add up to $50,000 per month. The dashboard should show the total cost of all services, with a breakdown by team and by age of last deployment.

Age of last deployment is a leading indicator. If a service has not been deployed in 90 days, it is likely abandoned. The dashboard should flag these services and show the trend over time. A healthy organization should see the number of services with no deployment in 90 days trending toward zero.

Number of services with no documented owner is another key metric. This is a sign of organizational debt. The platform team should aim to keep this number in the single digits. If it grows, it indicates that the ownership process is broken.

Targets should be set and reviewed quarterly. For example: reduce the number of zero-owner services from 15 to 5 in the next quarter, or reduce the total cost of services with no traffic in 90 days by 50%. The platform team should report these metrics to engineering leadership, tying them directly to cloud cost savings.

Counter-Arguments: Why Some Teams Hesitate to Retire

Despite the clear benefits, some engineering organizations resist systematic service retirement. A common objection is the fear of breaking something: "We don't know what this service does, but it might be important." This fear is understandable, but it is also a symptom of poor observability. The remedy is not to leave the service running indefinitely, but to invest in better monitoring and dependency mapping. Once you have confidence in your traffic logs, the fear diminishes.

Another objection is that cleanup is not a feature. Product managers often prioritize new functionality over maintenance, and retirement is seen as non-value-added work. However, this view ignores the opportunity cost: every hour spent maintaining a ghost service is an hour not spent on features that customers actually use. By quantifying the cost of abandoned services, the platform team can make a business case that cleanup is a high-ROI investment.

Some engineers argue that decommissioning is risky because a service might be needed again in the future. But if the service is truly abandoned, the code is still in version control. If it is ever needed again, it can be redeployed from the repository. The cost of redeployment is far lower than the cumulative cost of keeping it running for months or years.

Finally, there is the cultural challenge of ownership. Teams may be reluctant to admit that their old services are no longer useful. The platform team can address this by framing retirement as a positive act of curation, not a failure. Celebrating removals and tying them to cost savings helps shift the culture from accumulation to intentionality.

The Platform Team's Hidden ROI

Beyond the direct cost savings, tracking abandoned microservices improves engineering culture. Cleaning up dead code frees cognitive space. Engineers no longer have to wonder whether a service is important or whether they can safely ignore it. The platform team can focus on building tools that matter, rather than maintaining ghosts.

Fewer services also mean a smaller attack surface. Every running service is a potential entry point for an attacker. Retiring unused services reduces the risk of a security breach without requiring additional security tooling. In an era where supply chain attacks are on the rise, removing unnecessary dependencies is a low-cost, high-impact security measure.

Onboarding new engineers becomes faster when the architecture is lean. A new hire at the fintech company mentioned earlier would have had to understand 400 services. After cleanup, they only need to understand 352. That 12% reduction in cognitive load can cut weeks off the onboarding time, especially for junior engineers.

Six-figure savings is just the start. The real value is in the culture shift: from accumulation to curation, from "ship it and forget it" to "own it or retire it." Platform teams that track abandoned microservices are not just saving money—they are building a sustainable engineering practice. And that is worth more than any cloud bill.