The cost of acquisitions: What we learned about engineering from a decade of rapid growth
When you acquire another software company, you inherit every decision that the team made before you got there: the code, the tech stack, the architecture, the team structure, and all the conventions nobody wrote down.

When you acquire another software company, you inherit every decision that the team made before you got there: the code, the tech stack, the architecture, the team structure, and all the conventions nobody wrote down.
In the first half of 2026 alone, companies announced $2.8 trillion in mergers and acquisitions globally, the highest first-half total since LSEG (London Stock Exchange Group) started keeping records in 1980.
Everyone's ready to celebrate a closed deal, but few plan for the long-term aftermath. The real complexity rarely appears on day one. It builds quietly over years as teams operate in silos, until engineers eventually look up and realize that years of unaddressed tech debt have accumulated into a fragmented ecosystem.
At Spotify, we've experienced that aftermath. We've grown (including through acquisitions of our own) and built our early engineering culture on radical autonomy. When you're under pressure to grow fast, you may not care about standardization, but eventually, it creates a fragmentation problem you have to address.
We learned that lesson. Ultimately, it led us to create Backstage, which is now the industry-standard IDP.
If your engineering organization grew through acquisitions, you're going to run into the same problem we did: You can't scale effectively (especially in the age of AI), until you standardize how your teams build, measure, and ship code.
Here's what we learned from our season of growth and how we rebuilt our foundation to scale without compromising the secret sauce of our engineering team.
Rapid growth via acquisitions creates technical fragmentation
At Spotify, we initially designed our squad model around developer autonomy so we could move fast with minimal dependencies. It worked until we were hiring large waves of engineers every year, and acquiring companies at a steady clip. Each acquired team arrived with its own way of working, and our autonomy-first model gave them no reason to change it.
Eventually, that growth created widespread fragmentation. We ended up with a stack where every service was built differently, with limited standardization. Documentation wasn't always the most up to date. And half the time, nobody could say for sure who owned a given service. The backend was so complicated that the time for a new engineer to safely merge their 10th pull request climbed toward 60 days (against a target of 20).
Because we hadn't prioritized standardization alongside autonomy, our growth was costing us in visibility and control. We didn't know who owned which services. We had no clear view of system dependencies or if the system was healthy before a commit.
An IDP fixed our fragmentation problem
We didn't start with a master plan to build an internal developer platform. Driven by frustration over fragmented tooling, our engineers hacked together System Z (the solution that eventually became Backstage) to establish standards without compromising our engineering culture.
Over time, System Z evolved into a comprehensive developer portal that standardized delivery and reduced friction for our developers. Backstage defragmented our software ecosystem and created a solid foundation to scale our platform safely and efficiently.
First, it clarified service ownership. Before Backstage, engineers tracked service owners and on-call rotations in spreadsheets, which was impossible to scale. System Z provided a simple and always up to date dashboard that mapped services to their owners and APIs. Backstage ran with that idea at scale, creating a centralized service and ownership catalog across what were then 280+ engineering teams.
Backstage also helped us establish shared engineering standards. When teams build without common conventions, it becomes nearly impossible to keep services compatible. To prevent further fragmentation, we built "Golden Paths" (standardized workflows for shipping code) without restricting anyone's tech stack choice outright. Now, teams can pick a template inside Backstage, fill in a few fields, and in seconds get a fully configured, already-approved repo, wired into the right CI/CD pipeline with the right standards.
Golden Paths completely change the playbook for integrating new teams. Instead of forcing an acquired engineering team to endure a long, painful effort to rebuild their entire stack to match yours, Golden Paths keep services from drifting.
To keep standards aligned as services evolve, Soundcheck (a Backstage plugin) uses automated, codified checks to continuously monitor component health. Instead of responding to manual tickets, developers get real-time service health scorecards with actionable feedback to make sure their software stays secure, reliable, and compliant.
For Spotify, Backstage ultimately cut onboarding time by 55%. That makes onboarding more engineers or acquiring a new company survivable for our platform engineering team.
You can't prove ROI on what you can't measure.
Beyond slowing your team down and frustrating your engineers, fragmentation has longer-term impacts on your competitive posture. Without that single pane of glass allowing your team to understand all your code, standards, and services, you can't determine baseline metrics. And that means you can't evaluate performance or prove value to leadership to justify budget requests you need to grow.
That lack of visibility only becomes more expensive with AI coding agents in the mix. Unlike experienced engineers who understand system context, agents struggle to navigate fragmented architecture without clear standards. So, they either generate non-compliant code (that will need reworking) or burn tokens trying to parse unstandardized context.
With Backstage, our team can now make clear decisions about what's working, what isn't, and what to build next, then make a credible case to leadership for the budget we need to deliver it. With Xirp (our agent orchestration layer) operating in tandem, our coding agents also have the context they need to build intelligently without breaking dependencies.
Standardize your platform before you scale the next thing
Building an IDP wasn't the most exciting initiative on our roadmap at the time, but it's the one that let us overcome fragmentation so we could grow sustainably again. Today, our IDP standardizes how our engineering teams build, track, and ship code through a single centralized platform.
The DIY approach was painful. We were building the tooling and solving the problem at the same time, with no blueprint to follow. And after we open-sourced Backstage in 2020, many other companies adopted it and ran into a common problem: setting up and running that infrastructure yourself is a real, ongoing commitment. Not every company wants (or has the resources) to take that on. That led us to build Portal: all the features of Backstage, but we run it for you.
If you're dealing with fragmentation after an acquisition, tell us how you're handling it: what's worked, and where are you stuck?