Listen on the go

323 episodes, about 64 hours. Nadia, a senior engineer, talks every lesson through with Imran, a product manager. Your device reads them in two voices; the player keeps going while you move between pages and plays the next episode when one ends.

How the Web Works

6 episodes, 78 min
  1. Planning before opening dayWhat system design really is13 min
  2. Where two seconds really goWhat happens when you open an app or website13 min
  3. Couriers, loudspeakers and locked doorsNetworking you actually need13 min
  4. The waiter who never brings it twiceAPIs done right13 min
  5. Four counters or fortySpeed numbers and back-of-the-envelope math13 min
  6. The bus that is late once a weekMeasuring speed and reliability: p99, SLOs and nines13 min

SQL & Data Modeling

6 episodes, 77 min
  1. The ledger and the back pageModeling data in tables14 min
  2. One precise question to the databaseSQL you'll actually use12 min
  3. Four pages out of forty-one thousandIndexes from the inside14 min
  4. The rider's GPS trace for queriesReading query plans and fixing slow queries12 min
  5. Two shops, one last cartonTransactions, ACID, isolation and locks12 min
  6. Building the new shelf beside the oldChanging the schema without downtime13 min

Databases at Scale

6 episodes, 81 min
  1. Thirty volumes on one shelfPartitioning big tables14 min
  2. The copy that is always a little behindReplication and read replicas13 min
  3. Opening a fourth DC without chaosSharding and consistent hashing14 min
  4. Rewind to the minute before the mistakeBackups and disaster recovery14 min
  5. Cashiers, yoghurt and the storeroom keyRunning Postgres in production13 min
  6. Rice does not go in the freezerBeyond SQL: choosing the right data store13 min

Scaling Building Blocks

7 episodes, 96 min
  1. Open more counters, not a faster cashierScaling up vs scaling out13 min
  2. The floor manager at the front doorLoad balancers14 min
  3. The front shelf next to the counterCaching14 min
  4. The warehouse, the store and the photoFiles, object storage and CDNs14 min
  5. Tickets on the kitchen railQueues, background jobs and pub/sub14 min
  6. The guard at the store doorRate limiting and protecting your system14 min
  7. Is my order ready yet?Real-time updates: polling, WebSockets, SSE and push13 min

Distributed Systems

5 episodes, 63 min
  1. Sell the last carton, or refuse?CAP, PACELC and consistency14 min
  2. When the SMS gateway freezes checkoutFailure is normal: timeouts, retries, backoff and circuit breakers12 min
  3. Supermarket or shopping mall?Monolith, modular monolith, microservices13 min
  4. The note on the ledger pageEvents, the outbox pattern and sagas12 min
  5. Six handscanners and no signalOffline-first apps and data sync12 min

Running Software in Production

3 episodes, 39 min
  1. Sales report, receipts and CCTVObservability: logs, metrics and traces13 min
  2. One number changed in a URLSecurity essentials13 min
  3. Pilot stores and a recall planShipping safely: containers, CI/CD and releases13 min

System Design Case Studies

4 episodes, 55 min
  1. The walk before opening dayRunning a design review14 min
  2. Token 47 and the receipt next doorCase study: a URL shortener13 min
  3. Numbered envelopes from every storeCase study: syncing POS sales from hundreds of stores14 min
  4. The last fifty cartons on festival eveCase study: ordering without overselling stock14 min

Inside the Tech Giants

10 episodes, 119 min
  1. Waiting for the slowest store managerGoogle Search: crawling, indexing and answering in a fraction of a second14 min
  2. Two hundred misses and one late readerFacebook: the social graph, TAO and memcache at planet scale13 min
  3. Crates, stickers and twenty-five thousand followersInstagram: from 3 engineers on Postgres to a billion users13 min
  4. The clerk who never reads the lettersWhatsApp: billions of messages with a tiny team12 min
  5. Hexagons, rings and the taxi standUber: matching riders and drivers in real time11 min
  6. A basket that says yes, a stock count that never liesAmazon: the store that never closes11 min
  7. Rice in the back room, films in the ISPNetflix: streaming to every screen12 min
  8. One oven, eight hundred million customersChatGPT: serving a large language model to hundreds of millions11 min
  9. Same biryani, three kitchensClaude: how Anthropic serves Claude at scale11 min
  10. The mall, the corner shop and the ladderWhat the giants share, and what not to copy11 min

Your Developer Setup

4 episodes, 50 min
  1. From a line of code to the storeHow code becomes a running program14 min
  2. Talking to the store manager directlyThe terminal without fear13 min
  3. The cashier who never searchesVS Code essentials12 min
  4. One shelf label for every storeVS Code for teams: formatting, linting and shared settings11 min

Git from the Inside

7 episodes, 77 min
  1. A photo album of the shop floorWhat Git really is: snapshots and the three areas11 min
  2. The shop diary nobody readsEveryday Git: status, diff, log and good commits10 min
  3. One aisle, one label, one mergeBranches and merging12 min
  4. Two notes for one price tagMerge conflicts without panic12 min
  5. Drafts you can edit, reports you can'tRewriting history safely: rebase, squash, cherry-pick, stash11 min
  6. Pencil, correction note, or the binUndo anything: restore, reset, revert and reflog10 min
  7. Fingerprints on every cartonInside the .git folder: objects, refs and HEAD11 min

GitHub for Teams

7 episodes, 77 min
  1. Head office ledger, store copiesGitHub: remotes, clone, push, pull and authentication10 min
  2. The second pair of eyes on every changePull requests and code review13 min
  3. One main road, short side lanesBranching strategies, releases and versions12 min
  4. Cards that move themselvesPlanning on GitHub: issues, labels and Projects11 min
  5. The checker at the DC gateGitHub Actions: continuous integration11 min
  6. Who holds the key to the cash roomDeploying and securing with GitHub Actions10 min
  7. Following the paper trail in GitReading code like a detective10 min

JavaScript Deep Dive

8 episodes, 101 min
  1. Eight falsy values and a free discountJavaScript in one sitting13 min
  2. The cash drawer that remembers its floatFunctions, scope and closures12 min
  3. Two keys to one storeroomObjects, arrays and references12 min
  4. The sale that happened yesterdayWorking with data: arrays, Maps, JSON, dates and money13 min
  5. One company manual, many local rulesPrototypes, classes and modules11 min
  6. One cashier and the priority tokensThe event loop13 min
  7. Order numbers, deadlines and the forEach trapAsync JavaScript: callbacks, promises and async/await14 min
  8. A total of NaN and the test that stops itErrors, debugging and testing13 min

JavaScript in the Real World

6 episodes, 73 min
  1. The shop window and the CORS gatekeeperJavaScript in the browser13 min
  2. The order form, the GRN and the caretNode.js and npm12 min
  3. Labels on every carton, gone by runtimeTypeScript for a JavaScript team12 min
  4. From home kitchen to busy restaurantFrom script to service: a small API in Node11 min
  5. The cache that never forgotPerformance and memory in JavaScript13 min
  6. Check every carton at the gateSecurity and quality in JavaScript projects12 min

React for the Web

6 episodes, 74 min
  1. Plan, compare, swap: how React redrawsComponents, props and how React renders11 min
  2. One home for every numberState, effects and where data should live12 min
  3. Skeletons first, stock list secondLoading server data13 min
  4. One crate, one write-offForms that people can trust13 min
  5. The ramp, the shelf labels and the slow phoneAccessible, fast pages12 min
  6. The mystery shopper in your test suiteTesting React like a user13 min

Building APIs with Node.js

6 episodes, 75 min
  1. The rejection slip everyone can readDesigning an API people can use13 min
  2. The gate, the clerk and the pickerYour first NestJS service12 min
  3. Two orders, one credit limitData with PostgreSQL and Prisma13 min
  4. The shelf check that stops leaksWho are you and what may you do?11 min
  5. The ticket number that stops double ordersBackground jobs and idempotency13 min
  6. Bake it in the real ovenTesting and documenting the API13 min

Ship a Project End to End

3 episodes, 33 min
  1. One app, from issue to hotfixProject: ship a small app end to end11 min
  2. Rules your team only argues onceYour team's engineering playbook10 min
  3. The fast new hire who never sleepsWorking with AI coding assistants12 min

Software Development: Idea to App

7 episodes, 90 min
  1. One page before the first line of codeFrom idea to one-page spec13 min
  2. Tape on the floor, cards on the counterScreens and flows13 min
  3. The order book behind three tapsData model and API13 min
  4. One tap, one order, one bar of signalBuilding the app13 min
  5. Forty tests and one missing priceTesting what matters13 min
  6. Same recipe card, every shopContinuous delivery13 min
  7. Ten shops, two weeks, one honest decisionLaunch and learn12 min

Product Thinking Foundations

4 episodes, 46 min
  1. Who decides where the bus goesWhat a product manager actually does12 min
  2. Diagnosis before prescriptionProblems before solutions11 min
  3. The lunch box testUsers, customers and stakeholders11 min
  4. Four questions before the griddleHow products create value12 min

Product Discovery

5 episodes, 48 min
  1. The question your mother can't foolUser interviews that don't lie10 min
  2. Fifty-one minutes, not twentyWatching the work10 min
  3. Two hundred receipts and an eager AIFrom research to opportunities9 min
  4. A sore wrist and a bag of orangesTesting ideas cheaply9 min
  5. Nobody moves into the bakeryPrototyping with AI10 min

Strategy, Priorities & Roadmaps

5 episodes, 55 min
  1. The corner shop that stopped fighting on priceVision, strategy and why now12 min
  2. Why ship it is a terrible key resultOKRs and outcome goals11 min
  3. How the loudest person quietly winsPrioritisation that survives the meeting10 min
  4. Sixteen features, four outcomes, one honest forecastOutcome roadmaps10 min
  5. The cheapest quote and the five-year billBuild, buy or partner12 min

From Spec to Launch

6 episodes, 70 min
  1. Write the launch announcement firstWriting specs people read11 min
  2. Three taps, three credit notesUser stories and acceptance criteria11 min
  3. Review the screen in the doorwayDesign for PMs11 min
  4. Ranges, throughput and the waterproofing ruleWorking with engineers11 min
  5. The skylight, the snag list and the keysWorking with vendors and agencies13 min
  6. Soft opening first, then the cityLaunching: pilots, waves and the review after13 min

Metrics & Product Analytics

6 episodes, 63 min
  1. One number, and the soil beneath itNorth star, input and guardrail metrics12 min
  2. The festival that faked our adoptionFunnels, activation and adoption11 min
  3. Our best sign-up week, and its worst cohortRetention and cohorts10 min
  4. The receipt that arrived the next morningInstrumentation: tracking plans and data you can trust10 min
  5. Flip a coin before you take the creditExperiments: A/B tests, holdouts and store pilots10 min
  6. Check the thermometer before you treatMetric reviews that change decisions10 min

The Business of Product

4 episodes, 48 min
  1. Busy, popular and losing moneyUnit economics: does each order make money?12 min
  2. Your forty hours, and do you believe themBusiness cases a managing director will sign13 min
  3. Who signs up first for free deliveryPricing and packaging12 min
  4. One neighbourhood before the whole cityMarketplaces, platforms and moats11 min

Growth & Adoption

4 episodes, 46 min
  1. Count the regulars before the bannersProduct-market fit before growth11 min
  2. Thirty minutes, really? Designing the first orderOnboarding and the first-time experience11 min
  3. The grocer who keeps a loaf asideEngagement loops, habits and notifications without dark patterns12 min
  4. Save the seed, plant one fieldGrowth loops and local go-to-market12 min

Internal Tools, Operations & Platforms

5 episodes, 58 min
  1. Five department heads and one teamProduct management for internal tools12 min
  2. A ticket rail for the receiving dockDesigning for frontline work11 min
  3. One article, one master, six copiesPlatforms, integrations and systems of record12 min
  4. Helpers at the bus stopChange management and adoption12 min
  5. Seven pm on a festival FridayRunning products in production11 min

Product Teardowns & Idea Lab

6 episodes, 62 min
  1. Tasting the rival's curryHow to break down any product10 min
  2. The shopkeeper's cash drawerTeardown: sending money with a mobile wallet11 min
  3. Why the nearest rider is wrongTeardown: ride-hailing and food delivery10 min
  4. The person nobody demos toTeardown: tools businesses run on10 min
  5. Pave the desire pathIdea lab: finding new software and feature ideas10 min
  6. Decide when to quit firstIdea lab: judging and pitching ideas11 min

AI Product Management

5 episodes, 54 min
  1. The temp who bills by the pageHow AI features work, just enough for PMs12 min
  2. Some AI ideas are spreadsheets in disguisePicking the right problems for AI10 min
  3. Signal lost, recalculatingDesigning AI features people can trust10 min
  4. The taster who passes everythingEvals: measuring AI quality11 min
  5. The keys to the safe, one drawer at a timeAI agents in operations11 min

Communication & Leadership

5 episodes, 56 min
  1. Put the ask in the first lineWriting for decisions11 min
  2. Twenty minutes with the managing directorExecutive updates and presentations11 min
  3. No new counting before the festivalStakeholders, negotiation and leading without authority11 min
  4. Fewer ideas, better reasonsBreaking into product: PM interviews11 min
  5. Learn before you change anythingGrowing as a PM12 min

Vibe Coding: Build Apps with AI

6 episodes, 74 min
  1. The beautiful app that saved nothingWhat AI coding tools can and cannot do12 min
  2. Why the AI guessed everyone could seeA spec the AI can follow13 min
  3. One shelf at a timeBuilding in small steps13 min
  4. The missing cent and the double riceReading and fixing what the AI wrote12 min
  5. Locks on every mailboxData and security basics12 min
  6. Five minutes to roll backShip it and know your limits12 min

LLM Apps: Prompts, RAG and Evals

6 episodes, 75 min
  1. The interpreter who forgets every callHow LLM APIs work13 min
  2. Peanut free, or just not mentioned?Prompts and structured output13 min
  3. The model asks, your code decidesTools and the Model Context Protocol12 min
  4. Finding the right page, and only that oneRetrieval-augmented generation12 min
  5. The gate that caught a nut-free promiseEvals: knowing if it got better13 min
  6. The leaflet that gave ordersCost, latency and safety12 min

AI Systems for Builders

1 episodes, 14 min
  1. The assistant manager and the SOP binderDesigning AI features: LLMs, RAG and vector search14 min

Building AI Agents

6 episodes, 75 min
  1. Recipe cards and tasting cooksWhat makes an agent12 min
  2. Forty cases of milk, approved onceDesigning tools and permissions12 min
  3. The old card left in the drawerRetrieval over procedures13 min
  4. The folder that survives the restartMemory, state and multi-step plans13 min
  5. Five runs, one red lightEvaluating agents12 min
  6. A float, a key and a till rollShipping an agent safely13 min

AI Engineering in Production

6 episodes, 69 min
  1. The ticket that follows every answerObservability for LLM systems11 min
  2. Nine days nobody noticedEvals that never stop10 min
  3. The switch nobody switched backCost and latency at scale12 min
  4. Price list, script or training coursePrompting, retrieval or fine-tuning?11 min
  5. The mystery shopper for your AIGuardrails and red-teaming13 min
  6. Who answers when the AI is wrongGovernance and accountability12 min

Data Analysis with Excel, Python & AI

7 episodes, 79 min
  1. Sales are down. Down compared with what?Asking a question data can answer12 min
  2. The seventy-seven million dollar sumCleaning data in a spreadsheet10 min
  3. Nine stores and two aislesPivot tables and summaries11 min
  4. The chart that made six percent a crashCharts that answer the question11 min
  5. From spreadsheet clicks to a recipeThe same analysis in Python12 min
  6. The confident answer that double countedAnalysing with an AI assistant12 min
  7. Five minutes to say yesTelling the story11 min

Statistics for Data Work

6 episodes, 67 min
  1. The basket nobody actually buysDescribing data honestly10 min
  2. One spoonful, forty stores, an honest rangeSamples, uncertainty and confidence intervals10 min
  3. What a p-value can and cannot sayHypothesis tests without the fog11 min
  4. Size it, check it, read it onceDesigning and reading an A/B test12 min
  5. How many minutes does rain add?Regression and correlation12 min
  6. Every number right, the story wrongTraps that fool smart people12 min

Dashboards and Business Intelligence

6 episodes, 73 min
  1. Three sales numbers and one grainFrom questions to a reporting model12 min
  2. The till that sold everything twiceTransforming data in the warehouse12 min
  3. Three sales numbers, one MondayMetrics everyone agrees on12 min
  4. Four tiles that end the Monday argumentDesigning a dashboard for decisions12 min
  5. The Monday forty stores sold nothingFresh, tested, trusted13 min
  6. Open shelves, locked rooms, regular weedingSelf-service without chaos12 min

Data Science and Machine Learning

6 episodes, 73 min
  1. One email, one decision, one pageFraming a problem as a model12 min
  2. The six percent that was never realFeatures and leakage12 min
  3. Why nine percent was a mirageTraining and comparing models12 min
  4. Why the average missed the festivalForecasting demand13 min
  5. Who gets the coupon, and did it workClassification and churn12 min
  6. Why the small stores still ran outExplaining and choosing models12 min

Machine Learning in Production

6 episodes, 74 min
  1. The night the notebook needed TomásFrom notebook to pipeline11 min
  2. Two recipes for one featureData and feature pipelines11 min
  3. Which model made that forecast?Experiments, versions and the model registry13 min
  4. Never order from half a runServing: batch and online13 min
  5. Fix the feed before the modelMonitoring, drift and retraining13 min
  6. Who answers for the empty shelfResponsible ML in a business13 min

TechOps: Linux, Networks and IT Operations

6 episodes, 73 min
  1. The store box that felt slowLinux from the command line12 min
  2. The script that never deletes the wrong fileShell scripting for daily jobs12 min
  3. Prices offline in store one forty-twoNetworks from the till to the data centre12 min
  4. The badge that still opens doorsAccounts, SSO and MFA12 min
  5. Pilot, gate, pause: updating every scannerLooking after 1,400 devices12 min
  6. Triage, root causes and the rollback triggerIncidents, problems and changes13 min

DevOps: CI/CD, Containers and Infrastructure as Code

6 episodes, 70 min
  1. The smoke alarm nobody unplugsContinuous integration that people trust12 min
  2. Hotel rooms, layers and the stop signalContainers from the inside13 min
  3. The probe that restarted everythingKubernetes for application teams11 min
  4. The drawing, the register and the planInfrastructure as code11 min
  5. Two tables taste the new curryReleasing safely12 min
  6. Seals, labels and honest delivery numbersSecure supply chain and delivery metrics11 min

Site Reliability Engineering

7 episodes, 85 min
  1. The data plan for failureHow reliable is reliable enough?12 min
  2. Finding the retry storm in minutesObservability with OpenTelemetry12 min
  3. The smoke alarm and the toastAlerting that does not burn people out12 min
  4. The head chef stays at the passLeading an incident13 min
  5. The morning after the outagePostmortems and learning12 min
  6. Rehearsing the festival rush on purposeCapacity, resilience and game days12 min
  7. Washing plates at machine speedToil and automation12 min

Database Administration with PostgreSQL

6 episodes, 72 min
  1. Clerks, notebooks and crossed-out labelsInside a PostgreSQL server12 min
  2. The drill that said four hoursBackups you have actually restored12 min
  3. Only one chef wears the hatReplication and failover13 min
  4. The query that costs the most in totalFinding and fixing slow queries12 min
  5. Badges, keyrings and the till drawerSecurity and access11 min
  6. Refits, flattened boxes and the 3 a.m. folderUpgrades, maintenance and on-call12 min

Software Testing and QA

6 episodes, 75 min
  1. The mechanic's hour before the festivalWhat testing is for13 min
  2. Why the bug sits at exactly twenty-five dollarsDesigning tests that find bugs11 min
  3. The receipt that was sent twiceExploratory testing12 min
  4. Standing at the kitchen passTesting APIs and data13 min
  5. Gloves, lifts and screen readersAccessibility, devices and the real world13 min
  6. The snag list and the keysBugs, reports and acceptance13 min

Test Automation and Quality Engineering

6 episodes, 74 min
  1. Tasting the sauce beats mystery dinersA test strategy, not a pile of scripts12 min
  2. One tap, one order, one chargeUnit and API tests12 min
  3. The mystery shopper who never sleepsEnd-to-end tests with Playwright13 min
  4. The app version still in your pocketContract tests12 min
  5. When the test slows down with youPerformance and load testing13 min
  6. The smoke alarm that cried wolfStable suites in CI12 min

Mobile Apps with React Native

6 episodes, 75 min
  1. Planner, shelves and a direct lineHow React Native works12 min
  2. Back to the same job, every timeNavigation and app structure12 min
  3. The clock icon in the basementOffline first13 min
  4. Ask at the door, not the gateDevice features12 min
  5. The ferry that never waitsFast on a cheap phone13 min
  6. Shelf labels and freezer aislesTesting and releasing13 min

Security Foundations

6 episodes, 69 min
  1. What a burglar sees in your storeThinking like an attacker13 min
  2. The email that was really from himHow breaches really happen12 min
  3. The key card and the front deskIdentity: passwords, MFA and passkeys10 min
  4. The padlock, the seal and the lost keyCryptography without the maths11 min
  5. Why a guest phone could reach the tillsNetworks, endpoints and the cloud11 min
  6. Seven in the morning, one ransom noteRisk, compliance and the first hour of an incident12 min

Application Security for Developers

6 episodes, 70 min
  1. One digit away from someone else's invoiceBroken access control12 min
  2. The apostrophe that broke the searchInjection and unsafe input12 min
  3. Key cards, wristbands and stolen tokensAuthentication, sessions and tokens11 min
  4. The download link that skipped the APIThreat modelling a feature12 min
  5. The code you ship but never wroteSupply chain and secrets12 min
  6. The smoke alarm and the polite assistantSecurity in the pipeline and in AI features11 min

Defensive Security: SOC, Detection and Response

6 episodes, 61 min
  1. A shift on the security deskInside a SOC10 min
  2. The camera you never pointedLogs that matter10 min
  3. Teach the system what an attack looks likeWriting detections10 min
  4. Is this real, how bad, what nextTriage and investigation10 min
  5. Looking for the attacker no rule caughtThreat hunting10 min
  6. The night an alert decides everythingIncident response11 min

Offensive Security: Ethical Hacking and Pentesting

6 episodes, 59 min
  1. The letter that keeps you out of jailEthics, law and scoping10 min
  2. What the street already knowsReconnaissance9 min
  3. Two accounts and one changed idAttacking web applications9 min
  4. Flagged is not confirmedAttacking networks and services11 min
  5. One cupboard key to the whole buildingPrivilege escalation and lateral movement10 min
  6. The report is the whole jobReporting that gets things fixed10 min

Software and Solution Architecture

7 episodes, 88 min
  1. The decisions that are hard to undoWhat architects actually do13 min
  2. From good and on time to numbersQuality attributes and constraints12 min
  3. The weight that flips the decisionChoosing an architecture style12 min
  4. One owner, many readers, no surprisesIntegration and data ownership12 min
  5. Paying for the area under the curveCloud architecture and cost13 min
  6. Maps, logbooks and smoke detectorsDecisions, diagrams and reviews13 min
  7. Rebuilding the kitchen during dinner serviceEvolving a legacy system13 min

Business and Enterprise Architecture

6 episodes, 65 min
  1. Fourteen projects, three goals, one mapWhy enterprise architecture exists10 min
  2. Where the board's money should goCapability maps11 min
  3. Three hours of work, twenty-five daysValue streams and processes10 min
  4. Two kettles, no bread knifeApplication portfolio11 min
  5. Pipes before the new kitchenTarget state and roadmap12 min
  6. The garden shed and the towerFrameworks and governance11 min

Business Analysis

6 episodes, 69 min
  1. Two requests, one hidden needWhat business analysts do11 min
  2. Five reasons hiding behind the phoneStakeholders and elicitation11 min
  3. Where a phone order spends its dayModelling processes12 min
  4. Why Payment declined was a rule problemRequirements that work12 min
  5. Thin slices and real examplesUser stories and acceptance criteria11 min
  6. The test nobody wrote for rep modeFrom change control to acceptance12 min

Finance for Tech Teams

6 episodes, 69 min
  1. 21 million profit, 2 in the bankThe three statements11 min
  2. The dollar eleven that wasn't realUnit economics12 min
  3. Eighteen roles that cost nine monthsBudgets, capex and opex11 min
  4. Who left the test servers on?Cloud and SaaS costs with FinOps12 min
  5. Nine percent from one depotBusiness cases12 min
  6. The year you pay twiceBuild, buy or outsource11 min

From Engineer to Tech Lead

6 episodes, 72 min
  1. The captain who still playsWhat a tech lead is (and is not)12 min
  2. One page of direction, one decision at a timeTechnical vision and design docs12 min
  3. Thin slices and honest rangesSlicing and planning work12 min
  4. Hand over the wheel, one road at a timeDelegation and mentoring12 min
  5. Putting a price on the broken oven doorQuality, debt and AI tools12 min
  6. Three leads, one answerLeading with product and management12 min

Engineering Management

6 episodes, 71 min
  1. Stop scoring goals, start coachingThe manager's job11 min
  2. The meeting that belongs to them1:1s, feedback and coaching12 min
  3. Write the score before you talkHiring well11 min
  4. Evidence, ladders and a curious first questionPerformance and growth12 min
  5. Where the work waitsTeam design and delivery health13 min
  6. No surprises, real options, honest noManaging up and across12 min

Leading a Tech Department: Head of Engineering to CTO

7 episodes, 79 min
  1. From one kitchen to fiveThe department head's job12 min
  2. Fourteen priorities is not a strategyTechnology strategy12 min
  3. Boxes, spans and the weekly rhythmOrganisation and operating model12 min
  4. Sixteen million dollars and a notice deadlineMoney: budgets, headcount and vendors10 min
  5. Who owns the risk on Saturday nightRisk, security and compliance11 min
  6. Stop counting the licencesLeading AI adoption10 min
  7. Twenty minutes with the boardThe board and the executive team12 min