What Does a Backend Developer Do?

Beginner · 11 min

What a backend service is actually responsible for, and where that responsibility stops and the frontend's or infrastructure's begins.

Code Wrap · 11 min

What Does a Backend Developer Do?

The player loads from youtube-nocookie.com when you press play. Nothing reaches YouTube before that.

Taught by Code WrapReport a problem with this video
Not started
Set this lesson's status

What you'll learn

  • A backend service exists to hold the business logic, the data, and the authority over what's true, so that logic isn't duplicated or faked in every client that talks to it.
  • Four responsibilities belong to the backend in almost every system: running business logic, persisting data, handling authentication and authorization, and exposing an API other software can call.
  • What belongs to the frontend is presentation and interaction; what belongs to infrastructure is where your backend process actually runs, scales, and gets monitored — this roadmap is about the code in between.
  • This roadmap assumes you can already program in some language and teaches backend-specific practice — the frameworks, patterns, and decisions that apply once you're writing a service, not how to write a for-loop.

Why a backend exists at all

Picture an app with no backend — just a frontend, running entirely in the browser or on a phone. It can still do a lot: render a UI, hold state in memory, even talk to third-party APIs directly. Where it breaks down is anywhere the user doesn’t get to be trusted. A banking app can’t let the phone itself decide the account balance, because the phone is physically in the hands of whoever’s logged in — if the balance lived only on the client, changing it would be as easy as editing a variable in the browser’s dev tools. The same problem shows up anywhere two people need to see the same shared, authoritative version of something: a chat message, an inventory count, a payment that’s either happened or hasn’t.

A backend is the answer to that problem: a program that runs somewhere neither party controls directly, holds the one version of the data and logic that counts, and only reveals or changes it through rules it enforces itself. Every client — a web app, a mobile app, another service — has to go through it to read or change anything real. That’s the whole reason the client-server model exists, and if you want the networking mechanics behind how a client actually talks to a server, that ground belongs to how the internet and the web work and DNS and HTTP — this lesson assumes you’ve got that and won’t re-teach it.

The four things a backend is actually on the hook for

Strip away any specific framework or language and almost every backend service is doing some combination of four jobs.

Business logic. The rules that are specific to what this application actually does — how a shipping cost gets calculated, whether a discount code is still valid, what happens when two people try to book the same seat at once. This is the part that’s genuinely yours; nobody ships a library that knows your business rules for you.

Data persistence. Nothing the backend computes matters if it vanishes the moment the process restarts. A backend is responsible for storing data somewhere durable — almost always a database — and for making sure reads and writes stay consistent even when many requests are hitting it at once.

Authentication and authorization. Knowing who is making a request (authentication) and whether that specific person is allowed to do this specific thing (authorization). A frontend can hide a delete button from a user who shouldn’t see it, but hiding a button is not security — the backend has to actually check and refuse the request, because nothing stops someone from calling the API directly.

Serving an API. All of the above has to be reachable by something. Usually that’s an HTTP API returning JSON, but it might be a form-rendering web app, a gRPC service talking to other backends, or a webhook receiver. Either way, the backend has to define a contract — what requests look like, what responses look like — and hold up its end of it.

Where the backend’s job stops

It’s just as useful to know what isn’t this job. Presentation — how data looks on screen, animations, responsive layout, client-side form validation for a snappier UX — is the frontend’s job. The backend might validate the same input again (it has to, since it can’t trust the client), but it doesn’t care what color the submit button is.

Infrastructure is the other boundary, and it’s easy to blur with backend work because the two sit right next to each other. Writing the code that handles a request is backend work. Deciding how many copies of that process run, how traffic gets load-balanced across them, how a database gets backed up and failed over, how alerts fire when something breaks — that’s operations and infrastructure territory, and plenty of it is genuinely specialized work with its own roadmap-level depth elsewhere on this site. A backend developer needs to understand that infrastructure exists and roughly how their code behaves inside it (a process that ignores SIGTERM will cause real pain for whoever runs it), but owning the Kubernetes cluster is a different job description.

What this roadmap actually teaches

Because “backend developer” spans so much ground, it’s worth being explicit about scope going in. This roadmap assumes you can already write code — you know what a function, a variable, and a conditional are, in some language. It is not going to teach you a programming language from scratch, and it isn’t a system-design or DevOps course either. What it teaches is the specific practice of writing a backend service: how to pick a language and framework for the job, how a web framework turns an incoming request into a response, how to configure a service so it can actually be deployed, how to work with a database from application code rather than as a DBA, and the security and operational habits a service needs once it’s running for real. Each lesson from here assumes the last, building from “what is this job” toward the concrete decisions you make while doing it.

Check yourself

  1. 01Why can't a frontend app just hold the "real" application data itself, instead of asking a backend for it?

    Because the frontend runs on a device the user (or an attacker) fully controls — anything stored or decided there can be inspected, edited, or faked, so a backend exists as the one place everyone has to go through for the version of the data and logic that actually counts.

  2. 02What are the four responsibilities that belong to a backend service in nearly every system?

    Running the business logic, persisting data reliably, handling authentication and authorization, and exposing an API that other software — including the frontend — can call.

  3. 03If a mobile app and a web app both need to show the same shopping cart total, where should that total actually get calculated?

    On the backend — calculating it independently in the mobile app and the web app risks the two disagreeing, and neither client can be trusted to enforce pricing rules correctly or honestly anyway.

  4. 04What's the difference between what a backend developer owns and what an infrastructure/ops engineer owns?

    A backend developer owns the code that implements the service's logic, data model, and API; infrastructure owns where that code actually runs — the servers, scaling, networking, and monitoring underneath it. The line isn't always clean, but the backend's job is the code, not the machine it runs on.

  5. 05What does this roadmap assume you already know, and what is it teaching instead?

    It assumes you can already program — write functions, use variables, work with a language's basics. It teaches the practice specific to writing a backend service: frameworks, request handling, databases in application code, and the security and operational discipline a service needs, rather than a language from scratch.

Notes

Private to you

Esc
↑↓ navigate↵ open? shortcuts

Keyboard shortcuts

Press Esc to close

Anywhere

⌘K
Search and commands
/
Search
?
This sheet
Esc
Close

Reading a lesson

J
Next lesson
K
Previous lesson
B
Bookmark