I need to confess something: We spent 18 months and $1.2M building a DIY Backstage platform that never got past 15% adoption. It was a complete failure.
Then we killed it, switched to Roadie (managed Backstage-as-a-service), and went from 15% to 67% adoption in 4 months.
Here’s the full story of what went wrong, what we learned, and why managed platforms make sense for most companies.
The Context
Financial services company, 140 engineers, highly regulated environment. We thought we needed a custom DIY platform because:
- “We have unique compliance requirements”
- “Managed solutions won’t understand our security needs”
- “We’re engineers, we should build this ourselves”
Spoiler: We were wrong on all three counts.
The DIY Journey: 18 Months of Struggle
Month 1-6: Initial Build
- Hired 3 platform engineers
- Set up open-source Backstage
- Built basic service catalog
- Integrated with internal systems
Feeling: Optimistic. “This isn’t that hard!”
Month 7-12: Feature Additions
- Added CI/CD templates
- Built custom plugins for our tech stack
- Created golden paths for microservices
- Integrated monitoring and logging
Feeling: Busy. “So many features to build…”
Month 13-18: The Adoption Wall
- Launched to entire engineering org
- Only 15% of developers actually used it
- Most stayed in old workflows (GitHub, direct AWS access, Slack for discovery)
- Support tickets piled up
- Platform team spent 80% of time on maintenance, 20% on new features
Feeling: Frustrated and demoralized.
The Post-Mortem: What Went Wrong?
We brought in an outside consultant to review our platform. Their findings were brutal but accurate:
1. We Built What WE Wanted, Not What Developers Needed
Our assumptions:
- “Developers need a service catalog”
True - “Developers need CI/CD templates” True
- “Developers will love our custom integrations”
False
Reality from user interviews:
- “I can’t figure out how to use the golden paths”
- “The documentation is incomplete and confusing”
- “I just want to deploy my service, why is this so complicated?”
- “The UI is slow and doesn’t work half the time”
We never asked developers what they actually wanted. We just built what seemed technically cool.
2. We Had No Product Manager
Our platform team was 3 brilliant infrastructure engineers with zero product management experience.
We didn’t:
- Run user research
- Prioritize based on user value
- Track adoption metrics
- Measure developer satisfaction
- Have a real roadmap beyond “add more features”
We built infrastructure, not a product.
3. Maintenance Ate All Our Time
Month 6: Backstage releases new version, we need to upgrade
Month 9: Security vulnerabilities in our plugins, need to patch
Month 12: Breaking changes in Backstage API, rebuild 4 plugins
Month 15: Infrastructure scaling issues, need to optimize
Month 18: Another Backstage upgrade, more breaking changes
We spent 80% of our time keeping the lights on, 20% building value.
Meanwhile, our managed solution competitors were releasing features monthly while handling all the maintenance.
4. We Underestimated the Total Cost
Visible costs:
- 3 engineers × $180K = $540K
- Infrastructure = $80K
- Tools = $30K
- Subtotal: $650K/year
Hidden costs:
- Opportunity cost: What else could those 3 engineers build?
- Developer productivity loss: 85% of developers not using platform = inefficiency
- Support burden: Other engineers helping colleagues because platform docs were bad
Real total cost: ~$1.2M annually
And we still had 15% adoption.
The Decision to Switch
New VP Engineering joined, mandated platform review. Outside consultant recommended: “Kill the DIY platform. Go managed.”
Our reaction: Resistance.
“But we’ve invested 18 months!”
“Sunk cost fallacy,” consultant replied.
“But managed solutions won’t meet our needs!”
“Have you actually tried them?” We hadn’t.
The Migration to Roadie
Week 1-2: Roadie demo and technical evaluation
- All our “must-have” features existed
- Compliance and security features built-in
- Professional UI/UX (way better than ours)
- Integrations with our tools already available
Week 3-6: Migration execution
- Exported our service catalog and golden paths
- Roadie team helped migrate our custom plugins
- Some plugins we abandoned (turned out nobody used them)
- Developers can use same Backstage experience, just hosted
Total migration time: 6 weeks (vs. 18 months to build DIY)
The Results: 4 Months After Switch
Adoption Transformation
Before (DIY): 15% adoption
After (Roadie): 67% adoption and growing
Why the jump?
- Professional UI/UX that developers didn’t hate
- Fast performance (Roadie handles scaling)
- Regular feature updates without our effort
- Great documentation and support
- Developers trusted it more (“real product” vs “internal experiment”)
Cost Comparison
DIY platform annual cost:
- 3 engineers: $540K
- Infrastructure: $80K
- Tools: $30K
- Total: $650K
Managed Backstage (Roadie) annual cost:
- Platform fee: $85K
- 1 engineer (50% time) for customization: $90K
- Total: $175K
Annual savings: $475K
Plus we freed 2.5 engineers to work on business-critical features.
Team Transformation
Our remaining platform engineer (now at 50% time on Backstage) focuses on:
- Company-specific golden paths
- Custom integrations with proprietary systems
- Developer experience improvements
- Documentation for our workflows
No more time spent on:
- Backstage version upgrades
- Infrastructure scaling
- Plugin maintenance
- Security patches
- UI/UX improvements
Roadie handles all of that.
Developer Satisfaction
Before: NPS of 12 (abysmal)
After: NPS of 64 (good)
Developers love:
- “It actually works now”
- “The UI is fast and doesn’t crash”
- “I can find what I need”
- “Support team is responsive”
The Key Lessons
1. Your Competitive Advantage Is NOT Running Backstage
Unless you’re Spotify, Netflix, or a hyperscale company, running Backstage infrastructure is not your competitive advantage.
Your competitive advantage is:
- Domain-specific golden paths for YOUR tech stack
- Integrations with YOUR proprietary systems
- Workflows optimized for YOUR team’s needs
Let specialists handle the infrastructure.
2. Treat Platform as Product, Not Project
If we’d had a product manager from day one, they would have:
- Run developer interviews (discovered our UI was terrible)
- Tracked adoption metrics (realized 15% was failure)
- Prioritized based on user value (docs over features)
- Prevented 18 months of wasted effort
Platforms need product thinking, not just engineering.
3. Managed ≠ Less Control
Our fear: “Managed solutions won’t give us the control we need.”
Reality: We have more control now than with DIY.
With DIY, we were too busy maintaining infrastructure to build valuable customizations.
With managed, we focus entirely on the custom value layer.
4. Sunk Cost Is Sunk Cost
18 months and $1.2M invested. It hurt to walk away.
But continuing would have cost another $1.2M per year for a platform nobody used.
Walking away was the right decision.
When DIY Makes Sense vs. When Managed Wins
DIY Makes Sense If:
- You’re hyperscale (1000+ engineers) where cost economics flip
- Platform engineering IS your competitive advantage (you’re Spotify)
- You have extremely unique requirements that no vendor can meet
- You have dedicated product management for your platform
Managed Wins If:
- You’re sub-500 engineers (and honestly, probably sub-1000)
- Your differentiation is business logic, not developer tools
- You want to focus engineers on revenue-generating features
- You value velocity over control
For 95% of companies, managed is the right choice.
Advice for Others Considering DIY
Before you start:
- Actually try managed solutions (we didn’t, huge mistake)
- Calculate total cost including opportunity cost
- Hire a product manager for your platform team
- Set clear adoption and satisfaction targets
- Define what success looks like in 6 months
If you’re already struggling with DIY:
- Be honest about sunk cost fallacy
- Measure adoption and developer satisfaction
- Calculate what you could build with freed-up engineers
- Demo managed alternatives with open mind
- Make data-driven decision
Final Thoughts
Platform engineering isn’t dead. But DIY internal platforms are dying for most companies.
The winning pattern: Managed infrastructure + custom value layer.
Let Roadie (or similar) handle:
- Running Backstage
- Upgrades and maintenance
- Security and compliance
- Core UI/UX
You focus on:
- Your company’s golden paths
- Your proprietary integrations
- Your unique workflows
We went from 15% adoption with DIY to 67% with managed in 4 months, while saving $475K annually and freeing 2.5 engineers for business features.
Best decision we made.
Discussion
Has anyone else made the DIY → managed switch? How did it go?
Still running DIY? What keeps you from considering managed?
Considering managed from the start? What questions do you have?
Let’s talk about what’s actually working in 2026. 
Golden paths for our specific tech stack (microservices, data pipelines)
