Leadership#

Leadership in engineering is not about a title. It’s about influence, direction, and making others more effective. You can lead from any position — as a senior engineer, a tech lead, or even a mid-level developer who steps up during a crisis.

Technical Leadership Without Authority#

Most engineering leadership happens without direct reports. You influence through expertise, communication, and consistent behaviour — not by telling people what to do.

What Technical Leaders Do#

ActivityImpact
Set technical directionTeam builds coherent systems instead of patchwork
Define standards and patternsNew code is consistent; onboarding is faster
Make decisions (and document them)Team moves forward instead of debating endlessly
Remove blockersOthers can focus on their work
Raise the quality barThrough reviews, pairing, and example
Create safety for experimentationInnovation happens; failure is learning

How to Lead Without Authority#

flowchart TD
    A[Identify a problem] --> B[Propose a solution]
    B --> C[Build consensus]
    C --> D[Volunteer to implement]
    D --> E[Document and share]
    E --> F[Others adopt it]
    F --> G[You've led without being told to]

Practical examples:

  • Write the RFC for a recurring architectural problem
  • Create the PR template the team didn’t know it needed
  • Set up the monitoring dashboard that catches issues before users report them
  • Document the tribal knowledge that only exists in one person’s head

Mentoring Juniors#

Mentoring is the highest-leverage leadership activity. One hour of good mentoring can save a junior engineer days of struggle and months of learning the hard way.

Effective Mentoring Behaviours#

DoDon’t
Ask questions that guide them to the answerGive the answer immediately
Share your thought process, not just conclusionsSay “just do X” without explaining why
Normalise struggle and mistakesMake them feel stupid for not knowing
Give stretch assignments with supportEither bore them or overwhelm them
Check in regularly (don’t wait for them to ask)Assume silence means everything is fine
Celebrate their progressOnly point out what’s wrong

The Mentor’s Toolkit#

TechniqueWhen to use
Rubber duckingThey explain the problem to you; often solve it themselves
Scaffolded questions“What have you tried? What do you think the problem is? What would happen if…?”
PairingFor complex or unfamiliar tasks — teach by doing together
Code walkthroughsShow them how you approach a problem (think aloud)
Directed readingPoint to specific resources rather than “go learn X”
Retrospective 1:1s“What did you learn from that? What would you do differently?”

Knowing When to Help vs Let Them Struggle#

flowchart TD
    A[Mentee is stuck] --> B{How long?}
    B -->|< 30 min| C[Let them work - struggle builds skill]
    B -->|30 min - 2 hours| D[Check in: 'How's it going? Any blockers?']
    B -->|> 2 hours with no progress| E[Offer guidance or pair]
    D --> F{Making progress?}
    F -->|Yes| C
    F -->|No| E

Leading by Example#

People follow what you do, not what you say. If you want a team culture of quality, ownership, and openness, you have to model it consistently.

What “Leading by Example” Looks Like#

ValueThe behaviour
QualityYour PRs have thorough descriptions, tests, and clean code
OwnershipYou don’t say “not my problem” — you escalate or fix it
TransparencyYou share bad news early, admit mistakes, explain reasoning
Growth mindsetYou ask for feedback publicly, share what you learned
Respect for timeYou show up prepared, end meetings on time, honour async
InclusivityYou credit others, make space for quiet voices, assume good intent

The gap between what you espouse and what you practice is noticed. Always.

Decision-Making Frameworks#

Technical leaders make many decisions daily. Having frameworks prevents both analysis paralysis and reckless speed.

DACI Framework#

RoleResponsibilityExample (choosing a database)
DriverDrives the process, gathers input, proposesSenior engineer
ApproverMakes the final callTech lead or architect
ContributorsProvide input, expertise, constraintsTeam members, DBA, ops
InformedTold after decision is madeBroader team, product

Decision Sizing#

Decision typeApproachTime investment
Reversible, low impactJust decide. Don’t overthink.Minutes
Reversible, high impactDecide quickly, monitor, be ready to reverseHours
Irreversible, low impactDecide, document reasoningA day
Irreversible, high impactRFC, gather input, sleep on it, decideDays to a week

One-Way vs Two-Way Doors (Amazon model)#

  • Two-way door — easily reversible. Walk through it quickly, turn around if wrong. (Library choice, API design iteration, feature flag experiment)
  • One-way door — hard to reverse. Take time, gather data, get input. (Database migration, public API contract, architectural paradigm shift)

Most decisions are two-way doors that teams mistakenly treat as one-way.

Delegation#

Delegation is not dumping work — it’s investing in others while freeing yourself for higher-leverage activities.

What to Delegate#

DelegateKeep
Tasks others can learn fromDecisions only you have context for
Routine work you’ve masteredHigh-stakes work requiring your specific expertise
Work that develops someone elseConfidential or sensitive matters
Tasks where “good enough” is fineWork where your specific quality bar matters

How to Delegate Effectively#

flowchart LR
    A[Define the task clearly] --> B[Explain why it matters]
    B --> C[Set expectations: what good looks like]
    C --> D[Agree on check-in points]
    D --> E[Give autonomy between check-ins]
    E --> F[Provide feedback after]

Delegation Pitfalls#

PitfallResultSolution
Delegating without contextThey guess wrong, rework neededExplain the why and constraints
Micromanaging after delegatingThey disengage, you save no timeTrust the check-in schedule
Only delegating grunt workThey don’t grow, resent itInclude stretch assignments
Delegating and disappearingThey get stuck, feel abandonedBe available at agreed checkpoints
Redoing their work silentlyThey never improveGive feedback instead

The Staff+ Leadership Shift#

As engineers grow past senior, the work shifts from writing code to multiplying others:

IC LevelPrimary leverage
MidPersonal output
SeniorPersonal output + code quality influence
StaffTeam output + technical direction
PrincipalOrg output + strategic technical decisions

The progression is not about writing more code — it’s about creating more impact through others.

Key Takeaways#

  • Leadership is influence, not authority — you can lead from any level
  • Mentoring is high-leverage: invest an hour, save someone days
  • Lead by example — the gap between words and actions is always noticed
  • Size decisions appropriately — most are two-way doors that don’t need an RFC
  • Delegate with context and check-ins, not with micromanagement or abandonment
  • As you grow, your leverage shifts from personal output to multiplying others