~/maps/backend
Career map: Backend
Backend holds the highest salary ranges in application development, and the reason is direct: the cost of a mistake is higher. What breaks there takes down the product, leaks data or loses money — which is why interviews probe data modelling and reasoning about failure far more than framework syntax.
This map is deliberately language-agnostic until the third stage. Java, Node, Python, .NET and Go solve the same problems with different accents; picking one before understanding transactions, indexes and idempotency is memorising the accent without learning the language.
- 5 stages
- 21 topics
- 11 essential
- 105 questions
Each topic has a short lesson and a 5-question test. The check is only granted at 80% or above — and the test tells you plainly when you did not get there.
Essential appears in practically every job ad. Recommended is what gets you past screening. Optional is specialisation — pick one instead of attempting them all.
Stage 1
Fundamentals that do not change
By the end you can explain where your code runs and what happens when something in the middle fails.
Operating system and networking
essentialProcess, memory, port and DNS stop being abstractions the day the service will not start in production.
Git and code review
essentialOn a backend team the pull request is where architecture is argued — presenting a change is worth as much as writing it.
Data structures and complexity
essentialIt shows up in technical tests and, more importantly, when explaining why a query got slow with ten times more data.
Stage 2
Databases
By the end you can model a domain from scratch and defend the decisions — the stage that fails the most mid-level candidates.
SQL and relational modelling
essentialNormalisation, foreign keys and joins are the foundation of nearly every production system.
Indexes and query plans
essentialReading an EXPLAIN is the difference between guessing why it is slow and proving which query costs the most.
Transactions and concurrency
essentialThis is what stops the same balance from being debited twice when two requests arrive together.
NoSQL and caching
recommendedRedis and document stores solve specific problems — using them as a general replacement for relational is the classic mistake.
Stage 3
Language and framework
By the end you can deliver a complete service in your chosen stack — and justify the choice by sector, not by fashion.
Choosing the stack by sector
essentialJava and .NET dominate banking, insurance and large retail; Node and Python concentrate in startups and digital products — the sector decides better than preference.
Java and Spring Boot
optionalThe largest installed base among companies hiring with formal contracts in Brazil, and the longest-lived.
Node.js and NestJS
optionalConcentrates startup and digital-product backends, and is the natural path for anyone coming from frontend.
Python with Django or FastAPI
optionalThe bridge between backend, data and AI — and the stack that grew most in job ads since the generative-AI wave.
Clean code and testing
essentialAutomated testing is no longer a differentiator at mid level; without it, changing legacy code becomes a gamble.
Stage 4
APIs and integration
By the end you can design and document an API another team can consume without asking questions.
REST and API design
essentialCorrect status codes, pagination and versioning are what keep another team’s client from breaking.
Authentication and authorisation
essentialJWT, OAuth and sessions solve different problems — confusing them is the origin of many security flaws.
Idempotency and webhooks
recommendedEvery payment integration resends events; whoever does not handle duplicates charges the customer twice.
GraphQL
optionalShows up in products with many different clients consuming the same domain; otherwise REST usually suffices.
Stage 5
Production
By the end you can operate what you wrote — the line between mid and senior on most teams.
Docker and environments
essentialPackaging the service ends "it works on my machine" and is a prerequisite for any modern pipeline.
Logs, metrics and traces
recommendedWithout observability an incident becomes guesswork — and it is the first question in a senior interview.
Messaging and async processing
recommendedKafka and queues appear in nearly every senior role; at-least-once delivery changes how the system is designed.
Application security
recommendedInjection, data exposure and secrets in the repository are the basics that data-protection law made expensive to get wrong.
Microservices
optionalThey solve a team-organisation problem, not a performance one — adopting them too early trades one problem for five.
From the map to the market
Studying without looking at what is being advertised is studying in the dark. The job panoramas are Portuguese-only for now, since the inventory is the Brazilian market — but the salary comparison works in either language.
Other trails
## faq
Frequently asked questions
Which backend language should I choose in Brazil?
Look at the sector before the language. Java and .NET concentrate roles in banking, insurance, telecom and large retail, with longer contracts and more formal processes. Node and Python dominate startups and digital products, with faster processes and more turnover. Both choices are defensible; what does not work is deciding by social-media popularity.
What fails candidates most in backend interviews?
Data modelling and reasoning about failure. Most candidates do well on syntax and frameworks and freeze on normalisation, indexes, transactions, idempotency and what happens when the network drops mid-call. These come up from mid level onwards and almost nobody studies them deliberately — doing so is the biggest lever in this map.
Do I need frontend to work in backend?
Not a requirement, but it helps more than it seems: understanding what your API client needs prevents designing endpoints that force five calls to render one screen. The reverse also holds — people coming from frontend often learn backend quickly because they have consumed enough APIs to know what bad looks like.
Is it worth learning microservices early on?
No. Microservices solve an organisational problem for large teams, and bring a stack of complexity with them — networking, consistency, distributed observability, coordinated deployment. Learning to build a well-structured monolith teaches the same fundamentals and is what most roles actually require day to day.