Podcast · Tech & Science

The Backend Engineering Show with Hussein Nasser

by Hussein Nasser · English · Tech & Science

Welcome to the Backend Engineering Show podcast with your host Hussein Nasser. If you like software engineering you’ve come to the right place. I discuss all sorts of software engineering technologies and news with specific focus on the backend. All opinions are my own. Most of my content in the p

New episodes: Every two weeks
Typical length: 28 min
Latest: 25 Sep 2026
Language: English

Latest episode

25 Sep 2026 · 13 min

Engineers will be out of the 'Loops'

I discuss loops engineering and how it will numb creative thinking and critical system design for engineers.

Play episodeWhatsApp Download

Earlier episodes 29 most recent

18 Sep 2026 · 12 min
SQL was a mistake
I like SQL but the standard should have included ways to hint instead of the abstraction of "let me do it for you"
11 Sep 2026 · 16 min
Caching is a cop-out
In this episode I explore why you should take some time to examine the operation you are caching before doing so. And why caching is a cop-out
23 Aug 2026 · 18 min
How open ai agents "hacked" hugging face
10 Jul 2026 · 21 min
How a query optimization gave birth to infinite scroll
The infinite scroll in social media as we know it today is despised by all. But it always start as a bad idea. It originated as a result of UI change to relief the backend database from inefficient queries. I explore this in this episode of the backend engineering. 0:00 Intro1:00 Classic Paged results 6:23 Limitations of paging9:00 The scroll interface 12:00 How TikTok to infinite scroll 14:00 The current state
17 Jun 2026 · 34 min
Postgres is half as fast in Linux 7.0
An aws engineer discovered a 50% regression in postgres throughput while testing the new Linux 7.0 kernel. The cause turns out to be massive TLB and page faults exacerbated by Postgres process-based design. In this backend engineering show episode I dive deep into how this was discovered, the root cause and the possible fixes and workarounds. Intermediate and Advanced Backend Engineering Course Bundlehttps://courses.husseinnasser.com/bundleMy Book, Root Cause: Stories and Lessons from Two Decades of Backend Engineering Bugs https://amzn.to/4cKfZhe 0:00 Intro2:30 The Discovery6:30…
8 Jun 2026 · 32 min
Don't let AI rob you
A discussion about why many engineers still love the struggle, the mistakes, and the process of figuring things out themselves. This is how we grow and get better and stronger. Letting AI do everything (even though it can’t) robs us this feeling..
15 Apr 2026 · 10 min
New Book: Root cause
I wrote a new book that has been in the works for years. It is called Root Cause , and it is for those who enjoy the art of backend engineering. Early in my career, 20 years ago, I built backend and database applications without fully grasping their inner mechanics. Performance issues, race conditions, bugs, and even data corruption often left me lost. Since that day, I resolved to truly understand how systems work. From networking protocols and intermediary proxies to backend services and various database engines. I made it a habit to follow every request on its journey through the dark…
19 Jan 2026 · 46 min
5 Backend Design Patterns for Managing Threads and Sockets
In this video I introduce 5 different design patterns for building backend applications. Each mode explains how a socket listener is established, a connections are established and how threads and connections are managed to read, write and process requests.
15 Dec 2025 · 47 min
Page Tables
Page tables provide the mapping between virtual memory and physical memory for each process. This means it needs to be as efficient and as fast as possible. I explore the inner workings of page tables in this episode. 0:00 Intro 2:00 Virtual Memory ⁃ ⁃ 8:00 MMU 10:00 Page Tables ⁃ ⁃ ⁃ ⁃ ⁃ ⁃ ⁃ 11:30 Single Table Byte Addressability ⁃ ⁃ ⁃ ⁃ ⁃ ⁃ ⁃ ⁃ 16:00 Single Table Page addressability ⁃ ⁃ ⁃ ⁃ ⁃ 19:00 Multi-level Paging (Radix tree) ⁃ ⁃ 31:00 Huge Tables ⁃ ⁃ 33:00 TLB ⁃ ⁃ Summary
24 Nov 2025 · 49 min
CPU and Kernel Page Faults
Page faults occurs when the process tries to access a memory that isn’t backed by a physical page kernel raises a fault which loads a page. It happens on first access, stack expansion, COW, swap and much more. However it comes with a cost. In this episode of the backend engineering show I dissect the need and the cost page faults in the kernel. 0:00 Intro 4:00 Virtual memory Abstraction of physical memory Memory sharing Allow more processes to run , unused go to disk Numa, kernel can place memory near the cpu 12:00 VMA areas Text/code Data BSS Heap Stack 19:50 Kernel mode 25:30 What is a…
31 Oct 2025 · 24 min
Amazon US-EAST-1 Outage in Details
On October 19 2025 AWS experienced an outage that lasted over a day, 10 days later we finally got the root cause analysis and we know exactly what caused the DNS to fail0:00 Summary 5:30 How did Dynamo lost its DNS?13:41 EC2 Errors 16:16 Network Load Balancer ErrorsRCA here https://aws.amazon.com/message/101925/
17 Oct 2025 · 26 min
Graceful shutdown in HTTP
There are cases where the backend may need to close the connection to prevent unexpected situations, prevent bad actors or simply just free up resources. Closing a connection gracefully allows clients and backends to clean up and finish any pending requests. In this episode of the backend engineering show I discuss graceful connections in both HTTP/1.1 via the connection header and HTTP/2 via the GOAWAY frame. 0:00 Intro 4:58 Why shutdown connection? 6:46 HTTP/1.1 Graceful shutdown 12:26 Cost of HTTP/2 17:40 HTTP/2 GoAWAY frame 23:40 Summary Links…
3 Oct 2025 · 41 min
Postgres 18 gets Async IO
Postgres 18 has been released with many exciting features such as UUIDv7, Over explain module, composite index skip scans, and the most anticipated asynchronous IO with worker and io_uring mode which I uncover in this show. Hope you enjoy it 0:00 Intro 1:30 Synchronous vs Asynchronous calls 3:00 Synchronous IO 6:30 Asynchronous IO 10:00 Postgres 17 synchronous io 17:20 The challenge of Async IO in Postgres 18 20:00 io_method worker23:00 io_method io_uring 29:30 io_method sync 31:08 Async IO isn’t done! 3 1:30 Support for backend writers 32:36 Improve worker io_method 33:00 direct io support…
13 Jun 2025 · 23 min
Kernel level TLS
Fundamentals of Operating Systems Course https://oscourse.winktls is brilliant.TLS encryption/decryption often happens in userland. While TCP lives in the kernel. With ktls, userland can hand the keys to the kernel and the kernel does crypto. When calling write, the kernel encrypts the packet and send it to the NIC.When calling read, the kernel decrypts the packet and handed it to the userspace. This mode still taxes the host’s CPU of course, so there is another mode where the kernel offloads the crypto to the NIC device! Host CPU becomes free. Incoming packets to the NIC are decrypted in…
9 May 2025 · 10 min
The beauty of the CPU
If you are bored of contemporary topics of AI and need a breather, I invite you to join me to explore a mundane, fundamental and earthy topic. The CPU. A reading of my substack article https://hnasr.substack.com/p/the-beauty-of-the-cpu
18 Apr 2025 · 28 min
Sequential Scans in Postgres just got faster
This new PostgreSQL 17 feature is game changer. They know can combine IOs when performing sequential scan. Grab my database course https://courses.husseinnasser.com
11 Apr 2025 · 10 min
Does discipline work?
No technical video today, just talking about the idea of discipline and consistency.
4 Apr 2025 · 31 min
Socket management and Kernel Data structures
Fundamentals of Operating Systems Course This video is an overview of how the operating system kernel does socket management and the different data structures it utilizes to achieve that. timestamps 0:00 Intro 1:38 Socket vs Connections 7:50 SYN and Accept Queue 18:56 Socket Sharding 23:14 Receive and Send buffers 27:00 Summary
6 Dec 2024 · 29 min
The genius of long polling
Polling is the ability to interrogate a backend to see if a piece of information is ready. It can introduce a chatty system and as a result long polling was born. In this video I explain the beauty of this design pattern and how we can push it to its limit. 0:00 Intro 0:45 Polling 2:30 Problem with Polling 3:50 Long Polling 8:18 Timeouts 10:00 Long Polling Benefits 12:00 Make requests into Long Polling 17:36 Request Resumption 21:40 Summary
1 Nov 2024 · 39 min
Six stages of a good software engineer
You get better as a software engineer when you go through these stages. 0:00 Intro 1:15 Understand a technology 7:07 Articulate how it works 15:30 Understand its’ limitations 19:48 Try to build something better 27:45 Realize what you built also has limitations 32:48 Appreciate the original tech as is Understand a technology We use technologies all the time without knowing how it works. And it is ok not knowing how things work if interests isn’t there. But when there is interest to understand how something works, pursue it. It feels good when you understand how something works because you…
25 Oct 2024 · 18 min
This new Linux patch can speed up Reading Requests
Fundamentals of Operating Systems Course https://oscourse.win Very clever! We often call read/rcv system call to read requests from a connection, this copies data from kernel receive buffer to user space which has a cost. This new patch changes this to allow zero copy with notification. “Reading' data out of a socket instead becomes a “notification” mechanism, where the kernel tells userspace where the data is.” This kernel patch enables zero copy from the receive queue. https://lore.kernel.org/io-uring/ZwW7_cRr_UpbEC-X@LQ3V64L9R2/T/ 0:00 Intro 1:30 patch summary 7:00 Normal Connection Read…
18 Oct 2024 · 1 hr 2 min
Cloudflare's 150ms global cache purge | Deep Dive
Cloudflare built a global cache purge system that runs under 150 ms. This is how they did it. Using RockDB to maintain local CDN cache, and a peer-to-peer data center distributed system and clever engineering, they went from 1.5 second purge, down to 150 ms. However, this isn’t full picture, because that 150 ms is just actually the P50. In this video I explore Clouldflare CDN work, how the old core-based centralized quicksilver, lazy purge work compared to the new coreless, decentralized active purge. In it I explore the pros and cons of both systems and give you my thoughts of this system.…
28 Sep 2024 · 29 min
MySQL is having a bumpy journey
Fundamentals of Database Engineering udemy course https://databases.win MySQL has been having bumpy journey since 2018 with the release of the version 8.0. Critical crashes that made to the final product, significant performance regressions, and tons of stability and bugs issues. In this video I explore what happened to MySql, are these issues getting fixed? And what is the current state of MySQL at the end of 2024. 0:00 Intro 2:00 MySQL 8.0 vs 5.7 Performance 11:00 Critical Crash in 8.0.38, 8.4.1 and 9.0.0 15:40 Is 8.4 better than 8.0.36? 16:30 More Features = More Bugs 22:30 Summary and my…
20 Sep 2024 · 21 min
How many kernel calls in NodeJS vs Bun vs Python vs native C
Fundamentals of Operating Systems Course https://oscourse.win In this video I use strace a performance tool that measures how many system calls does a process makes. We compare a simple task of reading from a file, and we run the program in different runtimes, namely nodejs, buns , python and native C. We discuss the cost of kernel mode switches, system calls and pe 0:00 Intro 5:00 Code Explanation 6:30 Python 9:30 NodeJS 12:30 BunJS 13:12 C 16:00 Summary
13 Sep 2024 · 31 min
When do you use threads?
Fundamentals of Operating Systems Course https://os.husseinnasser.com When do you use threads? I would say in scenarios where the task is either 1) IO blocking task 2) CPU heavy 3) Large volume of small tasks In any of the cases above, it is favorable to offload the task to a thread. 1) IO blocking task When you read from or write to disk, depending on how you do it and the kernel interface you used, the write might be blocking. This means the process that executes the IO will not be allowed to execute any more code until the write/read completes. That is why you see most logging operations…
7 Sep 2024 · 25 min
Frontend and Backends Timeouts
I am fascinated by how timeouts affect backend and frontend programming. When a party is waiting on something you can place a timeout to break the wait. This is useful for freeing resources to more critical processes, detecting slow operations and even avoiding DOS attacks. Contrary to common beliefs, timeouts are not exclusive to request processing, they can be applied to other parts of the frontend-backend communications. Let us explore this briefly. 0:00 Intro 2:30 Connection Timeout 5:00 Request Read timeout 10:00 Wait Timeout 12:00 Usage Timeout 14:00 Response Timeout 16:00 Canceling a…
2 Sep 2024 · 28 min
Postgres is combining IO in version 17
Learn more about database and OS internals, check out my courses Fundamentals of database engineering https://databases.win Fundamentals of operating systems https://oscourse.win This new PostgreSQL 17 feature is game changer. You see, postgres like most databases work with fixed size pages. Pretty much everything is in this format, indexes, table data, etc. Those pages are 8K in size, each page will have the rows, or index tuples and a fixed header. The pages are just bytes in files and they are read and cached in the buffer pool. To read page 0, for example, you would call read on offset 0…
30 Aug 2024 · 37 min
Windows vs Linux Kernel
Fundamentals of Operating Systems Course https://os.husseinnasser.com Why Windows Kernel connects slower than Linux I explore the behavior of TCP/IP stack in Windows kernel when it receives a RST from the backend server especially when the host is available but the port we are trying to connect to is not. This behavior is exacerbated by having both IPv6 and IPv4 and if the happy eye ball protocol is in place where IPv6 is favorable. 0:00 Intro 0:30 Fundamentals TCP/IP 3:00 Unreachable Port Behavior 6:00 Client Kernel Behavior (Linux vs Windows) 11:40 Slow TCP Connect on Windows 15:00…
25 Aug 2024 · 20 min
Running out of TCP ephemeral source ports
In this episode of the backend engineering show I describe an interesting bug I ran into where the web server ran out of ephemeral ports causing the system to halt. 0:00 Intro 0:30 System architecture 2:20 The behavior of the bug 4:00 Backend Troubleshooting 7:00 The cause 15:30 Ephemeral ports on loopback

About The Backend Engineering Show with Hussein Nasser

The Backend Engineering Show with Hussein Nasser is a English tech & science podcast from Hussein Nasser. Melo plays each episode straight from the publisher's own feed — no ads added, no account needed — and remembers where you stopped, in this browser only.

Publisher: Hussein Nasser
Language: English
Category: Tech & Science
New episodes: Every two weeks
Typical length: 28 min
Latest episode: 25 Sep 2026
Feed: RSS — paste into any podcast app
Apple Podcasts: podcasts.apple.com/podcast/id1649995930
Rights: Hussein Nasser

RSS feed Apple Podcasts

More English tech & science

Take it with you

The Melo app keeps playing with the screen off, works in the car and on your watch, wakes you to your station, and browses the whole catalogue offline. Free, no ads, no account.