Will I go obsolete as an SDE?

The engineers who stay relevant long-term aren't the ones who know the most frameworks. They're the ones who are hard to replace because of how they think.

Here's what actually matters:

1. Deep fundamentals that don't expire

Frameworks come and go. These don't:

• How computers actually work — memory, CPU, I/O, the OS. When something is slow, you can reason about why.

• Data structures and algorithms — not for leetcode grinding, but for knowing instinctively when a hashmap beats a list, when an index changes everything, when you're creating an O(n²) problem without realising it

• Networking — TCP, HTTP, DNS, TLS. Every backend engineer hits these and most can't explain them

• Databases — not just "write a query" but transactions, isolation levels, indexing strategies, the difference between consistency and availability. This is where most mid-level engineers have gaps

• Concurrency — threads, async, race conditions, deadlocks. AI APIs are I/O bound. This matters right now.

2. Systems thinking

The ability to look at a system and reason about:

• Where will this break under load

• What happens when this dependency goes down

• Where is the data bottleneck

• What are the consistency tradeoffs here

• How does this scale from 100 to 100,000 users

This is the skill that separates senior from mid-level more than anything else. It can't be googled or prompted. It comes from building things, breaking them, and thinking carefully about why.

3. Knowing when NOT to use AI

This sounds counterintuitive but it's real. The engineers who will stand out in 2-3 years aren't the ones who use AI for everything — they're the ones who know exactly where AI helps and where it creates hidden debt.

AI is great at boilerplate. It's bad at:

• Knowing your specific system's constraints

• Understanding tradeoffs you haven't articulated

• Catching subtle security issues

• Reasoning about failure modes it hasn't seen

The engineer who can audit AI output, catch its mistakes, and know when to override it is more valuable than one who just accepts it.

4. Communication and taste

The ability to:

• Write a clear technical design doc

• Push back on a bad architectural decision with evidence

• Explain a complex tradeoff to a non-technical stakeholder

• Review code and give feedback that actually makes the codebase better

These compound over time. Most engineers underinvest here completely.

5. Owning a domain deeply

Pick something and go deep. Not just "I know Python" but "I understand how Python's async event loop actually works and when it breaks down." Not just "I use Postgres" but "I understand MVCC, vacuum, and why your query plan is doing a sequential scan."

Generalists get commoditised. Deep specialists with breadth get promoted and hired.

For your trajectory — AI systems backend engineering is the right domain to own. Not just calling APIs, but the infrastructure around AI: evals, observability, prompt management, agent orchestration, cost control. That domain is young, growing fast, and very few people have real depth in it yet.

6. Building in public and articulating your thinking

You're already doing this with the LinkedIn post. Keep going. Engineers who can write clearly about what they build and why they made the decisions they made are rare. It compounds — every post is a signal that you think carefully, and it reaches people you'll never meet.

The honest summary

The engineers who go obsolete are the ones who learned a framework and stopped there. The ones who stay relevant treat every project as a chance to understand something more deeply, build the habit of asking "why does this work this way", and develop opinions about tradeoffs.

You're already asking the right questions. That's the most important signal.