Ranking backend concepts from intern to senior, part 2

Six more backend concepts on the intern-to-senior tier list, ranked by how much of the system you have to hold in your head before you can make a good call.

Open in teleprompter

Six more concepts on the tier list

senior

orchestration

mid

event-driven

junior

webhooks

transactions

server-sent events

intern

table joins

event-driven

webhooks

orchestration

table joins

transactions

server-sent events

0.0s/0.0s

Same axis as before: not how hard a concept is to learn, but how much of the system you have to hold in your head before you can make a good call about it. Intern-level questions are answered inside one query. Senior-level questions are answered by your team, your traffic and the next two years of the product. This batch spans most of that range.

Event-driven architecture is mid-level

This is the step up from running behind a load balancer: work now happens somewhere else, later, and maybe out of order. You give up the comfort of a return value and have to reason about ordering, retries and eventual consistency instead. Nothing here requires you to design the whole platform, but you do have to think past the request you are currently serving.

Webhooks are junior

The moment you integrate an external service you inherit its callbacks, and callbacks arrive out of order, twice, or six hours late. Handling that reliably is a bounded skill: verify the signature, make the handler idempotent, acknowledge fast and do the real work elsewhere.

app/api/webhooks/route.tsts

1export async function POST(req: Request) {
2  const raw = await req.text()
3  if (!verify(raw, req.headers.get("signature")))
4    return new Response("bad signature", { status: 401 })
5 
6  const event = JSON.parse(raw)
7  const fresh = await claim(event.id) // insert, unique
8  if (!fresh) return new Response(null, { status: 200 })
9 
10  await enqueue(event)
11  return new Response(null, { status: 202 })
12}

Acknowledge before you work

Most providers retry anything that is slow or non-2xx. Claiming the event id and returning 202 immediately turns their retry policy from a source of duplicate work into a safety net.

Orchestration is senior

Here is the one senior placement in this batch. With orchestration you take responsibility for a whole operation finishing correctly while individual steps fail across systems you do not control. Retries, idempotency, compensation and partial failure all become your problem at once, and every one of them is a design decision rather than an implementation detail.

Table joins are intern

An ORM writes the SQL, and that is exactly why this stays on the list. If you do not know how the related tables fit together, you cannot predict how many rows come back, and you will ship the query that returns each order five times because it joined through the line items.

Database transactions are junior

As soon as a feature writes to two tables, half-finished writes become a real state your system can end up in. Knowing that, and knowing a transaction is what prevents it, is where I draw the line for junior. What a transaction does not cover, such as the email you already sent or the cache you already invalidated, is a later conversation.

Server-sent events are junior

A one-way stream over plain HTTP is a focused feature. You add an endpoint, you keep a connection open, you handle reconnects and the proxy that buffers you. Nothing about the rest of the system has to change, which is what keeps it below the mid-level line.

Which one would you move?

The argument I expect here is transactions, since plenty of people would push them down to intern. I keep them at junior because the interesting part is not the syntax, it is recognising which pieces of a feature must land together.