Chaos and Order

💡 왼쪽 원문을 읽으면서 오른쪽에 따라 써보세요. Tab 키로 힌트를 받을 수 있습니다.

Prologue — five years of re-definition

In 2019 "frontend engineer" meant React components and CSS. By 2026 it means something blurrier: you own the UI, plus edge logic, auth, API design, observability, and increasingly some SRE-ish concerns. Titles blur with "Full-stack," "Web platform engineer," "Design engineer."

This Season 6 finale is not a tech rundown — it's a career map. What to optimize. What to stop doing. Where the role is heading.

1. The three axes of specialization

Frontend in 2026 splits into three overlapping archetypes:

1.1 Design engineer

Lives between Figma and code.
Owns design system, tokens, motion, accessibility.
Writes components, not features.
Growing demand: every product wants distinctive UI, but maintaining it takes a dedicated owner.

1.2 Application engineer

Owns a whole product area — SSR, client state, data layer, routing.
Full-stack leaning. Often writes server code too.
Closest to "classic frontend engineer" but the bar moved up.

1.3 Platform / infra engineer (FE-flavored)

Build system, CI/CD, Vercel/Cloudflare wiring, performance budgets, observability.
Fewer of these — but promotions frequent because they enable others.

You don't have to pick one. But leveling decisions come from which axis you invest in.

2. Leveling in 2026 — what separates Senior, Staff, Principal

Senior — ships features end-to-end, owns decisions in a subsystem. Staff — owns cross-cutting concerns (perf, design system, architecture), influences other teams. Principal — shapes multi-year direction, hires leadership, is the face of a capability.

What changed in 2025:

AI fluency is now assumed at Senior. You must evaluate, prompt, and orchestrate AI tools well.
Systems thinking moved earlier — Staff-level architectural judgment is expected at strong Senior.
Communication/writing is now the defining Staff skill. ADRs, RFCs, one-pagers — because AI wrote the code, humans write the decisions.

3. What you can stop learning

A short list of things that are no longer differentiating:

Bundler internals. Vite/Turbopack/Rspack are stable. Knowing webpack.config.js is trivia.
CSS-in-JS framework wars. Tailwind + CSS variables won for most products.
State management library of the month. Zustand/Jotai + TanStack Query covers 90% of cases.
Custom hooks for everything. Most things are RSC-shaped now.
Manual TypeScript type gymnastics. satisfies, template literals, libraries like Zod gave us enough.

4. What to invest in

4.1 Web platform APIs

View Transitions, Speculation Rules, Popover, Anchor Positioning, :has(), Container Queries, CSS Custom Highlights, CSS Scoping.
These are permanent. Knowing them puts you 2 years ahead of the average engineer.

4.2 Server Components + streaming

Understand waterfalls, use(), Suspense boundaries, streaming SSR.
This is now the core mental model for Next.js/Remix/SolidStart/Astro.

4.3 AI as an IDE companion

Cursor/Claude Code/Copilot fluency: not "do it for me" but "make me 3× faster on grunge work."
Prompt engineering for code review, test generation, refactoring.
You should be writing agents that handle your own PR cleanup.

4.4 Observability

RUM (Real User Monitoring) and tracing. Senior engineers now diagnose UX from production data, not local dev.

4.5 Edge thinking

Where does the compute happen? Edge vs origin vs client vs CDN. This is an architectural skill.

5. AI and your role — what actually happened

Three predictions from 2023 did NOT come true:

"Frontend engineers will be replaced." No — demand grew, because AI made UI cheaper to ship, which encouraged more UI.
"We won't write React anymore." We still do, but we write less glue and more intent.
"Design systems will be AI-generated." Design systems are still human — AI generates variants, humans define principles.

Three predictions that DID come true:

AI handles tests, types, and trivial bugs.
Code review bandwidth doubled — you review more because generation is fast.
Senior+ engineers spend more time in decision docs, less in editor.

6. The career shape — Individual Contributor vs Manager

The IC track widened significantly in 2023–2025. At FAANG and many startups:

Staff IC = EM.
Senior Staff IC ≥ Director.
Principal IC ≈ VP.

If you like writing code and making architectural decisions, the IC track is real and rewarding. If you like growing people and setting strategy, management.

Hybrid pattern (getting common): 18 months as manager, then back to IC. Or 50/50 tech-lead–manager. Both directions are legitimate — lateral moves no longer carry stigma in most healthy companies.

7. Compensation snapshot (2025 Korea)

Korean market compensation for FE engineers (rough ranges, TC includes equity):

Level	Startup (Series A–B)	Startup (Series C+)	Major corp	Global remote
Senior (5–8y)	80–110M KRW	100–140M	110–160M	$180k–$ 280k
Staff (8–12y)	120–160M	150–220M	180–260M	$250k–$ 400k
Principal (12y+)	180M+	220M+	260M+	$350k–$ 550k+

Caveats: distributions are wide, title inflation is real, cash vs equity ratio varies. Base your negotiation on comparable offers, not titles.

8. Burnout — the quiet epidemic

Multiple surveys in 2024–2025 (State of JS, Stack Overflow, Korean developer community polls) put frontend burnout at the highest mark since records began. Why:

Framework churn exhaustion. 2023–2025 hit harder than any prior period.
AI anxiety. "Am I still relevant?" is more common than we admit.
Always-on culture — Slack, PRs, async reviews.
Scope creep — FE became responsible for A11y, perf, SEO, security, deploy, on-call.

What actually helps (from people who came back):

Explicit focus blocks. No Slack 9–12. Non-negotiable.
"Stop-doing" lists. Same as "to-do" but the opposite.
Longer sleeps, fewer side projects. Rest is a skill.
Community. Conferences (FEConf, JSConf Korea, React Korea), discord servers — the loneliness is a big piece.

9. The Korean community landscape

If you're based in Korea, these communities matter in 2026:

FEConf — annual, the flagship.
JSConf Korea — annual, broader JS.
React Korea — Discord-based, active.
Toss Slash — Toss's annual conference, high bar.
OKKY / GeekNews — for async discussion.
velog / 1boon / Brunch — writing platforms.

Open-source contribution from Korean engineers to Next.js, TanStack Query, and Astro grew meaningfully in 2024–2025.

10. Global remote as a Korean FE engineer

The remote-from-Korea market for strong FE engineers is real but competitive.

Path A — International Korean offices (Coupang, Naver/Line/Kakao global arms, Toss global). Same pay scale but broader career growth.

Path B — Fully remote global (Vercel, Supabase, Clerk, Linear, small US Series A). Pay is higher, culture may clash with Korean hours. English writing is the entry point — written async communication is currency.

Path C — Freelance/consulting. Harder for juniors, easier once you have 10+ years. Great for specialists (design system, accessibility, perf).

11. The 3-year investment map

If you're reading this as a mid-level engineer, here's a blunt 3-year recommendation:

Build one deep specialty. Perf, a11y, design systems, edge — pick one.
Ship one production AI integration. End-to-end, with evaluations.
Write publicly. 6–12 decent blog posts beat 100 mediocre tweets.
Own one open-source contribution. Even a mid-size PR to Radix or TanStack changes your resume.
Mentor. Teaching juniors exposes and fills your own gaps.

12. What I wish I knew at each stage

At 1–2 years: stop optimizing tools, ship things. Quantity beats quality at this stage. At 3–5 years: start reading other people's code seriously. Your own code gets better by osmosis. At 5–8 years: writing > coding on average. Decisions compound. At 8+ years: your job is to make other people 10% better. Every intervention is leveraged.

13. Season 6 — closing

Six months ago we started Season 6 on "Frontend Platform & Polish." We covered:

Design systems (tokens, Radix, Shadcn)
Core Web Vitals and RUM
Accessibility + internationalization
Monitoring + error tracking
Security (XSS, CSRF, CSP, Passkeys)
State management renaissance
Testing (Vitest, Playwright, visual regression)
CI/CD + feature flags + SLSA
And now: career.

What unifies Season 6 is that the frontend role matured. The bar to be "senior" moved up — not harder, just broader. Your job isn't just to write React. It's to own the user experience as a system — performance, reliability, security, accessibility, and the people who build it.

12-question self-assessment

Which axis (design / app / platform) are you strongest on?
Which web platform API did you last learn top-to-bottom?
When did you last profile production from RUM data?
Can you read a RFC/ADR and push back with specifics?
Do you have a kept-up-to-date "wins" doc?
When did you last say no to a task, and what did you say instead?
How many hours/week do you spend on deep work (no Slack)?
When did you last mentor someone to unblock them?
Is your compensation calibrated to market (not just internal)?
What's your 3-year specialty bet?
When did you last write something publicly?
Have you taken leave (not "sick") in the last 12 months?

10 anti-patterns to stop

Chasing every framework release hoping it "unblocks" you.
Optimizing the editor (themes, plugins) more than the output.
"Full-stack" meaning you learn nothing deeply.
Hiding from AI tools because "I want to stay sharp."
Ignoring accessibility as "someone else's job."
Never writing design docs.
Saying yes to every feature request.
Conflating busy with productive.
Never leaving your current employer's bubble.
Burning out silently. Tell someone. The industry kept many people who spoke up.

Season 7 preview

Season 7 starts with Backend & Platform — Node 22, Bun, Deno, Cloudflare Workers, edge runtimes. Then frameworks (NestJS, Fastify, Hono, Elysia, Spring Boot, FastAPI, Go, Rust), databases (B-tree, LSM, MVCC + CockroachDB/Spanner/TiDB/Neon/PlanetScale), queues, and observability. If Season 6 was "UI as a craft," Season 7 is "distributed systems for app engineers."

— Thanks for reading Season 6. See you in Season 7.