On Being a Senior Frontend Engineer

About ten years into my career, I was spending less time building features myself and more time helping the team improve how we build them.

At first, this felt strange. Wasn’t my job to deliver products? Wasn’t that what I was hired for?

The shift

Junior developers ship features. Senior developers improve how the team ships features.

The real value of experience isn’t about coding faster. It’s about noticing where the team is slowing down and finding ways to fix it:

• We’re spending a lot of time troubleshooting TypeScript problems. We should tighten our configurations to avoid these headaches.
• Style discussions come up in every PR. Adding Biome or Oxfmt could help us avoid those distractions and keep things moving.
• We keep recreating the same components. Investing in Storybook would help us maintain consistency and save time.

This isn’t about being smarter. It’s about having gone through these problems before.

What actually matters

After more than 14 years, here’s what I believe sets senior frontend engineers apart from the rest:

1. Developer experience is a feature

The best frontend teams have great tooling. (Poll Results: The State of Frontend Development in 2024-2025, 2025)¹ This means:

• Fast builds (Vite, esbuild)
• Automatic formatting (Biome, Oxfmt)
• Type safety (TypeScript with strict mode)
• Component documentation (Storybook)
• Fast feedback loops (fast tests, hot reload)

I now spend more time making these tools better than writing features myself. As a result, the team works faster.

2. Knowing when “good enough” is good enough

Junior developers commonly try to perfect every detail. Senior developers know when it’s time to ship.

It’s not about being lazy. It’s about comprehending opportunity cost. Every hour spent perfecting animations is an hour not spent on things users really need.

Ship it. Get feedback. Iterate.

3. Making others better

Helping others has a real impact. If I help three developers avoid a mistake I once made, that’s more valuable than any code I could write myself. (Ruschin, 2025)²

This means:

• Setting up tooling that catches mistakes early
• Writing clear PR reviews with context
• Documenting patterns in Storybook
• Pairing when someone is stuck
• Sharing what I’ve learned

4. Choosing boring technology (usually)

React is reliable. TypeScript is reliable. That’s exactly why they’re good choices. (Ramel, 2023)³

A new framework might seem exciting, but can the team maintain it? Will it still be supported in two years? Is the ecosystem stable?

Sometimes, choosing the reliable option is exactly what you need.

What I’m still learning

I don’t have all the answers. Some days, I still wish I could write code for eight hours without any meetings.

I still make mistakes. Sometimes I miss things during code reviews. I still go for complex solutions when a simple one would be better.

But now, I’m better at spotting these patterns. I’m also better at asking myself, “Will this actually help the team?” before jumping into solutions.

The unpleasant truth

As you become more senior, your impact becomes less directly measurable. (Scully, 2020)⁴

You can’t always point to a single feature and say, “I built that,” because your value is spread across many things:

• The bug that didn’t happen because of better TypeScript configs.
• The hour saved because Storybook made testing easier.
• A developer who avoided a mistake because you documented the pattern.

This can make it harder to know if you’re doing a good job. You have to learn to be comfortable with that uncertainty.

What I’d tell my younger self

1. Invest in tooling early. It pays off exponentially.
2. Don’t chase every new framework. Master the fundamentals.
3. TypeScript strictness is your friend, not your enemy.
4. Writing good docs is part of the job, not separate from it.
5. Helping others move faster is more valuable than moving fast yourself.

And most importantly: being senior isn’t about knowing everything. It’s about making the team better.

This is what I wish someone had told me ten years ago. It could have saved me some time, or I needed to learn it on my own.

Either way, here we are.