"Why would I hire a junior when I could hire a senior?"

Fair question. Here's my answer.

Fresh eyes find things experts miss

When you've been doing something for a decade, you stop seeing the weird parts. The config file that takes 20 minutes to understand. The deployment process with 47 manual steps. The code pattern that made sense in 2015 but now confuses everyone.

A junior looks at your codebase and asks: "Wait, why does this work this way?"

Sometimes the answer is "good reasons." Sometimes it's "nobody remembers." That second category is where improvements hide.

Motivation compounds

Early-career engineers have something to prove. Every project is an opportunity to build skills, demonstrate capability, and add to the portfolio.

This translates to:

  • Actually reading the docs before asking questions
  • Caring about code quality because it reflects on them
  • Following up on things without being reminded
  • Writing documentation because they just learned it and want to capture it

You're not getting phoned-in work from someone coasting on reputation.

The economics work

A senior engineer costs $150-300/hour. A junior might charge $50-100/hour for similar tasks.

Yes, the senior might work faster. But for many tasks—bug fixes, tests, documentation, small features—the speed difference doesn't justify 3x the cost.

And some tasks are better suited to juniors:

  • Documentation: Someone learning the system writes better docs than someone who forgot what was confusing
  • Testing: Fresh eyes catch edge cases that seem obvious in retrospect
  • Code cleanup: No emotional attachment to legacy decisions
  • Automation: High motivation to eliminate tedious tasks

What I'm actually offering

I'm not pretending to be a principal engineer. I'm offering:

Code reviews — Fresh perspective on your codebase. Security, performance, readability. [$200]

Bug fixes — I'll dig in, find the problem, fix it properly. [$300-500]

Feature work — Small to medium features, end to end. [$500-1000+]

Each comes with documentation. You'll know exactly what was done and why.

The real risk is different than you think

The risk isn't "junior makes a mistake." Mistakes happen at every level. The risk is "junior doesn't know they're stuck and wastes time."

I mitigate this by:

  1. Asking early when something's unclear
  2. Timeboxing exploration before escalating
  3. Over-communicating progress

You won't get radio silence for two weeks followed by "it's complicated."

Who this is for

Good fit:

  • You have well-scoped work that doesn't require years of domain expertise
  • You value clear communication and documentation
  • You want cost-effective help on concrete tasks

Bad fit:

  • You need someone to architect your entire system from scratch
  • You can't explain what "done" looks like
  • You expect senior-level speed at junior prices

If this sounds useful, let's talk. I'm taking on small projects now.

React to this post: