How I Scaled Our Startup from 10 to 100 Without Crashing

The Moment the Numbers Stop Making Sense

When I hit 10 engineers, marketers, and ops people, we were still a kitchen-table startup. Decisions happened over lunch, the product roadmap lived in a single Google Doc, and the founder’s habit of ping-ponging a Slack channel was our only “process.” At 100 heads, that same approach creates a hamster wheel of endless meetings, unanswered tickets, and a culture that collapses under its own weight. The shift isn’t about buying a fancier tool-stack; it’s about re-architecting the operating system that powers the business. Below is the playbook I’ve lived through, three concrete phases, a few hard-earned frameworks, and a checklist you can start copying today. It’s not a compliance manual; it’s the “just enough” scaffolding that keeps velocity high while the organization grows out of the founder’s head.

1. The Inflection Point: Why 10 → 100 Is the Hardest Stretch

“Everything that worked at 10 breaks at 50.”, Marquis Davis, Running Start Digital

Three forces converge around the 10-person mark:

The inflection point arrives when the product is no longer the limiting factor; the operational engine is. Building that engine early avoids the most common causes of startup mortality between 30 and 80 hires.

2. Phase-Zero: The “Foundational” Phase (10-25)

2.1 Codify What Exists, Don’t Reinvent It

At 12-15 people we introduced a single source of truth in Notion. The trick was to start small:

# Ops Handbook (Living)

- 🎯 Mission & Vision (one-pager)
- 📈 OKR Cycle (templates)
- 🛠️ Tech Stack (link to infra repo)
- 📊 Sales Funnel (Google Sheet → Notion view)

The handbook was version-controlled (Git-backed Notion pages) and owned by the person most involved in each area. Rule: If you touch it weekly, you own it.

2.2 The “One-Metric-You-Care-About” (OMCA)

Instead of drowning in dashboards, we picked a single leading indicator for each function:

When every team can point to a metric they can move on a weekly cadence, the communication load drops dramatically, no need for daily stand-ups beyond the product squad.

2.3 Light-Weight Governance

We introduced bi-weekly “Decision Docs” (max 2 pages) for anything that would change the product or go-to-market strategy. The template forced:

1. Problem, 2 sentences.
2. Options, bullet list with trade-offs.
3. Recommendation, who decides, deadline.

If a decision exceeded the 2-page limit, it automatically triggered a decision-review meeting with a VP-level peer. This simple gate kept us from making ad-hoc choices that later required costly reversals.

3. Phase-One: Enabling Autonomy (25-50)

3.1 Functional Pods with a “Mini-CEO”

By 30 we split into product pods (Product + Eng + Design) and growth pods (Marketing + Sales + CS). Each pod had a Lead, not a manager in the traditional sense, but a “Mini-CEO” responsible for:

• Aligning the pod’s OKRs with company-wide OKRs.
• Clearing cross-pod dependencies.
• Owning the pod’s budget (headcount, tooling).

The title mattered less than the authority: the Lead could approve a $5k ad spend or re-assign a developer without waiting for a chain of approvals.

3.2 The “Two-Week Board”

We instituted a rolling two-week operational board that replaced all-hands meetings for 60-plus people. The board consisted of:

The board was published every Friday in a shared Slack channel; any teammate could comment. This eliminated the “when is the next all-hands?” anxiety while still keeping the entire org on the same page.

3.3 Hiring the First Layer of Managers

My rule for the first five hires beyond the founding team: they must have a “process instinct.” Candidates with a background in scaling (for example, a former Ops manager at a Series B fintech) were preferred over pure tech rockstars. The rationale is simple: they’ll design the scaffolding we need before we can afford dedicated ops roles.

The interview framework we used:

1. Scenario, “Your engineer is blocked because the CI pipeline is flaky.”
2. Action, Walk through the steps they’d take today.
3. Systemic, “How would you prevent this upstream?”

If they could answer both, they got an offer.

4. Phase-Two: Institutionalizing Systems (50-100)

4.1 The “Operational Core”

At 55 we built a tiny Ops core (3 people) with clear ownership:

The core’s charter wasn’t “run the business” but “make the business run itself.” They owned the service-level agreements (SLAs) for internal tools (e.g., “deploys must have <5 % failure rate, 30-minute rollback window”).

4.2 Scaling the OKR Engine

Our OKR template (pinned in Notion) evolved into a nested hierarchy:

company:
 objective: "Expand ARR to $10M"
 key_results:
 - "Add $2M net new ARR"
 - "Maintain churn <5%"

product:
 objective: "Increase net-promoter score by 15 pts"
 key_results:
 - "Roll out in-app tutorial to 80% of users"
 - "Reduce critical bugs > P2 by 60%"

sales:
 objective: "Shorten sales cycle"
 key_results:
 - "Implement automated lead scoring"
 - "Decrease average time-to-close from 45→30 days"

Every quarter the Ops core ran a “OKR health audit.” Any KR without a clear owner or measurable target was flagged and either re-scoped or removed. This kept the system from spiraling into a spreadsheet of vanity metrics.

4.3 Tooling for Scale, Not Glitz

Rule: If the tool can be version-controlled, treat it as code. Changes become auditable and roll-backable.

4.4 The “Manager Enablement Loop”

With 80+ people we faced a manager-overload problem: new leads were promoted fast but never trained. The solution was a quarterly Manager Enablement Sprint:

1. Prep, Managers submit two pain points.
2. Workshop, Four-hour async session on coaching, delegation, and data-driven decision making (recorded for future hires).
3. Action, Each manager implements a single new practice (e.g., weekly 1-on-1 agenda template).
4. Review, Ops core checks adoption via a brief survey.

The loop cost roughly $5 k per quarter in internal hours but saved us from the hidden cost of manager burnout, a leading cause of turnover in the 60-80 headcount range.

5. Culture at Scale: From Direct to Documented

5.1 The “Living Manifesto”

We turned our values into a living manifesto that lives alongside the Ops handbook. Each quarter a cross-functional Culture Guild (five volunteers) audits the manifesto for relevance and adds a concrete example (“we ship at least one experiment per sprint”). The manifesto is not a static wall art; it’s a decision-making filter.

5.2 Celebrating Process Wins

When a pod reduced its PR-throughput time from 48 h to 24 h, we broadcast it in the two-week board and gave a “Process Hero” badge in Slack. This subtle reinforcement made the team view process improvements as first-class product work, not admin overhead.

6. The “Just-Enough” Operations Checklist

If you have any of these below the MVA, you’re likely over-engineering. If you’re missing one, you’re likely under-engineering.

7. Lessons Learned the Hard Way

8. A Quick Start Guide for the Next Founder

1. Week 1, 2: Create a Notion page titled “Ops Handbook (Living)” and add mission, product vision, and a two-page decision-doc template.
2. Week 3, 4: Identify one OMCA per function. Publish them on the board.
3. Month 2: Split into pods, assign a Lead, and give each lead a $5k discretionary budget.
4. Month 3: Hire a Head of Ops (or “Operations Generalist”) who can own the OKR cadence.
5. Month 4: Roll out the two-week operational board; retire the all-hands for the next 90 days.
6. Month 5, 6: Introduce the Manager Enablement Sprint and the “Living Manifesto.”
7. Month 7+: Run the “Just-Enough” checklist every quarter; adjust MVAs as you cross headcount thresholds.

Follow the cadence, iterate relentlessly, and you’ll keep the velocity-culture paradox from turning into a bureaucracy-culture paradox.

Closing Thoughts

Scaling from 10 to 100 isn’t a sprint; it’s a series of operational micro-hacks that, when layered, form a resilient engine. The secret sauce isn’t a magic tool or an ivory-tower process, it’s designing the “just enough” scaffolding that lets teams move fast, stay aligned, and retain the scrappy spirit that got them to 10 in the first place. If you’re staring at a spreadsheet of 70 hires and wondering where to start, pick the smallest slice that’s currently breaking you, document it, assign ownership, and make it measurable. Then repeat. The 10 → 100 journey becomes less of a cliff dive and more of a controlled ascent, and you’ll get to the next milestone without losing the people who made the first ten possible.

// share