How to Build Engineering Culture That Survives Hypergrowth
Build engineering culture during hypergrowth with explicit decision rights, quality standards, communication norms and growth expectations that teams can use.
I've scaled an engineering team from 8 to 120 in 18 months. The culture we started with didn't survive. Not because it was bad culture, but because it was implicit culture. And implicit culture dies the moment you can't fit everyone in one room.
Most engineering leaders talk about culture like it's a feeling. Something that happens when you hire the right people and let them vibe. That's fine at 10 engineers. At 40, it's chaos. At 100, it's a liability.
Here's what I learned about building culture that actually scales.
Every hypergrowth engineering org hits the same pattern:
Phase 1 (5-15 engineers): Culture is implicit. Everyone knows how things work because they were there when the norms formed. Decisions happen in hallway conversations. Code review standards are "whatever Sarah thinks is good." It feels great.
Phase 2 (15-40 engineers): New hires don't absorb the culture through osmosis anymore. They bring their own norms. The original team gets frustrated: "That's not how we do things here." But nobody wrote down how you do things. Velocity drops. Quality becomes inconsistent.
Phase 3 (40-100+ engineers): Subcultures form. Each team develops its own norms. Some teams ship fast with high quality. Others ship slow with bugs. There's no shared standard. The org feels fragmented.
I've watched this happen three times. The third time, I decided to prevent it.
Here's the take that makes people uncomfortable: engineering culture isn't a vibe. It's infrastructure. It needs to be designed, documented, maintained, and versioned, just like your codebase.
If your culture isn't written down, it doesn't exist. It's just a set of preferences held by whoever has the most social capital on the team.
I know this sounds cold. It isn't. Writing culture down doesn't kill the human element. It protects it. When norms are explicit, new hires can participate from day one instead of spending months guessing at unwritten rules. That also matters when onboarding developers to a codebase.[1]
Figure 1. Four documents make recurring engineering expectations explicit.
I built a system I call Culture OS. It has four components, and each one gets documented, reviewed quarterly, and updated when the team grows past a threshold.
Who gets to make what decisions? This is the number one source of dysfunction in growing teams. When decision rights are unclear, everything requires consensus, and consensus at scale is paralysis. The engineering leadership guide discusses the wider responsibilities behind those choices.[2]
Write down:
Individual decisions: Any engineer can choose libraries, tools, or patterns within their service without approval.
Team decisions: The team decides on API contracts, testing strategies, and sprint priorities. Majority vote, tech lead breaks ties.
Architecture decisions: The architecture guild approves cross-service changes, new data stores, and new external dependencies. Requires a written architecture decision record.
Org decisions: VP/CTO decides on team structure, hiring priorities, vendor selection above $50K/year.
This list took me two hours to write. It saves roughly 10 hours of ambiguity per week across the org.
How do we communicate? This matters more than most leaders think.[3]
Our communication norms:
RFCs for big decisions. Any change that affects more than one team starts with a one-page RFC. Template provided. Anyone can comment within 5 business days. Silence is consent.
Weekly engineering all-hands. 30 minutes. Three sections: wins, learnings, upcoming changes. No status updates. Those go in written form.
Async by default. Don't schedule a meeting if a Slack thread or document would work. When you do meet, publish notes within 2 hours.
Disagree and commit. After a decision is made, everyone executes. Relitigate in the next retrospective, not in Slack.
How do engineers grow here? This is where most culture documentation stops. It shouldn't.[4]
We define five engineering levels with specific, observable behaviors for each. Not vague stuff like "demonstrates leadership." Specific stuff like:
L3 (Mid-level): Completes well-defined tasks independently. Writes tests without being asked. Participates in code reviews. Can on-call for services they own.
L4 (Senior): Designs solutions for ambiguous problems. Mentors L3 engineers. Identifies and addresses technical debt without being asked. Can lead a project with 2-3 engineers.
L5 (Staff): Drives technical strategy for their domain. Influences decisions across teams. Identifies risks before they become problems. Can design systems that other teams build.
Every engineer knows where they are and what they need to demonstrate to reach the next level.
Figure 2. The proposed rollout tackles one component at a time.
I know what you're thinking: "This is a ton of process. We're a startup. We need to move fast."
I hear you. Here's the implementation timeline I used:
Month 1: Write the decision rights document. Share it. Get feedback. Finalize it. This alone fixes 40% of the confusion.
Month 2: Write quality standards. Start with the top five metrics that cause the most debates. You can add more later.
Month 3: Define communication norms. This is mostly codifying what's already working and fixing what isn't.
Month 4: Build the engineering ladder. This takes the longest but pays dividends in retention.
One component per month. Each one is a short document, not a manifesto. Total time investment: about 20 hours of leadership time. Maintenance: 2 hours per quarter per document.
Even with all this, some things will go wrong. Here's what I've seen:
Problem: The documents get ignored. Fix: Reference them in every decision. When someone asks "can I use MongoDB for this?" point to the decision rights doc. When a PR gets approved without tests, point to the quality standards. If leaders don't reference the docs, nobody will.
Problem: Teams treat the standards as a ceiling, not a floor. Fix: Celebrate when teams exceed the standards. Share examples of teams that went above and beyond. Make the standards the minimum, and recognize excellence.
Problem: New hires feel the culture is bureaucratic. Fix: Explain the why. "We wrote this down because we've seen what happens when you don't." Most engineers appreciate clarity once they understand the alternative is confusion.
# The Stealable Framework: The 4-Document Culture Kit
Decision Rights Matrix: One page. Who decides what. Review when you cross a team-size threshold (15, 30, 60, 100).
Quality Standards: One page. Measurable. Enforceable. Updated quarterly.
Communication Norms: One page. How information flows. Updated when tools or team structure changes.
Engineering Ladder: Two to three pages. Observable behaviors per level. Updated annually.
Total: Five to six pages. That's your culture OS. It's enough to survive hypergrowth. It's short enough that people actually read it.
The teams that scale culture successfully aren't the ones with the best original culture. They're the ones that treat culture as a system to be maintained, not a vibe to be preserved.
What should an engineering culture document cover?
Start with who can make which decisions and what quality means for your systems. Add communication norms and observable growth expectations, with examples that explain how a new engineer should use each document.
Does documenting culture create bureaucracy?
It can when documents add approvals without resolving uncertainty. Keep each document focused on recurring decisions, make it easy for teams to propose corrections and remove rules that create work without improving an outcome.
How do leaders keep engineering standards useful?
Reference the standards in reviews, planning and incident follow-up. Revisit them as systems and teams change, and explain the reason for each standard so engineers can recognise when an exception deserves discussion.
Should every engineering team use identical thresholds?
The numerical standards in the article describe one proposed operating model. Choose standards against the risk and workload of the system, and combine measurable expectations with discussion about whether the team can sustain them.
MachGTM review from its founder, covering research, sales playbooks, approval settings and the evidence an engineering leader should retain during a pilot.
A 3-tier succession planning framework for engineering orgs, with a 90-day sprint for accelerating candidates from potential to ready. Based on succession plans built at 4 companies.
The CTO's real job in product development isn't attending every meeting or making every technical call. It's connecting feasibility, viability, and capacity while letting EMs handle the day-to-day.
Four years of data from a fully remote engineering team across 4 time zones. Specific metrics on productivity, retention, and onboarding with the frameworks that actually worked.
A structured 30-60-90 day framework for handling engineering underperformance. Based on 14 real cases with a 64% success rate, starting with diagnosis before intervention.
Seven leadership antipatterns that look reasonable on the surface but quietly destroy engineering teams. Each one includes specific signals, real failure stories, and the framework I use to correct it.