A Self-Serve Platform to Enhance Development Team Efficiency

How we built a Backstage-powered internal developer platform that eliminated DevOps bottlenecks and boosted team efficiency by 50%.

At a Glance

• 50% increase in DevOps team efficiency
• 100% of existing APIs imported into the new platform
• Self-serve deployments for developers, no DevOps ticket required
• Standardized processes across all new releases, increasing security and control

The Client

A growing API-driven SaaS company with a rapidly expanding engineering organization. The platform served multiple teams building and deploying API services on AWS, supported by a central DevOps team responsible for provisioning the baseline infrastructure that developers needed to build on.

The business was scaling, the number of teams was growing, and the volume of new API services was increasing. But the process for getting those services deployed hadn't scaled with it.

The Challenge

Every time a development team needed to deploy a new API service, they had to wait for a DevOps engineer to provision the underlying infrastructure. Networking, IAM roles, deployment pipelines, scaffolding — none of it was available on demand. Developers filed a request, and then they waited.

This created a persistent bottleneck. DevOps engineers spent a significant portion of their time on repetitive provisioning tasks instead of higher-value work like improving reliability, security, and platform capabilities. Developers, meanwhile, were blocked until someone from DevOps was available to unblock them. The dependency was a drag on both teams.

As the company grew, the problem compounded. More teams meant more requests. More requests meant longer queues. The DevOps team became a throughput constraint on the entire engineering organization, and the coordination overhead was eating into delivery velocity across the board.

Why This Was Hard

The obvious answer — "just automate provisioning" — understated the real complexity. The client needed a platform that met several competing requirements at once.

First, it had to be genuinely self-serve for developers without sacrificing the control and governance that DevOps needed to maintain. Handing developers raw access to infrastructure tools wasn't an option. The platform needed user-friendly interfaces that abstracted the complexity while still enforcing the right guardrails.

Second, the platform had to integrate cleanly with the client's existing infrastructure-as-code, SCM tooling on GitHub, and AWS environments. A greenfield rebuild was off the table. Whatever we built had to slot into the current ecosystem with minimal refactoring.

Third, it needed backward compatibility. The client had a portfolio of existing APIs already running in production. The new platform couldn't just serve new services — it had to import and manage the existing ones too, or it would create a split world that doubled the operational burden instead of reducing it.

And finally, there was the classic buy-vs-build decision. Building a full internal developer platform from scratch would take months and require ongoing maintenance. But off-the-shelf tools rarely fit the specific workflows, auth systems, and CI/CD patterns a company already has in place.

Nimble's Approach

After evaluating the landscape, we chose Backstage as the foundational platform. It was the right fit for several reasons: its plugin architecture gave us the flexibility to extend it for the client's specific needs, it provided out-of-the-box UI components that we didn't need to build from scratch, and its open-source ecosystem meant we weren't locked into a single vendor's roadmap. Critically, Backstage could be adapted to meet the client's existing security controls.

From there, we built the custom integrations that turned Backstage from a generic developer portal into a tailored internal developer platform.

We developed a custom backend plugin that connected to the client's SCM (GitHub) and cloud infrastructure (AWS). This plugin pulled metadata from both systems and used it to enrich the options available to developers when creating or managing services. Instead of filling out forms with information they'd have to look up manually, developers saw context-aware fields populated with real data from their repos and AWS accounts.

We created a custom SAML authentication integration so the platform could plug into the client's existing centralized auth system. No separate credentials, no new login flow. Developers authenticated the same way they did for everything else.

We designed a deployment and feature-creation lifecycle plugin that aligned with the company's existing CI/CD pipelines. When a developer spun up a new service through the platform, the deployment pipeline was generated automatically, following the same patterns the DevOps team had established. This standardized how every new service was created and deployed, without requiring DevOps to configure each one manually.

Finally, we designed the entire platform for backward compatibility. Existing APIs could be imported into Backstage with minimal refactoring, so the client didn't end up with two parallel systems. The platform became the single source of truth for all API services, old and new.

The Results

50% Increase in DevOps Team Efficiency

With developers now self-serving their own infrastructure provisioning, the DevOps team reclaimed half their capacity. They redirected that time toward mission-critical work: improving platform reliability, strengthening security posture, and moving the business forward instead of processing provisioning tickets.

100% of Existing APIs Imported

The backward-compatible design meant the client didn't have to choose between managing legacy services in one system and new services in another. Every API lives in the same platform, managed the same way.

Faster Developer Onboarding

New developers could start deploying services quickly because the platform's interfaces were intuitive and enriched with useful metadata from GitHub and AWS. No tribal knowledge required.

Standardized Release Processes

Every new service followed the same deployment patterns, enforced by the platform. This increased both control and security, because deviations from the approved pipeline patterns were no longer possible.

Infrastructure Scaffolding Maintained by DevOps

Baseline infrastructure for new services was deployed from scaffolding templates that the DevOps team designed and maintained. Developers got consistent, production-ready foundations without DevOps having to provision each one manually.

What's Next

With the internal developer platform in place, the client's engineering organization has a foundation that scales with them. New teams can spin up services on demand, DevOps maintains governance through templates and plugins rather than ticket queues, and the platform itself can evolve as new needs emerge — new integrations, new service types, new compliance requirements — all through the plugin architecture that Backstage provides.