Finding 10x Leverage
The difference between a productive engineer and a highly impactful engineer is not how many hours they work or how fast they type. It is what they choose to work on. Leverage is output divided by input. A task that takes one hour and saves one hour has 1x leverage. A task that takes one hour and saves 130 hours per year has 130x leverage. The highest-performing engineers obsessively seek leverage: they find the one-hour investment that eliminates an entire category of recurring pain.
The Leverage Equation
Leverage = Impact Produced / Time Invested
Low leverage: Manually deploying code (30 min each time)
High leverage: Writing a deploy script (1 hour once)
Calculation:
Deploy script: 1 hour to write
Saves: 15 minutes per deploy
Deploys per week: 10
Weekly savings: 150 minutes = 2.5 hours
Annual savings: 130 hours
Leverage: 130x (130 hours saved / 1 hour invested)
This is not theoretical. This is basic arithmetic that most engineers never do. They spend their time on whatever is in front of them rather than calculating which work produces the most output per unit of input.
Categories of 10x Leverage
Automation of Repetitive Tasks
Any task performed more than twice is a candidate for automation. The math is simple: frequency times time-per-occurrence times expected lifespan of the automation.
Leverage calculation template:
Task: [describe the manual task]
Time per occurrence: [X minutes]
Frequency: [Y times per week]
People affected: [Z engineers]
Automation cost: [A hours]
Annual savings = X * Y * 52 * Z / 60 hours
Leverage = Annual savings / Automation cost
Examples:
Setting up dev environment manually
30 min * 2 new hires/month * 12 months = 12 hours/year
Automation cost: 4 hours
Leverage: 3x (marginal)
Manual database migration process
45 min * 3 times/week * 52 weeks = 117 hours/year
Automation cost: 8 hours
Leverage: 14.6x (high)
Manual test data creation
20 min * 5 times/day * 8 engineers * 250 days = 3333 hours/year
Automation cost: 16 hours
Leverage: 208x (extreme)
The test data example is real. A team of 8 engineers each spending 20 minutes a day creating test data manually is hemorrhaging time. A 16-hour investment in a test data generator has 208x leverage.
Fixing Flaky Tests
Flaky tests are a leverage gold mine because they have hidden costs that multiply across the entire team.
One flaky test:
Fails spuriously: 1 in 10 runs
CI runs per day: 50
Spurious failures per day: 5
Time per failure to investigate + retry: 15 minutes
Engineers affected: all (8 people)
Daily cost: 5 failures * 15 min = 75 min wasted/day
Annual cost: 75 min * 250 days = 312 hours/year
Fix time: 2 hours
Leverage: 156x
But the hidden costs go further. Flaky tests erode trust in the test suite. Engineers start ignoring failures. Real bugs slip through because "it was probably just that flaky test." The second-order cost of flaky tests dwarfs the direct time cost.
Documentation That Prevents Questions
Every question asked in Slack has a cost: the asker's time formulating the question, the responder's context switch to answer it, and the lost knowledge when the answer disappears into chat history.
Recurring question: "How do I set up the local dev environment?"
Frequency: 2 times per month (new hires, team rotations)
Time to answer: 30 minutes (back and forth in Slack)
Time to write a doc: 2 hours
Annual cost without doc: 30 min * 24 = 12 hours/year
Annual cost with doc: 2 hours once + 1 hour/year maintenance
Leverage: 4x in year one, grows as team scales
Recurring question: "What is the deployment process for service X?"
Frequency: 5 times per week (across 3 teams)
Time to answer: 15 minutes
Time to write a doc: 3 hours
Annual cost without doc: 15 min * 5 * 52 = 65 hours/year
Annual cost with doc: 3 hours once + 2 hours/year maintenance
Leverage: 13x in year one
The highest-leverage documentation is not comprehensive reference material. It is the answer to the five questions that get asked every single week.
Improving Developer Experience
Developer experience improvements have leverage because they affect every engineer on every workday.
Slow local build: 3 minutes
Engineers rebuild: 20 times per day
Team size: 15 engineers
Daily cost: 3 min * 20 * 15 = 900 min = 15 hours/day
Annual cost: 15 * 250 = 3750 hours/year
Reducing build time from 3 min to 30 sec:
New daily cost: 0.5 min * 20 * 15 = 150 min = 2.5 hours/day
Annual savings: 3125 hours/year
Investment: 40 hours of build optimization
Leverage: 78x
This is why companies like Google and Meta invest entire teams in build infrastructure. The leverage numbers at scale are enormous.
Architectural Decisions
Some leverage is not about saving time but about preventing future pain. The right architectural decision early can prevent months of rework later.
Decision: Use feature flags from day one
Cost: 8 hours to set up feature flag infrastructure
Benefit: Every future feature can be rolled back instantly,
tested incrementally, released to subsets of users
Without it: Every bad deploy requires a full rollback,
hotfix, and emergency deploy cycle (2-4 hours each)
With 2 bad deploys per month: saves 48-96 hours/year
Leverage: 6-12x (plus reduced risk, faster iteration)
Decision: Implement structured logging from the start
Cost: 4 hours
Benefit: Every future debugging session is faster
Estimated savings per incident: 30 minutes
Incidents per month: 8
Annual savings: 48 hours
Leverage: 12x
How to Identify Leverage Opportunities
Most leverage opportunities are hiding in plain sight. Engineers just do not look for them systematically.
The Time Audit
Track how you spend your time for one week. Categorize each block:
Category A: Unique creative work (design, architecture, coding)
Category B: Repetitive work (manual testing, deploys, data entry)
Category C: Waiting (for CI, for reviews, for deploys)
Category D: Interruptions (answering questions, context switches)
Leverage opportunities:
Category B -> Automate it
Category C -> Speed up the thing you are waiting for
Category D -> Write documentation, create self-serve tools
The Frustration Inventory
Ask every engineer on the team: "What wastes your time every week?" The answers are leverage opportunities.
Common frustration inventory results:
"CI takes 40 minutes" -> Parallelize, cache deps
"Setting up test data is painful" -> Build a test data generator
"I never know which service owns X" -> Service catalog
"Code review takes 3 days" -> Review rotation, smaller PRs
"Our alerts are too noisy" -> Tune thresholds, add context
Each frustration represents a recurring cost multiplied across the team. The frustrations mentioned by multiple engineers are the highest-leverage targets.
The Multiplication Test
Before starting any task, ask: "How many times will this matter?"
Writing a function: Matters once (or a few times if reused)
Writing a library: Matters every time someone uses it
Writing a linter rule: Matters on every commit by every engineer
Writing a design guideline: Matters on every design decision
Improving CI speed: Matters on every push by every engineer
The more the answer multiplies across people and time,
the higher the leverage.
Leverage Traps
Not everything that looks like leverage actually is.
The Over-Engineering Trap
Scenario: Build a "general-purpose" deployment framework
Estimated cost: 3 months
Actual cost: 6 months (scope creep, edge cases)
Benefit: Handles deploys for all services
Reality: 3 services use it, the rest are too different
Actual leverage: Low (high investment, limited applicability)
Better: Write a simple deploy script for the 3 most-deployed
services. 1 day each. Revisit generalization later.
The Premature Abstraction Trap
Scenario: Build a shared component library before you have
3 products that need it
Cost: 2 months
Benefit: Consistency across products
Reality: You have 1 product. The abstraction is wrong because
you designed it from one data point.
Better: Wait for 3 concrete use cases, then extract the pattern.
The Tooling Treadmill
Scenario: Switch CI systems every 6 months because the new
one is "better"
Each migration: 2 weeks of work
Benefit: Marginal improvement each time
Net leverage: Negative (migration cost exceeds improvement)
Better: Invest in optimizing the current system.
Leverage at Different Career Levels
The type of leverage you pursue changes as you grow:
Junior Engineer:
- Automate your own repetitive tasks
- Write scripts that save you 30 minutes a day
- Leverage: 1x to 10x, personal scope
Senior Engineer:
- Fix pain points that affect the whole team
- Improve CI, testing, and developer experience
- Write documentation that prevents recurring questions
- Leverage: 10x to 100x, team scope
Staff Engineer:
- Make architectural decisions that shape years of work
- Create platforms that multiply team output
- Eliminate entire categories of problems
- Leverage: 100x to 1000x, organization scope
Principal Engineer:
- Set technical direction that affects multiple teams
- Make build-vs-buy decisions worth millions
- Create technical strategies that compound over years
- Leverage: 1000x+, company scope
Common Pitfalls
- Working hard on the wrong thing: Effort and leverage are unrelated. You can work 80 hours a week with zero leverage if you are not working on the right problems.
- Not doing the math: Most engineers never calculate the actual time savings of their investments. A quick back-of-the-envelope calculation reveals whether something is 2x or 200x leverage.
- Ignoring recurring costs: A 15-minute task done daily costs 65 hours per year. Engineers accept these costs as "just how things are" instead of eliminating them.
- Pursuing perfect over good enough: A 90% solution delivered today has more leverage than a 100% solution delivered in three months. Ship the 90% and iterate.
- Only counting your own time: Leverage multiplies across people. Something that saves you 10 minutes but saves 50 engineers 10 minutes each is 50x more leveraged than you think.
- Confusing novelty with leverage: Building with a new technology is exciting but not inherently high-leverage. Using boring technology that solves the problem is often higher leverage because it has lower maintenance cost.
Key Takeaways
- Leverage is output divided by input. Pursue work where the ratio is highest, not where the effort is most visible.
- Do the math. Calculate time saved, people affected, and frequency of benefit before investing in a solution.
- Automation, flaky test fixes, documentation, and developer experience improvements are the most common sources of 10x leverage.
- Use the time audit and frustration inventory to find leverage opportunities systematically.
- Beware leverage traps: over-engineering, premature abstraction, and the tooling treadmill all look like leverage but are not.
- The type of leverage you pursue should scale with your career level: from personal scripts to organizational platforms.