Explore

Fundamentals of Backend Engineering

The role of a Backend Engineer

Some people think that the job of software engineers is to translate product requirements into working software applications by writing codes. While this may be partially true in some contexts, modern software development requires software engineers to take on much more responsibilities in order to build successful software applications. Those responsibilities include technical responsibilities like software designing, testing, and operations to business & product responsibilities like discovering opportunities, generating ideas, and designing business solutions. The more senior an engineer is, the bigger scope that the engineer should overlook, and more skills are needed for a software engineer to perform effectively.

This guide will provide you with an overview of the responsibilities of the backend engineer role and the skills a backend software engineer should have. For each skill, we also include some hand-picked resources for self-study if you want to learn more about that topic.

Backend Engineer's Responsibilities

In this section, we will describe some responsibilities of a backend engineer from our perspective. Please be noticed that this is not an exhaustive list; feel free to contribute if you find some mistakes or disagree with some of our selections.

Each responsibility is tagged with a seniority level. If a responsibility is tagged with principal level, it doesn't mean junior or senior engineers are not allowed to handle it; it just means that principal+ engineers are expected to have the knowledge and skills to take on that responsibility effectively.

Technical Responsibilities

Design and review solutions for business problems/requirements, including:

Architecture Design (Senior+).

APIs design (Junior+).

Database schema design (Junior+).

Component Design (Junior+).

Understand software quality attributes and tradeoffs when designing solutions (senior+), including but not limited to:

Testability.

Security

Reliability

Availability

Performance efficiency

Cost effectiveness

Write, review, and maintain high-quality code (Junior+):

Write and perform tests, including unit tests, integration tests, and performance tests (Junior+).

Write, review, and maintain CI/CD pipelines (Senior+).

Operate, troubleshoot, and debug software applications in the production environment (Senior+).

Leadership Responsibilities

Mentoring & coaching team members (senior+).

Define technical strategies, principles, best practices, and roadmap (principal+).

Refine development processes (principal+).

Consult engineering managers on resources management, hiring plan, team organization, and culture building (principal+).

Business Responsibilities

Traditional software engineers usually passively receive product requirements from Business Analysts. The products coming out of this mindset usually lack creativity, especially in terms of technical innovation. Engineers, with their deep understanding of technology and its capabilities, are one the best source of innovation.

As a backend engineer, you should proactively contribute to the product management process, right from the first step, including but not limited to:

Have a deep understanding of the business, customers, and products. (Senior+)

Actively consult product managers on finding opportunities, ideas generation, solution design, roadmap, and prioritization (Senior+).

Participate in product testing, dogfooding (Junior+)

Participate in product launching and post-launch assessment (Senior+).

Backend Engineering Knowledge And Skills

In order to handle those responsibilities, a backend engineer must continuously learn new knowledge and improve technical and soft skills. In this section, we will discuss some essential skills, knowledge, and learning resources that can help you pursue your career as a backend engineer.

Core Technical Knowledge & Skills

Basic Computer Science Knowledge

Algorithms and data structures, computer architecture, operating systems, computer networking, databases, programming languages, compilers, computer security, and distributed systems are some fields that a backend engineer should understand. For those not majoring in computer science,

https://teachyourselfcs.com/⁠

https://github.com/ossu/computer-science⁠

are good resources to learn about Computer Science.

Coding

Correctness, readability, extensibility, maintainability, and testability are some attributes of high-quality codes. A good starting book for coding is

Code Complete⁠

; it covers everything from component design to naming variables.

Backend development

A good book on backend development is

Building Microservices, 2nd Edition⁠

. Although the book mainly focuses on the microservices architecture style, most of the knowledge is still highly applicable to monolith or other architecture styles.

Backend engineer knowledge points:

Backend Application Development:

Framework Design Patterns:

⁠

Patterns of Enterprise Application Architecture⁠

⁠

Clean Architecture⁠

⁠

Layered vs Onion/Hexagonal architecture

Understand the differences between micro frameworks (Gin, Echo, Flask, FastAPI) and Full-fledged frameworks (Django, Rails, Buffalo).

Understand architecture styles and their use cases: Monolith, modular monolith, service-oriented, event-driven, microservices... (More resources about this topic can be found on System Design section)

Understand common problems and solutions in backend applications:

Data persistence.

Authentication.

Authorization.

Caching.

internationalization (i18n).

Data validation.

Error handling

Testing.

Client-Server communication and server-server communication.

Workflow orchestration, cron/background job management.

Distributed transactions, long-running transactions.

Observability: Health check, logging, metrics tracking, distributed tracing.

Config/secret management.

Service Communication

Understand different communication styles: Sync vs async, messaging, polling vs web sockets vs server-side events, RESTful vs GraphQL vs RPC...

For RESTful API design, some good guidelines are

Google AIPs⁠

Microsoft⁠

For messaging patterns:

https://www.enterpriseintegrationpatterns.com/⁠

⁠

Database:

Understand use cases and tradeoffs of different database types (Relational, NoSQL, NewSQL databases...):

⁠

NoSQL Distilled⁠

⁠

Understand Relational Databases and Schema Design:

⁠

Berkely's Introduction To DBMS Course⁠

⁠

High Performance MySQL⁠

⁠

SQL Antipatterns⁠

⁠

The Data Model Resource Book, Vol 3⁠

⁠

Security:

⁠

Agile Application Security⁠

⁠

Web Application Security⁠

⁠

OWASP Top Ten⁠

⁠

OWASP Web Security Testing Guide⁠

⁠

Microservices:

⁠

Building Microservices, 2nd Edition⁠

⁠

Monolith to Microservices⁠

⁠

Microservices Patterns⁠

⁠

System Design

Software architecture design is a continuous process. A senior software engineer should understand tradeoffs of different architecture styles and patterns, be able to evaluate architecture design decisions using software quality attributes, and design architectures that are evolvable. Some resources on system design:

Software Architecture Design Processes:

⁠

Fundamentals of Software Architecture⁠

⁠

Software Architecture in Practice⁠

⁠

Architecture Design Patterns & Practices:

⁠

Cloud Design Patterns - Microsoft⁠

⁠

Azure Architecture Guide⁠

⁠

Release It⁠

⁠

AWS Well Architected Framework⁠

⁠

Domain-Driven Design:

⁠

Eric Evan's Domain-Driven Design⁠

⁠

Learning Domain Driven Design⁠

⁠

Distributed System Design:

⁠

Designing Data-Intensive Application⁠

⁠

Patterns of Distributed System⁠

⁠

Real-World Systems:

⁠

Uber⁠

⁠

Facebook⁠

⁠

AirBnB⁠

⁠

Netflix⁠

⁠

InfoQ⁠

⁠

Supporting Technical Knowledge & Skills

Software Development Process

Lean, Agile, and DevOps have tremendously changed the way we develop modern software applications. Software engineers should understand basic principles and practices of Agile and DevOps, including but not limited to CALMS, shift-left movement, continuous integration/delivery, trunk-based development, etc...

Software Development Process:

⁠

Agile Manifesto⁠

⁠

Atlassian's DevOps guide⁠

⁠

Google's DevOps guide⁠

⁠

The Phoenix Project⁠

⁠

Devops Handbook⁠

⁠

Accelerate⁠

⁠

Practices:

⁠

Continuous Delivery⁠

⁠

Feature Flags⁠

⁠

Trunk Based Development⁠

⁠

System Administration & Software Operation

Understanding how modern softwares are built, delivered and operated in the production environment will help backend engineers better design their applications (

cloud-native applications⁠

), easier when troubleshooting and operating applications.

Practices

⁠

Linkedin's School of SRE⁠

⁠

Practice of Cloud System Administration⁠

⁠

Google's SRE books⁠

⁠

The Twelve Factor App⁠

⁠

Linux

⁠

How Linux Works⁠

⁠

Want to print your doc?
This is not the way.

Try clicking the ⋯ next to your doc name or using a keyboard shortcut (

CtrlP

) instead.