Modern Web

In this episode of the Modern Web Podcast, Rob Ocel talks with PlanetScale CEO Sam Lambert about what “database scale” actually looks like in 2026. Sam shares migration stories from companies that moved at the perfect time and others that waited until they were already in trouble, plus why sharding and reliability are never just “magic” if your queries and data model are a mess.

They also cover PlanetScale’s evolution beyond its MySQL and Vitess roots into Postgres, Metal, and what’s coming next for sharding in the Postgres world. Along the way, they connect the dots to AI workloads, which are increasingly write heavy and put new pressure on performance, uptime, and security.

What You'll Learn:

- How to spot the “right time” to migrate databases before you’re on fire (and what happens when you wait too long)

- What PlanetScale actually gives you “for free” at scale, and what it can’t fix (bad schema, missing indexes, terrible SQL)

- Why “auto” database magic is usually a tradeoff, and what to ask for when you want to peek behind the curtain

- What PlanetScale is becoming beyond MySQL/Vitess, including Postgres, Metal, and Nikky (sharding for Postgres)

- How AI workloads are changing database patterns, especially the shift toward write heavy systems and why that pressures reliability and security

Environment variables and secrets are usually a mess: out of sync .env files, scattered API keys, painful onboarding, and brittle CI configs. In this episode of the Modern Web Podcast, Rob Ocel talks with Varlock co-creators Phil Miller and Theo Ephraim about how Varlock turns .env files into a real schema with types, validation, and documentation, pulls secrets from tools like 1Password and other backends, and centralizes configuration across environments and services. They also dig into protecting secrets in an AI-heavy world by redacting them from logs and responses, preventing accidental leaks from agents, and pushing toward an open env-spec standard so configuration becomes predictable, portable, and actually pleasant to work with.

What you will learn:

- Why traditional .env files and copy paste workflows break down as teams, services, and environments grow.

- How Varlock turns environment variables into a schema with types, validation, documentation, and generated TypeScript.- How to pull secrets from tools like 1Password and other backends without leaving them in plain text or scattering them across dashboards.

- How to manage multiple environments such as development, staging, and production from a single, declarative configuration source.

- How Varlock helps protect secrets in AI and MCP workflows by redacting them from logs and responses and blocking accidental leaks.

- What the env spec standard is and how a common schema format can make configuration more portable across tools, templates, and platforms.

In this Modern Web Podcast, Rob Ocel and Danny Thompson break down the recent string of NPM supply chain attacks that have shaken the JavaScript ecosystem. They cover the NX compromise, the phishing campaign that hit libraries like Chalk, and the Shy Halood exploit, showing how small changes in dependencies can have massive effects. Along the way, they share practical defenses like using package lock and npm ci, avoiding phishing links, reviewing third party code, applying least privilege, staging deployments, and maintaining incident response plans. They also highlight vendor interventions such as Vercel blocking malicious deployments and stress why companies must support open source maintainers if the ecosystem is to remain secure.

Key Points from this Episode:

- Lock down installs. Pin versions, commit package-lock.json, use npm ci in CI, and disable scripts in CI (npm config set ignore-scripts true) to neutralize post-install attacks.

- Harden people & permissions. Phishing hygiene (never click-through emails), 2FA/hardware keys, least-privilege by default, and separate/purpose-scoped publishing accounts.

- Stage & detect early. Canary/staged deploys, feature flags, and tight observability to catch dependency drift, suspicious network egress, or monkey-patched APIs fast.

- Practice incident response. Two-hour containment target: revoke/rotate tokens, reimage affected machines, roll back artifacts, notify vendors, and run a post-mortem playbook.

In this episode of the Modern Web Podcast, Rob Ocel and Danny Thompson talk with Wes Eklund from AWS ProServe about interviews, practical AI, and the future of developer workflows. Wes shares what trips candidates up in coding and behavioral rounds, how to ask better questions, and why prepping multiple honest STAR narratives matters. Danny introduces the Thrive Framework for behavioral interviews and Rob underscores the discipline required to stand out in a crowded market. The trio then digs into 100 Days of Code in the AI era, smart ways juniors can learn with AI, and how Wes’s team uses MCP servers and Amazon Q to speed design, onboarding, and day-to-day delivery. They cover the lull in MCP hype, real security concerns, the “80 percent is a win” mindset when AI accelerates work, and when it actually makes sense to build agents. They close on thin, purpose-built agents, enterprise adoption patterns, and why frameworks like DSPy could reshape moats and costs.

Key Takeaways from this episode:

- Wes explains how candidates often fail because they neglect behavioral prep, and Danny introduces the Thrive Framework as a system to stand out.

- The group debates whether juniors should use AI. Wes frames it as a tool for strategy and reflection, not a shortcut, while Danny emphasizes using it to deepen knowledge and accountability.

- Wes shares how his AWS team leverages MCP servers and Amazon Q to speed design, boost onboarding, and solve problems faster, while Danny highlights enterprise-level use cases like multilingual documentation.

- They discuss whether developers should build agents, the risks of security gaps, and how frameworks like DSPy could make optimized, lightweight agents a new competitive edge.

Chapters

0:00 MCP servers: security reality check

0:33 Modern Web Podcast intro

0:55 Guest: Wes Ecklan (AWS ProServe)

2:02 Job hunt & interview mistakes

5:05 Danny’s THRIVE framework

7:39 Researching values & STAR stories

11:12 Sponsor + quality & discipline in applications

13:04 100 Days of Code in the AI era

18:03 Using AI at work (MCP + Amazon Q)

23:13 Hackathons & making time to innovate

25:06 MCPs in practice: adoption & security

36:00 Agents: when they help vs. hype — close & links

Rob Ocel and Danny Thompson sit down with Andy Bell to treat CSS as a craft, not a chore. Andy explains why he mentors the browser instead of micromanaging it, how progressive enhancement keeps products resilient, and which modern features deserve attention right now, including has, anchor positioning, and clamp. The conversation gets practical on grid versus flexbox, why grid is often simpler than people think, and how ecosystems and tooling skew usage. They unpack the real reasons Tailwind spread across teams, where it helps with speed and onboarding, and why core CSS skills plus a clear methodology prevent long-term debt. Expect candid consultancy stories, smarter debugging with today’s devtools, and a reminder that play, standards knowledge, and strong communication habits lead to cleaner, more maintainable front ends.Key Takeaways:- Andy Bell stresses mentoring the browser instead of micromanaging it, leaning on progressive enhancement and letting it adapt to context.- Features like :has(), anchor positioning, and clamp are changing how developers approach layouts, interactions, and responsive design.- Despite its power, Grid hasn’t caught on like flexbox, partly due to ecosystem and tooling choices. Andy suggests learning grid first for a clearer foundation.- Tailwind solves organizational and onboarding challenges, but without solid CSS fundamentals and consistent methodologies, teams risk piling up technical debt.

In this episode of the Modern Web Podcast, Rob Ocel and Danny Thompson are joined by Rishab Kumar, Staff Developer Evangelist at Twilio, to explore the evolving landscape of voice and AI interactions. They discuss the rise of conversational AI, how voice interfaces are becoming the natural medium for human-computer interaction, and the tools and best practices for integrating AI into real-world applications. Rishab shares insights from Twilio on building voice-enabled AI experiences, tackling challenges like latency and prompt design, and how AI is shaping the future of productivity and problem-solving. The conversation also highlights community-focused events, like the upcoming Commit Your Code Conference in Dallas, where networking, learning, and giving back to charity take center stage.

Key Takeaways:

- Voice interfaces are becoming more natural and conversational, moving beyond simple commands to context-aware, agentic interactions that can assist with tasks in real time.

- AI is being integrated into real-world use cases, from coding assistants and productivity tools to hands-on guidance for tasks like furniture assembly, car troubleshooting, and lab work.

- Platforms like Twilio provide APIs, Conversation Relay, and integrations with voice models to streamline AI voice interactions, handling challenges like latency, speech-to-text, and interruption management.

- There’s a growing need for specialized, reliable AI tools tailored to specific industries and tasks, as well as careful consideration of ethical implications, user trust, and contextual accuracy.

In this episode, Rob Ocel and Danny Thompson enjoy a conversation with Kilian Valkhof, founder of Polypane, a browser built for developers who care deeply about their craft. The discussion explores the shifting landscape of online developer communities as conversations migrate from Twitter to Blue Sky, Mastodon, Discord, and local meetups. Kilian shares how this decentralization has shaped advocacy around accessibility, performance, and front-end principles, while Rob and Danny reflect on what developers lose and gain when there’s no longer a single central hub. They also dig into guiding principles for building quality front-end experiences, from usability and accessibility to balancing trade-offs between performance, readability, and SEO.

Key points from this episode

- Developers are finding their communities scattered across Blue Sky, Mastodon, Discord, and meetups, changing how ideas about accessibility and performance spread.

- Practical frameworks like “rule of three” and “make it run, make it right, make it fast” give developers clearer guidance than vague advice such as “don’t repeat yourself.”

- Building with craft means going beyond visual accuracy to include accessibility, usability, and small details that improve the overall user experience.

- Teams need to agree on priorities so they can navigate trade-offs between things like accessibility, performance, SEO, and readability.

In this episode of the Modern Web Podcast, Rob Ocel and Danny Thompson talk with Philipp Krenn, Head of Developer Advocacy at Elastic, about how Elasticsearch has evolved from a search engine into a foundation for observability, security, and AI-powered systems. Philipp explains how Elastic approaches information retrieval beyond just vector search, using tools like LLMs for smarter querying, log parsing, and context-aware data access.

They also discuss how Elastic balances innovation with stability through regular releases and a focus on long-term reliability. For teams building with AI, Elastic offers a way to handle search, monitoring, and logging in one platform, making it easier to ship faster without adding complexity.

Key points from this episode:

• Elasticsearch has expanded beyond search to support observability and security by treating all of them as information retrieval problems.

• Elastic integrates with AI tools like LLMs to improve search relevance, automate log parsing, and enable features like query rewriting and retrieval-augmented generation.

• Vector search is just one feature in a larger toolkit for finding relevant data, and Elastic supports hybrid and traditional search approaches.

• Elastic maintains a steady release cadence with a focus on stability, making it a reliable choice for both fast-moving AI projects and long-term production systems.

In this episode of Modern Web, Danny Thompson chats with MelkeyDev, a Machine Learning Infrastructure Engineer at Twitch, about AI’s real-world applications, developer productivity, and the future of careers in Go.

They cover everything from the rise of tiny AI-driven teams competing with large enterprises to how system prompts may matter more than model choice. Melkey shares his thoughts on cost-effective LLMs, production pitfalls, and the cognitive downsides of over-relying on AI. The conversation also explores backend development with Go, what makes it great for fast-moving teams, and how new developers can get started.Keypoints from this episode:- AI’s real value lies in business use cases. Melkey emphasizes that AI isn’t just a productivity tool; it enables small teams to build faster, cheaper, and more effectively than ever before.

- System prompts are underrated. When it comes to LLM performance, prompt engineering often matters more than the model itself, especially for UI generation and agent design.

In this episode of the Modern Web Podcast, hosts Rob Ocel and Danny Thompson sit down with Andre Landgraf, Senior Developer Advocate at Neon (now part of Databricks), to explore the evolving role of AI agents in developer workflows. They discuss how more Neon databases are being spun up by agents than humans, what that means for developer and agent experience (DX vs AX), and how tools like MCP and step functions are enabling scalable agent orchestration.

On this episode of the Modern Web Podcast, Rob Ocel and Danny Thompson talk with Brian Morrison, Senior Developer Educator at Clerk. They cover the state of authentication today, what makes Clerk stand out for small teams and indie builders, and how thoughtful developer experience design can make or break adoption.Brian shares why bundling tools like auth, billing, and user management is becoming more common, how Clerk handles real-world concerns like bot protection and social login, and why starting with a great developer experience matters more than ever.The conversation also explores the role of AI in software development and content creation, where it helps, where it hurts, and how to use it responsibly without losing quality or trust.Keypoints for this Episode:

• Modern auth is about experience, not just security. Clerk simplifies user management, social login, bot protection, and subscription billing with developer-friendly APIs and polished default UIs.

• Bundled platforms are making a comeback. Developers are shifting from handpicking tools to using tightly integrated services that reduce setup time and complexity.

• Developer education needs more care and creativity. Brian emphasizes the importance of visual storytelling, thoughtful structure, and anticipating confusion to help devs learn faster and retain more.

• AI is a productivity multiplier, not a replacement. The group discusses how AI can accelerate development and content creation when used with oversight, but warn against using it to blindly build entire apps.

On this episode of the Modern Web Podcast, hosts Rob Ocel, Danny Thompson, and Adam Rackis are joined by Tejas Kumar, host of The Contagious Code podcast, author of Fluent React, and Developer Relations Engineer for Generative AI at DataStax. They unpack the current wave of AI announcements from Google I/O and Microsoft Build, and zoom in on the significance of MCP (Model Context Protocol) as a foundational shift in how AI-powered apps will be built and used.

Tejas breaks down what MCP is, why it's catching on across the industry, and how it could become the HTTP of AI apps. The group explores real-world examples, like AI apps managing your inbox or booking flights without ever opening a browser, and discuss how MCP servers enable secure, agent-driven experiences that can act on your behalf. They also touch on hallucinations, the role of fine-tuning vs. tool integration, and the future of checkout flows powered by AI agents.

Keypoints from this Episode:

- MCP enables structured communication between AI apps and servers, allowing agents to perform real tasks like sending emails or booking flights

- Users will increasingly interact with applications through natural language, with agents handling workflows behind the scenes

- Connecting models to tools via MCP helps reduce hallucinations by ensuring actions and responses are grounded in real data

- Most use cases benefit more from retrieval-augmented generation and strong tool integration than from expensive model fine-tuning

Follow Tejas on Social Media

In this episode of the Modern Web Podcast, Danny Thompson sits down with Reed Harmeyer, CTO of Skylight Social, and Brandon Mathis, React Native engineer at This Dot Labs. They unpack the technical and strategic decisions behind Skylight’s meteoric growth: why they built on the AT Protocol, how they tackled video discovery and scaling challenges, and how a fast-tracked in-app video editor gave them an edge.

Keypoints from this episode:

• Skylight Social was built on the AT Protocol, allowing users to retain followers across platforms like Blue Sky and enabling creators to publish interoperable content in a decentralized social network.

• The team used React Native with Expo to achieve rapid development and cross-platform performance—launching a high-quality, TikTok-like video experience in just days.

• An in-app video editor was prioritized to reduce friction for creators, built using a native SDK wrapped with Expo Modules, enabling features like clip rearranging, overlays, voiceovers, and AI-generated captions.

• User behavior data—specifically watch time—drives content recommendations, not just likes or follows, helping Skylight offer a personalized experience while navigating scaling challenges from hypergrowth.

Follow Reed Harmeyer on Social Media

In this episode of the Modern Web Podcast, Rob Ocel and Danny Thompson sit down with Julián Duque, Principal Developer Advocate at Heroku, to talk about Heroku’s evolution into an AI Platform-as-a-Service. Julián breaks down Heroku’s new Managed Inference and Agents (MIA) platform, how they’re supporting Claude, Cohere, and Stable Diffusion, and what makes their developer experience stand out.

They also get into Model Context Protocols (MCPs)—what they are, why they matter, and how they’re quickly becoming the USB-C for AI. From internal tooling to agentic infrastructure and secure AI deployments, this episode explores how MCPs, trusted environments, and better AI dev tools are reshaping how we build modern software.

Key Points from this episode:

- Heroku is evolving into an AI Platform-as-a-Service with its new MIA (Managed Inference and Agents) platform, supporting models like Claude, Cohere, and Stable Diffusion while maintaining a strong developer experience.

- MCPs (Model Context Protocols) are becoming a key standard for extending AI capabilities—offering a structured, secure way for LLMs to access tools, run code, and interact with resources.

- Heroku's AI agents can perform advanced operations like scaling dynos, analyzing logs, and self-healing failed deployments using grounded MCP integrations tied to the Heroku CLI.

- Despite rapid adoption, MCPs still have rough edges—developer experience, tooling, and security protocols are actively improving, and a centralized registry for MCPs is seen as a missing piece.

Chapters

0:00 – What is MCP and why it matters

3:00 – Heroku’s pivot to AI Platform-as-a-Service

6:45 – Agentic apps, model hosting, and tool execution

10:50 – Why REST isn’t ideal for LLMs

14:10 – Developer experience challenges with MCP

18:00 – Hosting secure MCPs on Heroku

23:00 – Real-world use cases: scaling, healing, recommendations

30:00 – Common scaling challenges and hallucination risks

34:30 – Testing, security, and architecture tips

36:00 – Where to start and final advice on using AI tools effectively

In this episode of the Modern Web Podcast, Rob Ocel and Danny Thompson talk with Hannes Rudolph, Community Manager at RooCode, to explore how this fast-moving, community-driven code editor is rethinking what AI-assisted development looks like. Hannes breaks down Roo’s agentic coding model, explains how their “boomerang tasks” tackle LLM context limits, and shares lessons from working with contributors across experience levels.

Keypoints from this episode:

- RooCode's "boomerang" architecture breaks complex coding tasks into structured, recursive subtasks, helping AI agents stay focused while avoiding context bloat and hallucination chains.

- Developers can build their own orchestrator and agent modes in Roo, tailoring persona and instructions to fit specific workflows—crucial for long-term productivity.

- Unlike many tools, RooCode shows developers exactly how much each LLM call costs in real time, empowering teams to manage both quality and budget.

- RooCode is deeply community-driven, with user-submitted PRs frequently reshaping priorities. The team emphasizes transparency, collaboration, and accessibility for contributors at all levels.

In this episode of the Modern Web Podcast, Rob Ocel is joined by Danny Thompson, Adam Rackis, and special guest Coston Perkins for a lively discussion on the evolving role of AI in software development. The group swaps thoughts on everything from the rise of AI agents like RooCode and Claude, to what makes tools like Vercel’s v0 surprisingly powerful for frontend work.

In this episode of the Modern Web Podcast, host Danny Thompson and co-host Adam Rackis chat with James Perkins, CEO of Unkey, an open-source API management platform built for scale, security, and developer simplicity. James shares the challenges of building globally distributed infrastructure, and why his team ditched serverless and TypeScript in favor of Go and servers.

They talk candidly about the realities of API management at scale, how Unkey balances open source transparency with enterprise-grade performance, and what it takes to build developer trust—both as a brand and as a product.

Keypoints from this episode

• Unkey simplifies API management by acting as middleware for authentication, rate limiting, and security—without requiring deep backend expertise. It's designed for developers to go from idea to production with minimal setup.

• Go over serverless – James and his team initially explored TypeScript and serverless architecture but ultimately returned to Go and servers for better performance, scalability, and developer experience at scale.

• Open-source transparency is core to Unkey’s philosophy – The entire codebase is public, and the team maintains a radically open company culture, where even investor updates and customer support emails are shared internally.

• Customer obsession drives every decision – Regardless of whether a user is paying $0 or $2,000/month, Unkey responds quickly, prioritizes community support, and encourages a culture of ownership and responsiveness across the team.

Chapters

00:00 – Intro + Why Unkey exists
02:00 – James' background and API pain points
03:50 – What Unkey actually does
05:45 – Engineering challenges + scaling architecture
07:30 – Tech stack changes: Go, TypeScript, Serverless
08:45 – Unkey as middleware: auth, rate limiting, analytics
10:40 – Future vision: making APIs as easy as deploying on Vercel
11:45 – Why Go instead of Node or TypeScript
13:30 – Go vs TypeScript: hiring, dependencies, developer experience
15:00 – Why API management is hard at scale
17:15 – Case study: Fireworks and Google Apigee performance issues
19:00 – The complexity of modern API platforms
20:00 – Sponsor break: This Dot Labs
20:35 – Will Unkey expand into app hosting?
22:00 – Unkey's focus on doing one thing really well
23:45 – Content strategy: personal brand vs corporate marketing
26:20 – Customer obsession: internal culture and open company model
30:30 – Open source dynamics and being fully transparent
33:45 – Advice for developer-entrepreneurs
36:24 – Wrap up + where to find the speakers

Follow James Perkins on Social Media

In this episode of the Modern Web Podcast, Rob Ocel and Danny Thompson get real about the current state of AI in software development. They talk about what’s working, what’s frustrating, and why so much of the conversation around AI feels repetitive or disconnected from reality. They explore how AI is actually being used day to day—and where it still falls short.

They also discuss the risks of relying too heavily on AI, especially for junior devs, and why understanding fundamentals still matters.

Keypoints from this episode:

- AI fatigue is setting in among developers, with many eager to move beyond hype and explore tools that solve real problems and deliver everyday value.

- Danny built a conversational AI agent named Nexie, trained specifically on Next.js and Vercel documentation, showing how personalized agents can provide focused, meaningful assistance.

- Over-relying on AI can backfire for junior developers. Using it to generate code without understanding the underlying logic undermines learning and growth.

- AI tools are starting to shift how we think about software quality. In some cases, speed and cost-effectiveness may outweigh traditional goals like maintainability.

Chapters

00:00 – Should Juniors Use AI?

01:04 – Real Talk on AI Conferences

03:00 – Building Nexi: A Personal Dev Agent

05:13 – Beyond the Hype: Finding Real AI Use Cases

09:36 – Why Senior Devs Struggle with AI Tools

15:55 – Mentorship, Theory, and Learning the Right Way

21:10 – When to Use AI (and When Not To)

26:50 – The Growing Gap in Dev Skills

30:31 – AI Is Redefining “Good Software”

32:09 – Final Thoughts + Where to Find Us

Join hosts Rob Ocel and Danny Thompson for another episode of the Modern Web Podcast, where they sit down with Brad Garropy, senior front-end engineer at Stripe, YouTuber, and all-around tech enthusiast.

Brad shares insights from his journey through big tech—from Dell to Adobe, Atlassian, and now Stripe—while discussing the challenges of scaling front-end engineering across different companies. The conversation covers TypeScript’s major performance boost, the Go vs. Rust debate, and how engineering teams are evolving their tooling for speed and efficiency.

They also explore Remix, why Brad prefers building projects with minimal dependencies, and his approach to self-hosting and keeping costs low for side projects. He reflects on balancing breadth vs. depth in a career, how developers can shape their personal brand, and the importance of learning through building.

Key Points from this Episode:

- TypeScript’s shift to Go has resulted in massive performance improvements, highlighting the impact of language choice on tooling speed and efficiency.

- Scaling front-end engineering in big tech comes with unique challenges, and each company operates differently despite similarities in structure.

- Keeping projects lean with minimal dependencies and self-hosting can reduce costs and provide greater control over development.

-Balancing breadth vs. depth in a career is crucial, as developers must decide whether to specialize deeply or explore a wide range of technologies.

Chapters

0:00 – Intro: Tailwind, Remix, and Thin Abstractions

1:09 – Meet the Hosts & Guest: Brad Garrapy

2:16 – Brad’s Career Journey: Dell → Adobe → Atlassian → Stripe

3:34 – TypeScript Gets 10x Faster: Why Go?

7:55 – Performance, Tooling, and Multi-threading Insights

14:59 – Why Remix? Building with Thin, Flexible Stacks

16:56 – Deployment Strategies & Avoiding SaaS Lock-in

19:57 – Cost, Free Tiers & the Case for DIY Infrastructure

28:13 – Creator Goals: Streaming, Tutorials & Building in Public

33:12 – Identity, Community, and Being Known for Something

38:23 – Where to Find Brad Online + Closing

Follow Brad Garropy on Social Media

On this episode of the Modern Web Podcast, Rob Ocel and Adam Rackis talk with Noah Harris, Senior Engineering Manager at Launch, to discuss the impact of mob programming and how it can transform engineering teams. Noah shares how pairing and mobbing helped him rapidly level up in his early career, how it fosters stronger communication, and why it’s particularly valuable for remote teams.

The conversation also explores engineering leadership, breaking past career plateaus, and the importance of soft skills in advancing your career. Noah shares insights on servant leadership, how engineers can take ownership without waiting for permission, and the role of code reviews in shaping strong technical leaders.

Key Points

1. Mob Programming for Team Growth – Noah explains how mob programming enhances collaboration, speeds up knowledge sharing, and improves code quality, especially in remote teams.

2. The Role of Pair Programming in Skill Development – Pairing with experienced engineers helped Noah rapidly learn JavaScript and asynchronous programming, reinforcing the importance of hands-on mentorship.

3. Breaking the Engineering Career Ceiling – Engineers looking to step into leadership roles need to be proactive, take ownership, and engage in code reviews to build influence and credibility.

4. Servant Leadership & Soft Skills Matter – Leadership isn’t about authority—it’s about removing blockers, supporting the team, and improving communication. Engineers who master this mindset naturally transition into leadership roles.

Follow Noah Harris on Social Media

In this episode of the Modern Web Podcast, Danny Thompson and Adam Rackis talk with Abdel Sghiouar, Cloud Developer Advocate at Google, Kubernetes Podcast co-host, and CNCF Ambassador. Abdel shares insights from his global tech journey, from Morocco to Google's largest data center in Belgium, and now Sweden. They discuss cloud computing trends, including WebAssembly, AI-driven serverless workloads, and the shifting lines between frontend and backend. They also explore AI’s impact on cloud development, from simplifying tooling to raising questions about job automation. Abdel offers a pragmatic take on AI’s role, emphasizing that those who learn to leverage it will thrive.

Key points from this episode:

In this episode of the Modern Web Podcast, hosts Rob Ocel and Danny Thompson sit down with Mariano Cocirio, Staff Product Manager at Vercel, to discuss Fluid Compute, a new cloud computing model that blends the best of serverless scalability with traditional server efficiency. They explore the challenges of AI workloads in serverless environments, the high costs of idle time, and how Fluid Compute optimizes execution to reduce costs while maintaining performance. Mariano explains how this approach allows instances to handle multiple requests efficiently while still scaling to zero when not in use. The conversation also covers what developers need to consider when adopting this model, the impact on application architecture, and how to track efficiency gains using Vercel’s observability tools.Is Fluid Compute the next step in the evolution of serverless? Is it redefining cloud infrastructure altogether?

Keypoints

• Fluid Compute merges the best of servers and serverless – It combines the scalability of serverless with the efficiency and reusability of traditional servers, allowing instances to handle multiple requests while still scaling down to zero.
• AI workloads struggle with traditional serverless models – Serverless is optimized for quick, stateless functions, but AI models often require long processing times, leading to high costs for idle time. Fluid Compute solves this by dynamically managing resources.
• No major changes required for developers – Fluid Compute works like a standard Node or Python server, meaning developers don’t need to change their code significantly. The only consideration is handling shared global state, similar to a traditional server environment.
• Significant cost savings and efficiency improvements – Vercel’s observability tools show real-time reductions in compute costs, with some early adopters seeing up to 85% savings simply by enabling Fluid Compute.

Chapters

0:00 – Introduction and Guest Welcome

1:08 – What is Fluid Compute? Overview and Key Features

2:08 – Why Serverless Compute Struggles with AI Workloads

4:00 – Fluid Compute: Combining Scalability and Efficiency

6:04 – Cost Savings and Real-world Impact of Fluid Compute

8:12 – Developer Experience and Implementation Considerations

10:26 – Managing Global State and Concurrency in Fluid Compute

13:09 – Observability Tools for Performance and Cost Monitoring

20:01 – Long-running Instances and Post-operation Execution

24:02 – Evolution of Compute Models: From Servers to Fluid Compute

29:08 – The Future of Fluid Compute and Web Development

30:15 – How to Enable Fluid Compute on Vercel

32:04 – Closing Remarks and Guest Social Media Info

In this episode of the Modern Web Podcast, Rob Ocel, Danny Thompson, Adam Rackis, and Brandon Mathis discuss the role of abstractions in software development. They explore frontend tools like React and SolidJS, backend abstractions like serverless platforms, and the importance of understanding patterns and learning through mistakes. The group also highlights emerging trends for 2025, including opportunities in platform plugins and developer marketplaces. Key Points for the Episode:

• The Role of Abstractions in Development: The panel discusses the benefits and challenges of abstractions in software development, emphasizing the importance of understanding underlying systems to avoid over-reliance on tools like React hooks and serverless platforms.
• Learning Through Experimentation: Personal experiences with tools like Advent of Code, exploring new languages like Swift and Rust, and experimenting with new frameworks like SolidJS highlight the importance of hands-on learning and stepping outside comfort zones.
• Platform Opportunities: A growing interest in building apps and plugins on established platforms like Stripe, Zoom, and Chrome Extensions showcases untapped opportunities for developers to create impactful solutions and monetize their skills.

In this Modern Web Podcast episode, hosts Rob Ocel and Danny Thompson chat with Bree Hall, developer advocate at HubSpot and content creator known as "Bytes of Bree." Bree shares her journey from front-end engineer to advocacy, offering insights on balancing travel, staying productive, and navigating the pressures of being "always on." They explore creating engaging content, short vs. long-form formats, and how to build trust with an audience. Bree also shares tips on learning, working, and sharing knowledge while staying authentic in the tech space. Key Points from the Episode:

• Transition to Developer Advocacy: Bree shares her experience moving from front-end engineer to developer advocate, highlighting the expanded ways to contribute beyond coding.
• Managing Travel and Productivity: Practical tips for balancing frequent travel with work, including maintaining a travel kit, planning small tasks, and adapting work hours.
• Specializing in a Tech Stack: Bree emphasizes the importance of mastering a specific tech stack deeply, choosing Astro, React, and Tailwind as her focus for 2025.
• Short vs. Long-Form Content: Discussion on how short-form content skills improve long-form storytelling, with platforms like TikTok emerging as powerful tools for learning and discovery.

In this episode of the Modern Web Podcast, host Danny Thompson sits down with David Mytton, founder and CEO of Arcjet and creator of the console.dev DevTools newsletter. They explore what makes a truly successful developer tool, the importance of great documentation, and how Arcjet is redefining "security as code" for modern applications. David shares insights into open-source strategies, balancing speed and innovation in startups, and the evolving role of AI in developer tools.

Chapters

0:00 - 1:41 Episode Introduction

1:42 - 2:55 David Mitten’s Background & Dev Tools Expertise

2:56 - 4:17 The Importance of Great Documentation

4:18 - 6:43 Challenges in Keeping Documentation Updated

6:44 - 9:20 Simplistic vs. Over-Stylized Docs

9:21 - 11:19 Why Arcjet Stands Out

11:20 - 13:01 Developer Security & Perceptions

13:02 - 15:07 Layered Security & Best Practices

15:08 - 16:46 Encouraging Developers to Prioritize Security

16:47 - 18:48 Dependency Management Challenges

18:49 - 20:30 Evolving Dev Tools Over Time

20:31 - 22:54 Modern Code Editors & Terminal Innovation

22:55 - 25:41 AI’s Role in Dev Tools

25:42 - 27:08 Benchmark Reliability in Dev Tools

27:09 - 30:57 Open Source Contributions & Strategy

30:58 - 32:54 Shipping Fast as a Small Team

32:55 - 34:06 Closing Remarks

Follow David Mytton on Social Media

Dive deep into the fascinating world of SQLite and Turso with Gláuber Costa, the founder and CEO of Turso, as he shares insights into the evolution of modern database technologies. Hosted by Danny Thompson and Adam Rakus on the Modern Web Podcast, this episode unpacks SQLite's growing popularity, Turso's innovative managed database services, and how local-first architectures are changing the database landscape. From syncing databases to leveraging SQLite for offline use, discover how these advancements empower developers to build faster, scalable, and cost-effective solutions. Tune in to learn about Turso’s unique approach, real-world use cases, and the future of databases in edge computing and mobile applications. Topics Discussed:

Backstage at All Things Open 2024, hosts Rob Ocel and Danny Thompson talk with Max Howell, creator of Homebrew and founder of the Tea Protocol, about making open source sustainable. Max shares his journey from building Homebrew as a passion project to launching Tea Protocol, which uses token-based economics to support maintainers without compromising open source values. They explore challenges like corporate involvement, project monetization, and building resilient open source communities.

Chapters

00:00 - Introduction

02:20 - Max’s Open Source Journey

09:09 - The Problem with Open Source Sustainability

13:54 - Why Traditional Funding Models Fail

16:08 - Tea Protocol’s Economic Model

18:34 - What Happens Without Open Source?

20:59 - Sacrifices Open Source Maintainers Make

23:09 - Capturing Value in Open Source

25:10 - Advice for Aspiring Open Source Developers

27:36 - Where to Learn More

Follow Max Howell on Social Media

In this episode of the Modern Web Podcast, recorded backstage at All Things Open, hosts Rob Ocel and Tracy Lee sit down with Bermon Painter, Composable Platforms Leader at Slalom, to explore how behavioral economics shapes ethical UX design. They discuss real-world examples like continuous glucose monitors, AI-driven personalization, and tackling dark patterns while balancing user trust and business goals. Berman also shares career tips and his unique open office hours, making this a must-watch for designers, engineers, and leaders alike.

Chapters

Introduction and Guest Welcome – 00:00

What is Behavioral Economics? – 02:36

Real-World Application: Voting Policies – 04:37

Healthcare Example: Continuous Glucose Monitors – 05:52

Design Challenges for Healthcare Apps – 08:12

Personalization and AI in UX Design – 12:52

International UX Design Differences – 14:08

The Ethical Dilemma of Dark Patterns – 17:28

Ethical Frameworks for Product Design – 20:33

Balancing Profit and Ethics – 22:39

Behavioral Economics for Engineers – 27:10

Berman’s Open Office Hours and Final Thoughts – 28:56

Outro and Sponsor Shoutout – 30:59

Follow Bermon Painter on Social Media

In this episode of the Modern Web Podcast, recorded live at All Things Open in Raleigh, NC, hosts Rob Ocel and Danny Thompson sit down with Dr. Sally Wahba, Principal Software Engineer at Splunk. Dr. Wahba shares her experience tackling on-call burnout, offering insights into reducing fatigue through better observability, automation, and thoughtful team practices.

The conversation also touches on mentorship and growth in the tech industry, including practical advice for junior engineers navigating the transition from academics to professional roles and tips for companies to better support new talent.

Chapters

00:00:13 - Introduction to Marketing This Dot

00:01:00 - Asking for Help Effectively

00:02:21 - Reducing On-Call Fatigue

00:04:42 - Observability Best Practices

00:07:07 - Balancing Alerts and On-Call Efficiency

00:09:30 - The Role of On-Call in Modern Engineering

00:11:29 - Insights from the Grace Hopper Celebration

00:13:56 - Mentorship and Team Dynamics

00:16:14 - Rapid Changes in Technology and Adaptation

00:18:39 - Automation, Observability, and Debugging Challenges

00:21:04 - Addressing the Talent Gap and Junior Engineer Growth

00:24:00 - Closing Thoughts and Where to Learn More

Follow Dr. Sally Wahba on Social Media

In this episode of the Modern Web Podcast, Danny Thompson sits down with Ferdinand Como and Baptiste Leproux from Nuxt Labs to uncover the story behind Nuxt Studio, a tool that's transforming how developers and non-technical users interact with Nuxt applications.

Ferdinand and Baptiste share how Nuxt Studio bridges the gap between developer customization and user-friendly content management. Built to empower agencies, freelancers, and their clients, Nuxt Studio combines powerful features like live previews, Vue component integration, and schema-driven forms to make managing content seamless.

The conversation also explores the broader mission of Nuxt Labs—building sustainable open-source tools that enhance developer experience and meet real-world needs. With insights into the future of Nuxt Studio and its potential to scale for larger organizations, this episode is a must-listen for anyone passionate about innovation in web development.

Chapters

1. Introduction and Setting the Stage (00:00:00)  

2. The Vision Behind Nuxt Studio (00:03:10)  

3. Nuxt Studio’s Core Features (00:08:45)  

4. Challenges in Building Nuxt Studio (00:16:20)  

5. Target Audience and Use Cases (00:22:35)  

6. Sustainability in Open Source (00:29:00)  

7. The Future of Nuxt Studio (00:35:10)  

8. Nuxt Studio’s Role in the Nuxt Ecosystem (00:42:30)  

9. Closing Thoughts and What’s Next (00:48:00)  

10. Sponsor Shoutout and Wrap-Up (00:53:20)  

Follow Baptiste Leproux and Ferdinand Coumau

Rob Ocel and co-hosts Tracy Lee, Adam Rackis, and Danny Thompson talk with tech educator Ankita Kulkarni about her journey from engineering leader to full-time educator. Ankita shares insights on teaching Next.js, bridging practical knowledge gaps, and helping developers tackle real-world challenges. They discuss Next.js as a React-based framework, its benefits, and the challenges it presents for beginners.

Chapters

Introduction to the Podcast and Guests 00:01  

Meet Ankita Kulkarni, Tech Educator 00:26   

Ankita's Transition to Full-Time Education 01:41   

Teaching Practical Knowledge in Next.js 03:19   

Effective Methods for Teaching Next.js 05:27  

Challenges of Being a Full-Time Educator 07:48  

Balancing Broad and Specific Examples 09:54   

Embracing Mistakes as a Teaching Tool 12:13  

Pair Programming and Mentorship 14:00   

Discussion on Next.js and Framework Adoption 16:48   

Advantages and Challenges of Next.js 18:12  

Choosing the Right Framework for Your Needs 20:35   

Impact of Next.js in React Documentation 22:26   

Learning Paths for New Developers 23:24   

The Rise of Full-Stack Web Development 25:09   

Benefits of Frameworks Abstracting Complexity 26:27   

OpenNext and Deployment Flexibility 28:06 

Ankita's Excitement for New Next.js Features 30:35  

The Future of Next.js Without Vercel 32:16  

Final Thoughts and Where to Find Everyone Online 34:21

Follow Ankita Kulkarni on Social Media