Missing My Coworker Jason Today

I was going to write something technical this week.
Maybe about architecture patterns. Or why most “clean code” debates are just ego in disguise.

But instead, I’ve been thinking about Jason.

Jason left 20 days ago.
Not because of layoffs.
Not because of drama.
He left to focus on his own business.

And ever since, the office feels… different.

Not quieter.
Just less sharp.

Jason was one of those rare developers who looked like a senior on paper — years of experience, big projects, scars from production outages — but still thought like a curious junior.

And that combination? It’s dangerous. In a good way.

Because most juniors are hungry but unsure.
Most seniors are confident but tired.

Jason was hungry and confident.

The Thing About “Junior” Titles

We love labels in tech.

Junior.
Mid.
Senior.
Staff.
Principal.
Wizard.

But Jason taught me something simple:

Experience is not about years.
It’s about ownership.

I’ve seen juniors with 2 years of experience take more responsibility than seniors with 10.

I’ve seen seniors hide behind architecture diagrams like they’re ancient scrolls nobody else can read.

Jason never hid.

If something broke, he didn’t say:

“Who wrote this?”

He said:

“Okay. Let’s fix it.”

And then he’d open the logs.

Debugging With Him Felt Different

You know how debugging usually goes:

1. Panic.
2. Blame the backend.
3. Blame the frontend.
4. Blame DevOps.
5. Restart everything.
6. “It works now.”

Jason skipped steps 2–4.

He’d sit down, calm, almost annoyingly calm, and say:

“Let’s reproduce it first.”

No drama. No Slack wars. No ego.

And when a junior dev asked what might have felt like a “stupid question,” he never did the senior sigh.

You know the sigh.

The one that says:

“You should know this already.”

Instead, he’d explain it from first principles. Like he was explaining it to himself.

That’s when I realized something uncomfortable:

The best seniors are just juniors who never stopped asking why.

Career Advice He Never Officially Gave

Jason never did motivational speeches.
He wasn’t the “LinkedIn wisdom thread” type.

But he’d drop small comments that stuck.

Once, after a long sprint, I complained that I felt behind compared to “real senior engineers.”

He said:

“Behind who? The version of you that doesn’t exist yet?”

That one hit harder than any performance review.

We compare our daily messy reality with someone else’s highlight reel.
GitHub stars. Conference talks. Viral posts.

Meanwhile, the real growth happens in:

• fixing that bug nobody wanted
• refactoring code no one notices
• saying “I don’t understand this” in a room full of confident faces

Jason did all three.

The Junior With Senior Energy

Here’s something I’ve noticed:

A lot of juniors try to “act senior.”

They avoid asking questions.
They over-engineer simple tasks.
They use big words in code reviews.

Jason did the opposite.

He’d say:

“This might be a dumb idea, but…”

And then propose the most elegant solution in the room.

Confidence without arrogance.
Experience without ego.

That’s rare.

The Day He Told Me He Was Leaving

It wasn’t dramatic.

No emotional music.
No mysterious calendar invite.

He just said:

“I think it’s time to build something of my own.”

And honestly? I wasn’t surprised.

People like Jason eventually outgrow being “just” employees.

They don’t chase titles.
They chase problems.

Still, when someone like that leaves, you feel it.

Because you lose more than a co-worker.

You lose:

• the person who challenges your thinking
• the calm voice during production chaos
• the silent standard everyone measures themselves against

What This Has To Do With You

If you’re a junior developer reading this:

Stop trying to look senior.

Instead:

• Take ownership of small things.
• Ask better questions.
• Admit what you don’t know.
• Care about the system, not just your ticket.

That’s how you grow.

And if you’re a senior:

Remember how it felt to not understand half the things in the codebase.

Be the person who explains — not the person who sighs.

20 Days Later

The code still runs.

Deployments still happen.

Standups still feel slightly too long.

But sometimes during a bug discussion, there’s a pause where Jason would normally say:

“Wait. What assumption are we making here?”

And nobody says it.

So now I try to.

Maybe that’s the real impact of good engineers.

They don’t just ship features.

They change how you think.

And honestly?

We miss him.

Not just me — the whole team.

We miss the calm during chaos.
We miss the random architecture debates.
We miss the way he’d quietly raise the standard without ever announcing it.

The Slack threads are still there.
His old commits are still in the repo.
But the chair is empty.

Jason, if you’re reading this — we’re proud of you.

We’re cheering for your business.
We know you’re going to build something great.

But yeah… we’re also looking forward to the day we grab coffee again, argue about code, and pretend we’re not secretly debugging life at the same time.

Good teammates are hard to find.

Good friends even harder.

See you soon, brother.

PS - Now I am gonna expand my work inviting new developer - it's part-time.
So If you are based on Europe and America and interested in that, please feel free to contact me anytime.