Fundamentals of Backend Engineering

Name: Fundamentals of Backend Engineering
Rating: 4.7 (7524 reviews)

Understand backend communication design patterns, protocols, execution and proxying

Bestseller

Highest Rated

Created byHussein Nasser

Last updated 7/2026

English

Arabic [Auto],Bulgarian [Auto],

What you'll learn

Learn the fundamentals of backend engineering
Backend communication design patterns
Understand how backend communication protocols work
Comprehend how OS Kernel communicate with Backend Applications
Operating System fundamentals (Thread, Process, async IO in linux)
Learn HTTP/1.1, HTTP/2, HTTP/3
Learn gRPC, WebRTC, WebSockets
Learn TLS 1.2, TLS 1.3, QUIC 0RTT

Course content

8 sections • 64 lectures • 20h 2m total length

Welcome5:47
Who is this course for?3:01
Designed for backend engineers who want to demystify why systems work and bridge backend and network concepts. It also serves full-stack or frontend engineers seeking intermediate to advanced insights.
Course Outline10:47
Explore backend engineering fundamentals by examining communication patterns, protocols, and execution models—from request-response and pub-sub to OSI, UDP/TCP, HTTP/1.1/2/3, TLS, and QUIC, ending with proxies and load balancers.
Course Notes3:30
Download all slides, source code and references0:04
Repo: github /hnasr/backend-course-code

Backend Communication Design Patterns Intro2:02
Request Response27:37
Synchronous vs Asynchronous workloads42:30
Explore synchronous versus asynchronous workloads, including blocking IO, non-blocking IO, callbacks, promises, and async/await, with Node.js event loop, queuing, and asynchronous backend processing.
Push19:59
We explain what Push is, how does it work, its pros and cons, and then we build a web socket chatting application using Push model
Polling14:13
Long Polling10:11
Server Sent Events13:18
In this lecture we discuss Server Sent Events pattern and show an example in NodeJS
Publish Subscribe (Pub/Sub)16:37
In this lecture I talk about the publish subscribe pattern, its pros and cons and show an example with RabbitMQ
Multiplexing vs Demultiplexing (h2 proxying vs Connection Pooling)14:52
Explore multiplexing and demultiplexing across http/1.1 and http/2, and how reverse proxies and connection pooling affect throughput and resource use.
Stateful vs Stateless22:42
Explore stateful and stateless backends and protocols to understand how applications store or transfer client state. Learn implications, such as session management, cookies, and database-backed state, influencing scalability and resilience.
Sidecar Pattern21:33

Protocols Intro1:08
Protocol Properties10:47
What to take into account when designing a protocol?
OSI Model47:29
Open Systems Interconnection model - this lecture is taken from my networking course.
Internet Protocol1:07:12
This is a collection of lectures specific to IP protocol taken from my fundamentals of network engineering course merged into one lecture.
UDP48:22
User Datagram Protocol - This is a collection of lectures specific to UDP protocol taken from my fundamentals of network engineering course merged into one lecture.
TCP55:11
Transmission Control Protocol - This is a collection of lectures specific to TCP protocol taken from my fundamentals of network engineering course merged into one lecture.
TLS26:59
Transport Layer Security - This is a collection of lectures specific to TLS protocol taken from my fundamentals of network engineering course merged into one lecture.
HTTP/1.131:11
HTTPS, TLS, Keys and Certificates1:01:38
WebSockets21:21
Learn how WebSocket enables bidirectional, full-duplex communication over HTTP via the upgrade handshake. Explore use cases like chat apps and live feeds, plus pros, cons, and a simple Node.js example.
HTTP/217:03
HTTP/327:58
gRPC49:10
WebRTC1:07:44
Explore WebRTC for real-time peer-to-peer communication, covering SDP signaling, ICE candidates, NAT traversal with STUN and TURN, and browser data channels.

Backend Execution Patterns Intro4:48
Explore backend execution patterns for accepting and dispatching requests with tcp, udp, http, grpc, and https over tls and quic, and how listeners and process models affect performance and idempotence.
The Process and The Thread and how they compete for CPU time27:46
Compare processes and threads, explain how CPU scheduling and memory sharing shape multi-process and multi-thread backends, and show locking and copy-on-write strategies.
How The Backend Accepts Connections29:29
In this lecture we explain the SYN and ACCEPT queues in the OS and how the backend reads from them
Reading and Sending Socket Data21:22
In this lecture we explain the Receive and Sender queues in the OS and how the backend reads and writes to them
The Listener, The Acceptor and the Reader2:06
Single Listener, Acceptor and Reader Thread Execution Pattern3:07
Discover the single listener, single acceptor, and single reader pattern in Node.js, where a thread handles connections asynchronously, and scale by running multiple Node.js processes.
Single Listener, Acceptor and Multiple Readers Thread Execution Pattern5:31
Single Listener, Acceptor, Reader with Message Load Balancing Execution Pattern3:27
Multiple Accepter Threads on a Single Socket Execution Pattern1:57
Multiple Listeners, Acceptors and Readers with Socket Sharding Execution Pattern6:48
Backend Idempotency6:24
Implement idempotency by attaching a unique request ID, a UUID, and replay-detect to prevent duplicate effects on the backend with absurd execution. Get is read-only; never use get for writes.
Nagle's Algorithm12:07
Learn how nagle's algorithm buffers tcp segments to fill the maximum segment size (MSS), causing client delays, and how disabling tcp no delay can improve overall performance.
When do you use threads?1:40

Proxy vs Reverse Proxy20:05
Explore the difference between a proxy and a reverse proxy, and how they bridge to the back end, enabling caching, logging, and load balancers through gateways, sidecars, and api gateways.
Layer 4 vs Layer 7 Load Balancers27:51
WebSocket Proxying23:21
Compare layer four and layer seven WebSocket proxying, explain how layer four tunnels traffic via nginx while layer seven terminates TLS and inspects content, enabling smart routing and WebSocket upgrades.

How ChatGPT uses Server Sent Events44:07
This is a video from my YouTube channel that I thought it's useful to add it here.

Code https://github.com/hnasr/javascript_playground/tree/master/chatgpt-twochats
How I design software5:25
The Journey of a Request to the Backend4:51
The Journey of a Request to the Backend (Video)12:20
JSON Web Token (JWT), its Pros and Cons56:37
SELECT COUNT (*) can impact your Backend Application performance, here is why20:15

How does the Kernel manage backend connections?4:55
Running out of TCP Ports18:32
Postgres failure caused by a Cisco router (TCP issue)1:39
Building Secure Backend Applications (OWASP recommendations)27:47
Explain the OWASP top ten web security risks, including injection, broken authentication, sensitive data exposure, and more, and show how to design secure backend and frontend applications.
HTTP Graceful Connection Shutdown25:05
Explore how to perform graceful shutdowns in HTTP/1.1 and HTTP/2, including the go away frame, balancing connections, streams, and caches to free resources without disrupting clients.

Requirements

Intermediate programming skills (1-2 years)
Having built a backend application
Basic network fundamentals

Description

Backend engineering is an art. During my 18 years career working with and building backend applications, I discovered that certain communication design patterns keep emerging. There are only handful of ways clients communicate with backend applications, although they might be more, I believe the patterns I discuss in this course are the most common. Examples of these patterns are request-response, publish-subscribe, short and long and push.

Based on these communication design patterns, engineers may use a number of protocols for concrete communication. While core transport vehicles are limited to either TCP or UDP, tons of industry specific protocols are built on top of these two to address certain problems and use cases. Examples of these high level protocols are HTTP/1.1, HTTP/2, HTTP/3, gRPC, WebRTC and many more. Other transport protocols like QUIC was built on top of UDP to bring HTTP/2 streaming down at the transport level. Each protocol has its pros and cons and fits certain use cases. In the course, I discuss the top common protocols and provide examples and demos where applicable.

Before the client can send a request, it has to establish a connection to the backend. Understanding how the connection is established, and what parts of connection establishment is done at kernel and what parts are done at the backend application process is critical. How the connection is then accepted by the backend application and how it can accept connections as fast as possible so the kernel queue doesn’t get full otherwise clients can no longer connect.

After the connection is established the client sends the request, but what happens exactly in the backend application to read the request? What exactly is a request? Understanding the cost of parsing a request based on the protocol makes the engineer appreciate the work done and equip her with better tools to troubleshoot performance problems or bugs.

Once the request reaches the backend, the application has to execute the request. The backend has a buffet of design choices when it comes to the style of execution it can choose. Understanding the difference between a process and a thread, multi-process, multi-threaded and the correlation to the number of CPU cores or hardware threads is crucial to pick the right execution pattern. One does not have to stick with these patterns but can invent new ones that suits their needs.

This course is designed for engineers who have built backend applications, it is an intermediate — advance level course, certain programming and networking knowledge is required so I recommend taking my fundamentals of network engineering course before taking this course if you don’t have the networking skills. I hope you enjoy this course, and thank you so much for considering it.

Who this course is for:

Backend Engineers
FullStack Engineers
Frontend Engineers interested in the Backend (must have built a backend app)
Network engineers who want to get better at backend design
Site reliability engineers

Fundamentals of Backend Engineering

What you'll learn

Explore related topics

Course content

Introduction5 lectures • 23min

Backend Communication Design Patterns11 lectures • 3hr 26min

Protocols14 lectures • 8hr 53min

Many ways to HTTPS7 lectures • 21min

Backend Execution Patterns13 lectures • 2hr 7min

Proxying and Load Balancing3 lectures • 1hr 11min

Extras6 lectures • 2hr 24min

Bonus Content5 lectures • 1hr 18min

Requirements

Description

Who this course is for: