How to become a Backend Software Engineer (2024 edition)

First, let’s check if you qualify by answering ONE question:

Yes? Great! Read on ;-)

How I became a Software Engineer

In my 9th grade I applied to a computer science course in my school. The selection of special courses was pretty bare, - either software engineering, or something else I don’t even remember what it was. The choice was obvious, and it defined all the future life.

The course was pretty basic (and we used QBasic, haha!), but it was enough for me to realise having a computer, a couple of hands and a brain is all I need to create something out of nothing.

In grade 10 as my course project I went completely over what would earn me a top grade and created a “Who wants to be a millionaire” game simulator. The game would greet a player with a pretty oval face of the host. The questions would progress from funny and easy ones to more tough. The hints would be available too. If the player is stuck on a simple question, the audience or a call to a friend would most likely give the player the right answer. For more difficult questions, the audience would be less helpful. The list of questions could be edited in a text file, and each time the game engine would pick a random set of questions.

I chanced to get admitted to Far Eastern Federal University to study math and programming as main subjects. My passion multiplied many times with every programming project. I did c, c++, perl, and finally php. It may seem like a weird transition from c to php (and boy I loathed both perl and php because how come a language doesn’t have pointers and direct memory access? Like, what if I need to write up a linked list?), but it happened naturally as I got fascinated by the web, and started picking web-based projects as my courseworks.

How YOU will become a Software Engineer

There is no single recipe, but if you just follow your passion, you’ll figure out your own way. What this chapter is about than, you may ask? It’s about giving you a little bit of a roadmap, a map outlinig some continents and oceans, it’s a rough map, so you’ll definitely find some dragons dragons and maybe some treasure chests. This article is something I wish I had when I was starting out. Wait, not like this. This article is something I wish I had when I was starting out NOW, in 2024-2025, because software engineering changed a lot since I started. What didn’t change is the passion. And basics.

Basics

Meta-skills

First of all, you should have some meta-skills. These are the skills that will help you learn other skills. They are:

• Problem-solving. You should be able to break down a problem into smaller parts, analyze them, and come up with a solution. You should be able to think logically and critically.
• Learning. Applied curiosity isn’t enough. You should be able to learn new things quickly and efficiently. This implies learning how to learn, and knowing where to look for information. I strongly recommend enrolling into the Learning how to learn on Coursera.

Linux/UNIX/MacOS

First of all, you should be comfortable with a Unix-like operating system. It doesn’t matter if it’s Linux, MacOS, or FreeBSD. You should be able to navigate the file system, install software, and run commands in the terminal.

Some very basics you should get yourself familiar with are:

• File system hierarchy
• ssh
• bash/zsh
• package managers (apt, yum, brew)
• basic commands (ls, cd, cp, mv, rm, mkdir, touch, cat, less, grep, find, ps, kill, top, etc.)
• permissions (chmod, chown)
• environment variables

If you want to use Windows, I think it’s fine too, but I won’t help you with that, sorry. Last time I used Windows was when XP was still a thing, and Vista just came out and was a huge failure 😬

Programming

First of all, programming itself. You don’t need to go too deep, just don’t go too shallow. Wade into programming languages and paradigms, understand some OOP and SOLID principles, get a grip on the basics of algorithms and data structures. Dive a little deeper and understand abstractions, design patterns, and software architecture. Here’s a more precise list of what you should be at least familiar with (don’t need to be an expert):

• Programming language of your choice (syntax, semantics, control structures, a bit of standard library). I’d recommend starting with latest version of Python.
• OOP principles (encapsulation, inheritance, polymorphism) and SOLID principles
• Basic algorithms and data structures (arrays, linked lists, stacks, queues, trees, graphs, hash maps, sorting, searching)
• Design patterns (singleton, factory, builder, strategy, observer, etc.)
• Some frameworks and libraries (Flask would be a good option for Python)
• Caching
• Abstractions
• Unit testing

Databases

Secondly, you should know about databases. At least RDBMS (relational database management system) and how to use SQL (structured query language). Let’s lay out a list of bare minimum knowledge:

• RDBMS (MySQL/PostgreSQL)
  • Desiging a database schema
  • Normalization
  • Transactions
  • ACID properties
• SQL (SELECT, INSERT, UPDATE, DELETE, JOIN, GROUP BY, ORDER BY, etc.)
• Indexing

Invest a little bit of time learning Valkey too, it’s fork of Redis but it’s FOSS and de-facto an industry standard for caching and session storage. It also can be used for things you wouldn’t want to be concerned about, like rate limiting, distributed locks, message queues, etc.

RDBMS and Valkey are the bare mminimum. There are many more databases and data storage solutions, but you can learn them as you go. There are NoSQL, NewSQL, columnar databases, document databases, key-value stores, time-series databases, graph databases, etc.

Web

• HTML, CSS, JavaScript
• HTTP protocol
• DNS and how it works
• RESTful API
• Web security (XSS, CSRF, SQL injection, etc.)
• Web servers (Nginx, Apache, etc.)
• Session management

Git

Even if you don’t have a team to work with, you should learn Git. It’s a version control system that will help you keep track of your code changes and collaborate with others.

Get yourself familiar with just basics to get you going. Going through a tutorial would be a good start.

The bare minimum is when you are comfortable using following commands:

git clone
git init
git checkout
git fetch
git pull
git push
git diff
git rebase
git show

Up next

In the next chapter we’ll talk about more advanced topics, like:

• Authentication and authorization, OAuth, JWT, etc.
• Microservices (REST, gRPC, GraphQL)
• Containers (Docker, Kubernetes, etc.)
• CI/CD (Jenkins, GitLab CI, GitHub Actions, etc.)
• Cloud computing (AWS, GCP, Azure, DigitalOcean, etc.)
• Security (OWASP Top 10)
• Monitoring (Prometheus, Grafana, DataDog, etc.)
• Logging (ELK stack, Graylog, etc.)
• Networking (TCP/IP, DNS, HTTP, etc.)
• Databases and search engines (DynamoDB, MongoDB, Cassandra, ElasticSearch, etc.)
• Web (React, Angular, Vue, etc.)

Also invest more into learning the language of your choice (can be only 1 for now). A programming language isn’t a thing in itself. Knowing only the syntax and semantics of a language is like knowing only the alphabet. You need to know how to write words, sentences, paragraphs, and whole books. You need to know how to structure your code, how to separate concerns, how to write clean and maintainable code. In addition to the language standard library, you should also learn some frameworks and libraries, how to use package managers, how to write tests, how to debug, how to profile, etc.

All of these are outside of the scope of this article, but if you are passionate about software engineering, you’re unstoppable learner, and capable of figuring everything out by yourself ;)

GOOD LUCK!