What you need to know to get a job as a backend developer in 2023

Work through this roadmap & I promise you’ll find a job…

You don’t know what you don’t know. Let me explain what I mean by that…

There are 4 types of knowledge:

1. Known knowns — things that you know, and you know that you know them (e.g. how to add, or how to speak English)
2. Unknown knowns — things that you know but take for granted and might possibly forget (e.g. how to bake bread, or a song on the piano)
3. Known unknowns — things that you don’t know but you know they exist and could learn them (e.g. martial arts, or Italian)
4. Unknown unknowns — things that you don’t know and don’t even know that they exist! (e.g. philately, or computational fluid dynamics)

Discovering unknown knowledge

When you’re learning to code and trying to get a job as a developer, one of the hardest parts is discovering the things that you don’t know that you don’t know (unknown unknowns)!

This post aims to demystify the job of web development. Specifically, we’ll focus on backend development in this post (frontend, data science, mobile, and more to come!).

Here’s a comprehensive resource on what you need to know…

The basics

Okay, so what are the fundamentals of web development?

1. How the internet works

A solid understanding of how the internet works is the most important place to start.

Many junior developers learn how to code without holistically learning how the Internet works. It shows when they interview for jobs because deploying a live production web application is very different from writing little apps from tutorials.

You’ll want to understand the high-level fundamentals of HTTP, DNS, TCP/IP, client-server/request-response, and how they all work together to allow users to access a website.

I’ve got you covered with a video and article on those topics:

2. Fundamentals of computing

In addition to the basics of the internet, you should understand the essentials of computers. Here are some concepts to be familiar with (no need to be an expert):

1. CPU, RAM, & Hard drive
2. Operating systems and basic terminal usage
3. Processes, threads, & concurrency
4. I/O-bound vs CPU-bound computations
5. Algorithmic complexity

You don’t need a degree in computer science or an expert understanding of the mechanics. But you should be able to talk about computing and the tradeoffs of various choices when coding.

3. Webpage essentials

As a backend developer, you’ll primarily be responsible for code that runs on web servers, worker machines, and independent processes.

However, at the end of the day, the user interacts with a web page, and you should understand the fundamentals of building web pages.

These boil down to 3 essential skills that you should be familiar with:

1. HTML
2. CSS (no need to be a CSS god, just passing familiarity with CSS approaches)
3. JavaScript (basic, vanilla JavaScript knowledge is all you’ll need)

4. Pick a backend language

We’re finally to the point where you learn how to code!

Notice that I put 3 other steps before learning how to code. Understanding those fundamentals is super important. With a good foundation in internet and computing, you’ll actually learn to code faster because certain lessons will fit into the larger picture quicker for you.

Okay, so which language should you learn?

There are a lot of options and you could probably get a job with any number of languages. That said, right now I’ll simplify your decision based on the trends I’ve seen in the web development industry:

Pick Python or JavaScript if you want to be a backend developer

These are the modern languages with the fastest growth. Most new startups today are building with either Python or JavaScript. Python is good for data-intensive applications. JavaScript is popular with consumer apps.

Honorable mention: Go (performant growing language from Google), Ruby (popular for web dev in the past 15 years), Java (older, enterprise language), C# (Microsoft ecosystem, enterprise)

Development skills

We’ve covered the basics and you should now be able to code up a simple script and basic HTML page. Additionally, you should understand the essentials about the internet and computing.

Now, let’s get into the meat of the skills you’ll need to work as a professional backend developer.

1. Frameworks

Backend development rarely happens from scratch. For performance and security reasons (along with ease of use), nearly all companies leverage established open-source frameworks for backend development.

If you chose JavaScript as your language to learn to code, then that means learning:

• Express (and consequently learning about NodeJS)

If you chose Python as your language, then learn:

• Django and/or Flask

Learn these frameworks well as they’ll be the underpinning of nearly everything you do as a backend developer.

2. Database essentials

As a backend developer, you’ll end up designing and interacting with various ways of storing data. You should understand how those data stores work, good design practices, and how to safely query data.

Currently, databases technologies follow one of two general paradigms:

Relational — Relational databases are an established technology and the most widely used in production applications. Generally, you query relational databases using SQL. You should learn the essentials of SQL!

NoSQL — There are a variety of other databases that all are lumped together in the bucket of “databases that don’t use SQL,” aka NoSQL. The commonality between them is they don’t organize data into traditional tables with rows. Instead, they might be optimized for storing unstructured documents, time-series information, columnar data, or realtime rapid operations.

To get a job as a backend developer, you should definitely know about relational databases and how they work. Knowledge about NoSQL databases is less essential, but it’s good to know that they exist and the basics of what they might be used for.

3. How APIs work: creating & consuming them

Most of the modern internet is powered by Application Programming Interfaces (APIs).

In the past, web pages required loading a new page with every operation, making the web clunky to click around. Today, you’ll notice that the page rarely reloads while you’re browsing modern websites. Instead, APIs allow everything to load seamlessly & asynchronously as you browse.

As a modern backend developer, creating and maintaining APIs will be a huge part of your job. Additionally, you’ll make requests to other APIs in order to fetch data or authenticate requests.

You should know the basics about APIs, how to use them, and how to create them. Broadly, REST APIs using JSON are the most popular and most important to know.

As a backend developer, you’re also likely to encounter other formats like SOAP APIs using XML or GraphQL APIs. It’s not essential to know all the details of these formats, but it’s good to be familiar.

4. Caching

Caching means storing recent or frequently used information so that subsequent requests are either faster or don’t need to interact with a server at all. There are several different types of caching to know about:

1. Memory stores — e.g. Redis or Memcached
2. Content Distribution Networks (CDNs)
3. Client side caching — e.g. browser cache, cookies, local/session storage

For production applications running at a large scale, caching is very important. It can also be quite tricky to get right, as maintaining a valid version of the cache when things change is a major task.

5. Testing

Software testing can be a little confusing and circular feeling, if you haven’t encountered tests before. At a basic level, you’re writing separate code that runs your feature code and makes sure it works as expected.

As a professional developer, you should write tests any time you contribute new code. Most organizations have testing requirements for new code before it can be merged into the project.

You should be familiar with several different types of testing:

• Unit testing in your language of choice
• Integration testing for multiple parts of the web application in your framework of choice
• End-to-end testing of the entire application that ensures all features are working correctly together

You should know about these concepts:

• Test-driven development
• Writing testable code

Job-oriented skills

In addition to the hard coding skills, you’ll need skills in other technologies that make for a job-ready developer.

1. Version Control / Git

All serious software development teams use version control software to manage changes to source code. Overwhelmingly, Git is the tool of choice and you should definitely know how to use Git before getting a job.

Additionally, it’s worth learning about repositories and how code gets hosted online so that teams can collaborate. The most popular repository hosting site is GitHub. Learn GitHub and you’ll be well prepared for any other repo host you might encounter in your job.

2. Terminal usage & SSH

As a backend developer, it pays to be comfortable using the terminal. Pick Windows vs Unix and then dig into some common terminal commands.

You should be able to navigate directories, open/copy/move files, and run commands from the terminal prompt. Bonus points if you learn how to string together commands, search files, and do batch operations using the command line.

Backend developers can be asked to SSH into remote machines, like CI/CD environments or staging servers, in order to debug issues. So, basic terminal usage will be invaluable.

Command aliases will also help you save a lot of time:

3. CI / CD

Continuous integration and continuous deployment are processes in place at the most productive software teams.

These tools automatically run checks and tests against new code that’s pushed. From there, they can automate the entire chain of spinning up a development environment, running automated QA, and automatically deploying the code to production once it’s approved and merged.

As a backend developer, you should be familiar with CI/CD and how it works to check new code. In some cases, you may need to help update, maintain, or change CI/CD workflows. Just a high-level understanding of CI/CD will be enough for your first job — bonus points if you set up CircleCI or Travis to automatically run the tests for one of your portfolio projects.

4. Containerization / Docker

One of the most important developments in software in recent years is the trend toward containerization.

With containerization software like Docker, you define the exact parameters of the environment where your code should run. What’s the operating system? What dependencies need to be installed?

For decades, the common trope of software development was, “It works on my machine!” Missing or outdated versions of dependencies across machines meant that the application ran inconsistently. With containerization, that problem is eliminated.

Instead, Docker containers allow everyone’s computers to have a shared definition of the setup for the application. Developers can collaborate on different machines while everyone shares the definition of the application’s runtime.

As a backend developer at most organizations, you’ll need to know about containerization and the basics of Docker (how to start/kill/restart containers). You might also be asked to make changes to a Dockerfile or docker-compose.yml, so it’s worth understanding the fundamentals.

5. IDEs / Modular Editors

Developers spend a lot of time typing. At my last job (which lasted 2.5 years), I added 283k lines of code.

When you’re spending that much time typing, it’s actually super important that you have a tool that supports quickly editing text.

Modern IDEs are designed to make writing code easier with lots of features that simplify adding, editing, and navigating. Popular IDEs include:

• VS Code
• PyCharm
• Sublime

For me, I prefer fewer bells & whistles and more powerful control over my editor. That’s why I use Vim, a modular editor that has a high learning curve but makes editing text very fast.

If you’re up for the challenge, I think learning Vim (plus the idea of Unix as IDE) is worth it.

Software Approaches

A big part of the job of a software engineer is thinking about and talking about software with other engineers and stakeholders.

You’ll need a good foundation in common approaches and patterns so you can follow along and contribute to these conversations in a meaningful way.

1. Design principles

Software developers have a couple go-to principles that come up over and over when talking about code. They’re acronyms, so here they are and you can research each one:

• DRY — Don’t repeat yourself
• YAGNI — You aren’t gonna need it
• KISS — Keep it simple stupid (or, I prefer, “Keep it stupid simple” bc you’re not stupid!)
• SOLID — This one is a harder acronym to type out, but Google “solid software” and you’ll find the right thing
• Gang of Four (GoF) — A whole book of common code templates to apply to various real world problems

2. Architecture patterns

Web applications tend to follow architecture paradigms for how they’re designed and deployed. Here are some common patterns/terms that you should be familiar with:

• Monolith
• Service-oriented
• Microservice
• Serverless

3. Observability & monitoring

When the application breaks, developers need to know about it. Production applications need a way that errors generate alerts for the engineering team.

Moreover, engineering teams track all kinds of metrics about the application like number of requests, response time, and traces of user flows. Monitoring and observability tools are the hallmarks of great engineering teams.

As a new developer, you should know the basics of logging and exception handling. You should also be passingly familiar with some of the most popular tools for monitoring like Datadog, New Relic, Dynatrace, or Sentry.

4. Scaling

As you add more users or heavier workloads to your application, you reach limits of scalability. When scaling issues arise, it’s up to backend engineers to figure out solutions that make the application more performant for larger loads.

There are some basic terms and scaling strategies you should know about as a new backend developer:

• Horizontal vs vertical scaling
• Background tasks (workers)
• Load balancing
• Read-through vs write-through caching
• Writer/reader databases & read replicas
• Database partitioning/sharding

5. Security

An understanding of the basic principles of web security is also incredibly important as a backend engineer.

Thankfully, most frameworks will enforce security practices by default, meaning that you don’t need a deep understanding of cryptography, SQL injection, or CORS/CSRF attacks. However, you should still know that these vulnerabilities exist and best practices for avoiding them.

The best place to get a quick rundown of security best practices is OWASP:

“Soft” skills

When you’re not writing code, there are a long list of other tasks that software engineers undertake. Far from being minor tasks, these soft skills are what set apart the truly great developers and will distinguish you in an interview or working on a team.

I’ve got whole articles about these skills. That’s how important they are.

Whew, that ‘s a lot!

Yes, it is!

Backend developers have a difficult, highly technical set of skills. They also have to collaborate effectively with other engineers to implement complex features.

It’s not easy to get a job as a backend engineer. Don’t let anyone tell you it’s simple. There’s a reason why backend engineers get paid so much, and it’s because learning all of these skills well is difficult.

Now that you have a roadmap, though, you know what you know (and what you don’t). If you work through the sections of this article, I promise you’ll be job ready when it comes time to interview!

Free Access to Career Advice

Get a free 7-day developer career course & email access to me as your engineering mentor…

Join 800 other developers currently in my free email mentorship program.