SWE – Software Engineering for the Rest of Us
by Arian Zargaran
SWE: Software engineering, explained like you're smart but brand new. Two hosts, one big idea a day, zero jargon left unexplained. If you've ever nodded along in a tech conversation you didn't understand, this is your show.
Episodes
-
Episode 26: Three Clues That Tell Engineers What Your App Is Really Doing
Mia and Leo explain logs, metrics, and traces through a building's visitor log, dashboard gauges, and security cameras: what logs record, why metrics trigger alarms, how a trace follows one request across services, and why engineers need all three clues when an app breaks. Observability for...
-
Episode 25: The Assembly Line That Ships Code While You Sleep
Mia and Leo explain CI/CD through a factory assembly line making blenders: continuous integration, automated tests, builds, continuous delivery vs continuous deployment, and why small, frequent, boring releases beat rare scary launches. CI/CD, pipelines, automated testing, and deployments for...
-
Episode 24: How Your Favorite App Changes Overnight Without Breaking
Mia and Leo explain software deployments through a restaurant chain swapping its soup recipe across twenty kitchens: canary rollouts, blue-green deployments, staging environments, rollbacks, and why your favorite app can change overnight without shutting down. Deployment, production, and feature...
-
Episode 23: The Traffic Cop Who Keeps Websites From Crashing
Mia and Leo explain load balancers through a supermarket attendant directing shoppers to the shortest checkout line: round robin, least connections, health checks, sticky sessions, and why load balancing is what makes scaling out actually work. Load balancing for beginners.
-
Episode 22: One Super Checkout Lane or Ten Ordinary Ones?
Mia and Leo explain scaling up vs scaling out through supermarket checkout lanes: why one bigger computer hits a ceiling and a single point of failure, how adding more ordinary servers handles peak traffic, and why load balancers and shared state matter when you scale out. Vertical scaling,...
-
Episode 21: The Shipping Container That Fixed 'It Works on My Machine'
Mia and Leo explain containers and Docker through the shipping container: why apps break when they move between computers, how a container packs code with its libraries and settings, what a Docker image is, and why Spotify and Netflix run on containers in the cloud. Pack it once, run it anywhere.
-
Episode 20: The Cloud Is Just Someone Else's Computer
Mia and Leo explain cloud computing through a rented workshop: why apps like Netflix and Spotify run on someone else's computers, how companies rent more power for the holidays and hand it back in January, and the three ways the workshop analogy breaks — geography, shared outages, and the meter...
-
Episode 19: Why Your Bank and Instagram Don't Use the Same Database
Mia and Leo compare SQL and NoSQL databases through a filing cabinet with fixed drawers versus flexible labeled bins. Schemas, document stores like MongoDB, key-value stores like Redis, and the real tradeoff between structure and flexibility: why banks choose SQL and social feeds choose NoSQL....
-
Episode 18: How Every App Asks Its Database a Question
Mia and Leo teach SQL — Structured Query Language — through a librarian who follows precise instructions. Select, filter, sort, and join: how apps ask database tables for exactly the data they need, and why a language from the 1970s still runs the modern internet. What question is your app asking...
-
Episode 17: The Library That Never Forgets
Mia and Leo open the doors on databases — software's long-term memory. Tables, rows, columns, and indexes explained through a library filing system, plus why a database beats a spreadsheet when ten thousand people show up at once. So what does a database actually store, and how does it find...
-
Episode 16: Why a Video From Tokyo Loads Instantly in Dallas
Mia and Leo explain content delivery networks (CDNs) through neighborhood warehouses: edge servers, origin servers, latency, caching at global scale, what gets cached, and why stale copies happen. Why does a video from the other side of the planet load instantly?
-
Episode 15: Why Your Apps Keep a Spare Copy of Everything
Mia and Leo explain caching through a kitchen counter versus pantry: browser cache, memory cache, stale data, cache expiration and invalidation, and why clearing your cache fixes stale pages. Why does the second visit to any app feel instant?
-
Episode 14: How Websites Remember You When They Have No Memory
Mia and Leo explain cookies, sessions, and logins through a coat-check ticket: how a tiny cookie lets a forgetful website remember you, why logging out destroys the session, what clearing cookies really does, and why a stolen ticket is a security risk. How does a site with no memory greet you by...
-
Episode 13: Every Click You Make Sends a Secret Form
Mia and Leo explain HTTP in plain English through a post-office form: request methods GET, POST, PUT, PATCH and DELETE, response status codes 200, 301, 404, 403 and 500, headers, and why HTTPS seals the envelope. What really happens when you click a link?
-
Episode 12: The Waiter Who Serves a Million Tables at Once
Mia and Leo explain APIs through a restaurant menu: endpoints, requests, parameters, API keys, and responses, with real examples from weather apps, Google login, and online payments. Why do apps order from each other's kitchens instead of cooking everything themselves?
-
Episode 11: The Dining Room and the Kitchen Behind Every App
Mia and Leo explain frontend vs backend through a restaurant: the dining room you see and touch, the kitchen doing the hidden work, and the A P I waiter running between them. What happens behind the swinging door when you tap order? Plus a teaser for tomorrow's deep dive on A P Is.
-
Episode 10: What Really Happens in the Second Before a Website Appears
Mia and Leo trace the journey from typing a URL to seeing a page — DNS address lookup, HTTP requests, servers, HTML, CSS, JavaScript, and status codes like 404 — through an ordering-a-package analogy. What four-step delivery happens every time a website loads?
-
Episode 9: The Tape Fix That Costs You Later
Mia and Leo explain technical debt: why software teams knowingly take shortcuts (like taping a leaky pipe before guests arrive), how refactoring pays it back, and why big apps slow down as the interest piles up. Can you name the difference between deliberate and careless debt after one listen?
-
Episode 8: Pilots Never Skip the Checklist. Neither Should Code
Mia and Leo explain automated testing through the pilot's pre-flight checklist: unit, integration, and end-to-end tests, why every code change gets a full safety check before it ships, and what even the best tests can't catch. What happens when teams skip the checklist to ship faster?
-
Episode 7: The Teaspoon That Cost 300 Million Dollars
Not all bugs are created equal. Mia and Leo break down the three kinds of bugs — syntax errors, runtime errors, and the silent, deadly logic error — and explain why computers amplify one tiny mistake into a catastrophe. Featuring the true story of the 1999 Mars Climate Orbiter, lost because two...
-
Episode 6: Never Rewrite the Original While the Kitchen Is Serving
Mia and Leo explain Git branches, pull requests, code review, merges, and merge conflicts through a restaurant kitchen's master recipe book — how engineers experiment safely and fold changes in without breaking the real thing. Why does a merge conflict mean the system is working?
-
Episode 5: Save Points for Code
Mia and Leo explain Git through a photo album for your code: commits as labeled snapshots, diffs as side-by-side comparisons, reverting as time travel to a working version, and why every project needs version control instead of folders named final-final. What's the difference between Git and...
-
Episode 4: The Translator Who Reads the Whole Book First
Mia and Leo explain compilers vs. interpreters: how source code becomes machine code, why compiled programs like phone apps run fast while interpreted languages like Python and JavaScript stay flexible, plus Java bytecode and just-in-time compilation. Which translator is quietly working inside…
more -
Episode 3: The Recipe Your Computer Can't Read
Mia and Leo crack open source code: the human-readable recipe behind every app and website, why engineers write recipes instead of ones and zeros, and how translators turn those recipes into machine code your phone can run. Plus a peek at tomorrow's deep dive into compilers versus interpreters....
-
Episode 2: Why Talking to a Rubber Duck Fixes Your Code
Mia and Leo unpack the debugging mindset: the rubber duck technique, reproducing bugs, reading error messages, divide-and-conquer with binary search, logging breadcrumbs, and breakpoints that freeze time. The developer's guide to finding bugs — plus why debugging is a life skill, not just a…
more -
Episode 1: What a Software Engineer Actually Does
Mia and Leo kick off SWE with the plain-English basics: debugging, Git, A P Is, databases, testing, and deployment. The eighty percent of software engineering beyond writing code.
-
SWE Trailer: Software Engineering for the Rest of Us
A 60-second intro to SWE: one software engineering concept a day, explained in plain English. New episodes every morning.
About this show
SWE: Software engineering, explained like you're smart but brand new. Two hosts, one big idea a day, zero jargon left unexplained. If you've ever nodded along in a tech conversation you didn't understand, this is your show.
Hosted by
Arian Zargaran
Categories