Skip to content

How I Saved My Client Thousands by Removing 200+ Dead API Endpoints

4 min read In EnglishУкраїнськоюPo polsku

How I used Datadog, Kibana, and Jira automation to help remove 200+ unused API endpoints and retire unnecessary microservices and AWS Lambda functions.

Illustration of tangled API connections being scanned and simplified into a leaner microservices architecture as obsolete endpoints are removed.
On this page

The Hidden Cost of API Bloat

Sometimes, the most valuable engineering work isn't adding another feature. It's figuring out what the system no longer needs.

On a previous project, I worked with a large microservices architecture containing more than a thousand API endpoints. As products evolved, some features disappeared, but the endpoints built to support them remained. That left us with code to understand, test, secure, and maintain—even when it no longer served a useful purpose.

I saw an opportunity to turn that accumulated technical debt into something actionable. The result was the removal of more than 200 unused API endpoints, along with the decommissioning of several microservices and AWS Lambda functions.

Why Unused API Endpoints Matter

An unused route doesn't automatically generate a large cloud bill. If nobody calls it, its direct compute cost may be close to zero. The real cost often sits elsewhere: in code ownership, tests, dependencies, security reviews, troubleshooting, and the uncertainty developers face when changing legacy systems.

In a microservices environment, obsolete functionality can also keep entire workloads alive. A service or Lambda function that is no longer needed may still have associated infrastructure, configuration, monitoring, and maintenance overhead. Removing an endpoint is useful; being able to retire the infrastructure behind it is where the savings become much more tangible.

Taking Initiative: From Suspicion to Evidence

With more than a thousand endpoints, checking them one by one would have been a poor use of engineering time. Luckily, the project already had observability tools in place: Datadog for monitoring and tracing, and Kibana for exploring service logs.

Those tools made it possible to investigate which endpoints appeared to be receiving traffic over a given observation period. But there is an important distinction: no observed requests does not prove an API is safe to delete. Logs may have limited retention, monitoring may be incomplete, and some endpoints are used only by infrequent jobs or integrations.

So I treated missing or very low traffic as a signal to investigate, not as an automatic deletion decision. The goal was to identify credible cleanup candidates and make the follow-up work manageable.

Working Smarter with Datadog, Kibana, and Jira APIs

Instead of spending days clicking through dashboards, I used the Datadog and Kibana APIs to automate the repetitive part of the investigation. That let me analyze endpoint usage at a scale where manual checks would have been impractical.

Then I connected the discovery process to the Jira API, creating cleanup tickets for endpoints that warranted review. This turned scattered monitoring information into a trackable engineering backlog.

The interesting part wasn't the API integration itself. It was recognizing that tools we already paid for could be combined into a practical workflow: find candidates, make them visible, validate their usage, and coordinate removal. Automation helped us focus engineering attention on decisions rather than repetitive searches.

The Outcome: 200+ Endpoints Removed—and Infrastructure Retired

The initiative ultimately helped us remove more than 200 unused API endpoints. Importantly, the cleanup also made it possible to decommission several microservices and AWS Lambda functions that were no longer required.

That distinction matters. Deleting unused route handlers simplifies a codebase; retiring whole workloads can also eliminate ongoing cloud and operational costs. Fewer components mean fewer things to deploy, monitor, troubleshoot, and keep secure.

I no longer have access to the client's AWS billing or historical metrics, so I can't provide a verified dollar total or claim a measured performance improvement. The title's reference to “thousands” is a directional estimate of the combined infrastructure and engineering cost avoided—not an audited savings figure. The outcomes I can stand behind are the 200+ endpoint removals and the decommissioned services and Lambda functions.

The Bigger Lesson: Optimization Is an Engineering Mindset

It's easy to measure engineering output by how many features we ship. But mature systems also benefit from engineers who question what should still exist.

For me, this project was about more than deleting code. I identified an opportunity in a complex system, used existing observability data to investigate it, automated the repetitive work, and helped turn the findings into concrete cleanup.

Good engineering isn't only about building more. Sometimes it's about having the initiative—and the evidence—to safely build less.