The Platform That Didn't Need to Be Built: A Staff Engineer's Restraint
The Platform That Didn’t Need to Be Built: A Staff Engineer’s Restraint
Sarah had been a Staff Engineer at a rapidly growing fintech company for two years. Her team was struggling with deployment complexity across 50+ microservices. Every deployment required manual coordination, engineers ping-ponged between Slack channels, and incidents often traced back to deployment ordering issues.
The obvious solution seemed clear: build an internal deployment platform with dependency management, automated rollouts, and integrated rollback capabilities. Sarah even had a design doc drafted. Six months of engineering time, maybe eight with proper testing. The team was excited.
But Sarah did something unexpected. She said no to her own proposal.
The Investigation Nobody Asked For
Before completely shelving the platform idea, Sarah spent a week doing something unglamorous: she shadowed deployments. Not from her desk watching logs, but sitting with engineers as they deployed, asking questions about each step.
What she discovered:
- Only 12 of the 50 services deployed frequently (weekly or more)
- The “complex coordination” happened in just 4 critical paths
- Most deployment pain came from 3 services that nobody wanted to touch
- Engineers had built unofficial scripts and tools that worked reasonably well
- The real problem wasn’t lack of platform—it was unclear service boundaries
The deployments weren’t actually broken. They were symptoms of architectural issues that a platform would mask, not fix.
The Unsexy Solution
Instead of building a platform, Sarah proposed something far less exciting:
Phase 1: Formalize What Works
- Document the informal scripts teams were already using
- Create a thin wrapper around existing CI/CD tools
- Establish clear deployment runbooks for the 4 critical paths
- Total effort: 3 weeks
Phase 2: Fix the Root Causes
- Refactor the 3 problematic services with unclear boundaries
- Establish service ownership and on-call rotation
- Create explicit contracts between coupled services
- Total effort: 8 weeks, spread over 6 months
Phase 3: Standardize (If Needed)
- Re-evaluate after 6 months whether a platform is needed
- If yes, build based on proven patterns from Phase 1 & 2
Her tech lead was skeptical. “This feels like we’re just kicking the can down the road. Won’t we eventually need the platform anyway?”
Sarah’s response: “Maybe. But we’ll need it for the right reasons, and we’ll know exactly what to build. Right now, we’d be building a platform to avoid fixing our architecture.”
The Execution: Influence Without Authority
Sarah didn’t have authority over the services that needed refactoring. They belonged to three different teams, each with their own priorities. Here’s how she created change without mandates:
Step 1: Create Visibility
- Built a dashboard showing deployment coupling and incident correlation
- Made deployment pain quantifiable: time, incident rate, engineer hours
- Shared monthly with engineering leadership
Step 2: Make It Easy to Do the Right Thing
- Paired with each team to understand their constraints
- Created refactoring proposals that fit their roadmaps
- Offered to do the grunt work of migration if they owned testing
Step 3: Build Success Stories
- Started with the team most open to change
- Documented improvements: 60% fewer deployment incidents, 40% faster deployments
- Used success story to motivate other teams
Step 4: Create Economic Pressure
- Calculated cost of deployment coordination: 2.5 engineer-weeks monthly
- Showed how refactoring would pay for itself in 3 months
- Made inaction more expensive than action
Within four months, all three problematic services had been refactored. The documented scripts from Phase 1 were working well. When Sarah revisited the platform question six months later, the team’s consensus was clear: “We don’t need it anymore.”
The Career Impact
Sarah’s approach had unexpected consequences for her career trajectory:
What She Didn’t Get:
- A shiny new platform to showcase
- Conference talks about building internal tools
- A big “launch” moment
What She Did Get:
- Reputation as someone who solves real problems, not just builds features
- Trust from peer teams for understanding their constraints
- Credit for saving 6 months of engineering time
- Recognition from leadership for business judgment
- A stronger case for promotion to Principal Engineer
Six months after the project, during her performance review, her engineering director said something revealing: “You could have built the platform and gotten credit for shipping something big. Instead, you saved us from a mistake. That’s exactly what we need from Staff Engineers.”
The Lessons: What Makes This Staff-Level Work
This case study reveals several patterns that distinguish Staff Engineer work from earlier career stages:
1. Business Judgment Over Technical Complexity
Early career: “What’s the most elegant solution?”
Senior: “What’s the most robust solution?”
Staff: “What’s the solution that creates the most value?”
Sarah chose boring refactoring over exciting platform building because it delivered more value. Staff Engineers need to develop business judgment that goes beyond technical merit.
2. Influence Through Economics
Sarah didn’t win through technical authority. She won by making the business case undeniable. When you can translate technical problems into economic impact, you create executive alignment.
Key technique: Always quantify in terms leadership cares about:
- Engineering time saved
- Incident reduction
- Time-to-market improvement
- Cost avoidance
3. The Courage to Say No (Especially to Yourself)
The hardest “no” is the one you say to your own ideas. Sarah had emotional investment in the platform. Walking away required ego management and long-term thinking over short-term recognition.
4. Making Architectural Issues Visible
The dashboard showing deployment coupling was crucial. It transformed a fuzzy problem (“deployments feel hard”) into concrete data. Staff Engineers often need to create measurement systems before they can drive change.
5. Enabling Teams Rather Than Building For Them
Sarah could have built the platform and handed it to teams. Instead, she enabled teams to fix their own issues. This approach scales better and builds organizational capability.
The Anti-Patterns to Avoid
Don’t:
- Build platforms before you have proven patterns
- Solve coordination problems with technology when the issue is architectural
- Let resume building drive technical decisions
- Underestimate the value of unglamorous investigation
- Assume complexity requires complex solutions
Do:
- Shadow actual users before designing solutions
- Look for root causes beneath surface symptoms
- Choose boring solutions when they work
- Build credibility through business impact, not just technical sophistication
- Be willing to advocate for not building things
The Follow-Up: One Year Later
A year after Sarah’s project, the company had scaled to 80 microservices. Deployment processes were still working smoothly with the lightweight approach. When the team finally did invest in platform capabilities, they built exactly what they needed based on a year of real usage patterns.
The platform they eventually built took 6 weeks instead of the original 6-month estimate, because they knew precisely what to build and what to skip.
Sarah’s work became part of company lore: “Remember when Sarah saved us from building that platform?” It became a reference point for other Staff Engineers facing similar decisions.
Takeaway for Staff Engineers
The hardest part of Staff Engineering isn’t building complex systems. It’s having the judgment to know what not to build, the influence to drive change without authority, and the patience to solve root causes instead of symptoms.
Sometimes the most impactful technical leadership is choosing restraint over ambition.