The career advice I’d give younger me — calibrated for 2026, when AI tooling has shifted what “writing code” means, but the fundamentals still matter more than ever.

Compound skills

Time spent on these compounds for decades:

  • Databases. Postgres deeply. SQL deeply. Indexing, transactions, replication. Every backend problem touches data eventually.
  • Networking and HTTP. TCP, TLS, DNS, load balancers, caching, CDNs. Read System Design Fundamentals .
  • OS basics. Linux, processes, memory, file systems, signals. The bug is rarely in your code; it’s often in the environment.
  • Writing. Specs, postmortems, design docs. The engineers who get promoted write well.

Skills that depreciate:

  • Specific framework versions.
  • Specific cloud vendors’ UIs.
  • The current month’s trendy tool.

AI tooling

In 2026, AI is part of the toolkit. Engineers who use it well ship faster and broader. Skills:

  • Tool selection — Cursor / Claude Code / etc. See Cursor vs Windsurf vs Claude Code .
  • Prompting for code — small surprising lift.
  • Verifying agent output — the new core skill.
  • Building agentic systems — high-leverage work area.

Engineers who refuse AI tooling are 2010 holdouts. Engineers who blindly trust it ship bugs faster. The middle path wins.

Side projects and learning

Side projects compound like investing. Pick projects that:

  • Use a tech you’re learning.
  • Solve a real problem (yours, ideally).
  • Could be public.

I learned more from one weekend hacking a side project than from a month of tutorials. The accountability of “this should actually work” teaches everything.

Build in public

A public GitHub. A blog. Contributions to OSS. A Twitter / Mastodon presence. All compound.

The career payoff: opportunities find you instead of you finding them. Recruiters DM. Conferences invite. Other engineers hire you for projects.

Cost: a few hours a week. ROI: career-changing.

(I write at blog.rajpoot.dev and keep my projects at rajpoot.dev . Both have paid back many times over.)

Optimize by level

Junior (0–2 years)

  • Learn the fundamentals. Don’t chase frameworks. Postgres, HTTP, Linux, Git deeply.
  • Read code. A lot. Including code you didn’t write.
  • Ask “why.” Understand the systems before optimizing them.
  • Embrace AI tools to learn faster. Don’t use them to skip understanding.

Mid (2–5 years)

  • Pick a depth. Backend services. Databases. Distributed systems. Don’t be generalist forever.
  • Ship complete projects. Beginning to end. Including the boring 20%.
  • Practice writing. Design docs, specs, RFC-style. Get reviews.
  • Take on-call. Production fluency comes from carrying the pager.

Senior (5–10 years)

  • Architecture > code. Decisions multiply across teams.
  • Mentor. You learn most by teaching.
  • Cross-team. Influence beyond your project.
  • Pick a domain. Payments, ML infra, search, reliability. Domain expertise pays for decades.

Staff+ (10+ years)

  • Leverage > output. Decisions, hires, standards.
  • Long-horizon judgment. What still matters in 5 years?
  • Coalition-building. Most staff work is political-with-a-lowercase-p.

On compensation

  • Negotiate every offer. Always.
  • Levels matter; titles less so.
  • Take the equity if the company is good; ignore it if it’s not.
  • Be prepared to leave. The best leverage is BATNA.

On stress

  • Burnout is real. The 25-year-old who can do 70-hour weeks is 35 with a back problem and depression.
  • Hard work matters; chronic overwork doesn’t.
  • Set boundaries. Defend them.
  • Take vacation. Use all of it.

On AI specifically

The 2026 question: should I become an “AI engineer”?

Honest answer: AI is part of all engineering now. You don’t need to specialize in it to use it — but the engineers building AI products have outsized leverage. If you find LLMs interesting, lean in. If you don’t, the fundamentals you build still matter.

The mistake is to assume “I’ll skip AI and stick with what I know.” AI literacy is now a baseline skill.

What I’d actually do

If I were starting again in 2026:

  1. Postgres + HTTP + Linux for 6 months as foundation.
  2. One backend language deeply (Python, Go, or TypeScript).
  3. One side project that’s actually useful.
  4. AI tooling in daily workflow.
  5. A blog, even if nobody reads it for the first year.
  6. Contribute to OSS — small fixes count.
  7. One paying side gig to learn what production really means.

Five years of consistent compounding beats five years of optimization.

Read this next

If you want my career-and-side-project archive, it’s at rajpoot.dev .

Building something AI-, backend-, or data-heavy and want a second pair of eyes? I do consulting and freelance work — see my projects and ways to reach me at rajpoot.dev .