Mentoring & Leveling
Mentoring turns Python specialists into force multipliers: juniors learn async safety and pytest architecture; mids grow into tech leads. Clear leveling criteria and deliberate pairing beat vague "be more senior" feedback.
Recipe
Quick-reference recipe card - copy-paste ready.
## 30-day plan (junior → mid path)
Week 1: Shadow on-call + fix docs typo PR
Week 2: Own bug with tests + review from buddy
Week 3: Small feature behind flag + deploy with buddy
Week 4: Present learning at guild (15 min)
## Leveling signal (mid engineer)
- Ships features with tests and observability
- Reviews others' PRs constructively
- Debugs prod with runbook, minimal escalationWhen to reach for this:
- New hire onboarding to Python fleet
- Promotion discussions lack evidence
- Seniors hoard critical tasks
- Team velocity blocked by review bottleneck
Working Example
"""pairing_exercise.py - mentor-guided refactor with tests."""
from __future__ import annotations
# BEFORE (mentee): mutable default
def add_item_cart(cart: list | None = None, item: str = "") -> list:
if cart is None:
cart = []
cart.append(item)
return cart
# AFTER (pairing session): explicit types + test
def add_item_cart(cart: list[str], item: str) -> list[str]:
return [*cart, item]
def test_add_item_cart_does_not_mutate_input():
original = ["a"]
result = add_item_cart(original, "b")
assert result == ["a", "b"]
assert original == ["a"]Mentor script:
- Mentee explains bug risk in mutable default.
- Pair writes failing test first.
- Mentee opens PR; mentor reviews with 🟡/🔴 tiers only.
- Mentee deploys to staging with buddy on bridge.
What this demonstrates:
- Concrete exercise tied to real Python gotcha
- Tests prove mentoring outcome, not just attendance
- Graduated ownership ending in supervised deploy
- Written leveling signal defines "mid" expectations
Deep Dive
How It Works
- Buddy system - First 90 days; not the same as manager.
- Mob programming - 2-4 engineers, one driver; for migrations and hard bugs.
- Leveling rubric - Scope, impact, autonomy, influence documented per level.
- Growth plans - 2-3 outcomes per quarter (e.g., "own billing module on-call").
- Calibration - Managers align levels across squads quarterly.
Mentoring Formats
| Format | Best for |
|---|---|
| Pair programming | New codebase patterns |
| Async PR mentorship | Daily skill transfer |
| Office hours | Unblocking many juniors |
| Guild talks | Spread deep dives (async, typing) |
Python Notes
## Suggested learning path (Python SME)
1. Fundamentals + pytest
2. FastAPI or Django vertical slice
3. Observability + on-call shadow
4. Design review attendance
5. Lead small RFCGotchas
- Only assigning tickets - No skill transfer. Fix: Debrief after each task with "what would you do solo?"
- Vague promotion feedback - "Not senior enough." Fix: Map gaps to rubric behaviors with examples.
- Mentor as bottleneck - All reviews through one person. Fix: Rotate buddies; mentee reviews others too.
- Skipping on-call shadow - First solo page is terrifying. Fix: Shadow two shifts minimum.
- Ignoring non-code growth - Communication and specs matter. Fix: Include product collaboration goals.
Alternatives
| Alternative | Use When | Don't Use When |
|---|---|---|
| External training | New domain (ML, security) | Daily Python idioms |
| Self-paced courses | Baseline language refresh | Production ownership |
| Apprenticeship program | Many juniors at once | Single hire |
| Rotation across squads | Breadth for staff track | Urgent delivery crunch |
FAQs
How often should mentors meet?
30 min weekly 1:1 plus ad hoc pairing on hard tasks.
Junior on-call?
Shadow first; solo with senior backup for low-risk rotation slots.
How document leveling?
Engineering ladder doc with Python-specific examples per level.
Mob programming frequency?
Weekly for hard refactors; not daily default (expensive).
Remote mentoring?
Screen-share pairing, recorded guild talks, async PR mentorship.
When is someone mid-level?
Consistently ships tested features with light guidance; helps others debug.
How handle underperformance?
Clear plan with manager; mentor supports skills, manager owns outcomes.
Mentor time allocation?
Target 10-20% for tech leads; protect in sprint planning.
Cross-team mentoring?
Encourage for platform patterns (observability, packaging).
Leveling and titles?
Titles follow calibrated level; rubric is source of truth.
Related
- Code Review Culture - daily teaching
- Delegation & Spreading Context - grow ownership
- Career Growth: Senior to Lead - long path
- Team Onboarding - first 30 days
- On-Call Health - sustainable shadowing
Stack versions: This page was written for Python 3.14.0 (stable 3.14, maintenance 3.13), FastAPI 0.115+, Django 5.2, Flask 3.1, Pydantic 2, PyTorch 2.6+, pandas 2.2+, Polars 1.x, ruff 0.9+, and uv 0.6+.