Talk Python in Production Book

Welcome to Talk Python in Production! Learn how Talk Python manages a podcast website, SaaS e-commerce platform, and mobile API traffic without overspending or vendor lock-in. We’ll explore best practices for scaling, cost control, and infrastructure reliability, without building our own data center. This chapter sets the stage for an empowering journey into a more self-reliant, efficient way of running Python applications in production. Enjoy the ride!

We explore how Talk Python outgrew PythonAnywhere and transitioned to dedicated Linux VMs. Starting with a PaaS was ideal for testing podcast waters, but maintenance downtime and limited control prompted the shift. DigitalOcean offered a simpler, more affordable alternative to hyperscale providers like AWS. With eight small VMs running various apps, podcasts, courses, APIs, the approach worked but introduced complexities, especially around updates and reboots. Ultimately, dividing apps across multiple servers didn’t deliver the expected isolation, simplicity, or cost savings. This chapter highlights the lessons learned, paving the way for a more efficient, containerized hosting environment in future chapters.

Learn how Talk Python escaped the complexity and costs of hyperscale cloud platforms, inspired by David Heinemeier Hansson’s We have left the cloud journey. Instead of maintaining multiple VMs, we consolidated everything into a single, powerful server running Docker and Docker Compose for seamless app isolation and portability. Enjoy a simpler, faster, and cloud-agnostic setup; without rewriting apps for proprietary services or sacrificing performance and reliability.

See why Talk Python ditched multiple small servers for a single, larger machine with eight vCPUs and 16 GB RAM. Although the total compute power is the same, consolidating everything under one server simplifies updates, as only one machine needs patching, and dramatically increases peak performance. When each web app spikes separately, it can tap into nearly all eight CPUs, rather than being limited to a small VM. This approach provides 4-8x more capacity for critical moments at roughly the same price. Explore how Docker-based isolation still protects each app while allowing full compute sharing and streamlined management.

In this chapter, learn why Talk Python embraced Docker on one powerful server instead of sprawling cloud services or heavy orchestration. Containers run directly on the host OS, providing near-zero overhead and a simple yet robust architecture. By consolidating everything under a single VM, Talk Python achieves 99.999% uptime and just 19 seconds of monthly downtime, without Kubernetes-level complexity or vendor lock-in. Inspired by self-hosting success stories like Basecamp and Zig, this approach avoids runaway costs, offers effortless portability, and still benefits from the hosting provider's reliable data center. See how 'just Docker Compose' delivers both performance and peace of mind.

Learn how Talk Python accelerates its web apps by adopting Granian, a Rust-based HTTP server supporting both WSGI and ASGI. Discover why legacy options like uWSGI have faded and how Granian compares to Gunicorn and Uvicorn in benchmarks. By harnessing Rust’s battle-tested “hyper” library, Granian delivers impressive throughput and low latency—ideal for Python’s I/O-heavy workloads. You’ll also see how multiple worker processes (a “web garden”) help overcome Python’s GIL, ensuring full hardware utilization. Finally, explore how Talk Python’s Docker-based deployment simplifies upgrades, fosters flexibility, and keeps application performance consistently high in production.

Discover how self-hosting with Docker Compose opens up a world of simple, flexible add-ons for your Python apps. In this chapter, you’ll learn how Talk Python integrates open-source analytics (Umami) and downtime monitoring (Uptime Kuma) right on the same server, no extra subscriptions or third-party data sharing required. By running these Dockerized services alongside your main application, you’ll gain deeper insight into user behavior and real-time uptime status. Plus, you’ll see how to manage external volumes for persistent data and free yourself from vendor lock-in. Explore thousands of self-hostable solutions at awesome-selfhosted.net and create the ultimate DIY stack.

Discover practical ways to monitor and manage Dockerized application, even if you’re new to containers. You’ll learn about btop and Glances, two free, feature-rich terminal dashboards that display CPU, memory, disk usage, and running processes, including those inside containers. Next, see how the Docker Cluster Monitor provides a real-time overview of container statuses and resource limits. You’ll also learn to log into a container’s shell, no SSH setup required, and persist logs with volume mappings to tail them from the host. Armed with these tools and techniques, you’ll gain full visibility and control of your self-hosted environment.

Uncover practical Docker optimizations for faster Python app builds and deployments. Learn how to reorder Dockerfile commands to leverage layer caching—so small changes (like editing a CSS file) won’t trigger full dependency reinstalls. Explore uv, a tool that quickly fetches Python versions and caches dependencies, while Docker’s --mount option preserves these caches across rebuilds. You’ll also see how a .dockerignore file trims out unneeded files, speeding up image builds. Finally, discover strategies for improving continuous integration times and reducing PyPI overhead, all while creating smaller, more efficient Docker images for your production environment.

Discover how Talk Python uses NGINX as a front-line server and reverse proxy for high-performance HTTPS routing. You’ll see exactly how NGINX connects to Python app servers like Granian or Uvicorn, handling SSL, static file serving, and domain routing. Learn how to automate free SSL certificates with Let’s Encrypt and Certbot, even in a locked-down Docker environment. Through example configurations, you’ll gain insights into mapping volumes for certificate management, creating auto-renew cron jobs, and handling multi-domain setups. Explore these approaches to build a secure, flexible, and modern web stack without locking yourself into proprietary cloud services.

Learn how Talk Python accelerates global content delivery by caching static assets and media through Bunny.net’s expansive worldwide network. You’ll see how replicating CSS, JavaScript, images, and even large audio/video files at 119 edge locations slashes latency for users, whether they’re streaming a podcast or loading a web page. Discover how querystring cache-busting ensures zero stale files on deployment, while straightforward billing (just $0.01/GB) keeps costs low. By offloading bandwidth to the CDN, Talk Python’s main server remains responsive. Explore these techniques to deliver a fast, smooth user experience without relying on hyperscale cloud services.

We walk through creating a fully operational production environment on a single Linux cloud server. You’ll learn how to provision a Hetzner VM, secure it with a firewall, install Docker, and build layered images for both Linux- and Python-based containers. Then, see how to deploy a Flask+HTMX app via Granian, wire it into NGINX, and ensure automatic startups with systemd. Finally, you’ll script deployments and updates, simplifying future releases. By following these step-by-step instructions, you’ll get an end-to-end blueprint for running Python web apps on a fully controlled, one-server infrastructure.

You’ll explore how to blend powerful static site generators, such as Hugo, into your existing Python web stack. First, discover Hugo’s flexibility for building non-blog sites (e.g., data-driven pages) from Markdown and CSV files, all without a database or backend server. Then, learn two ways to embed those static files within your Docker/NGINX environment: host them standalone or nest them under routes in existing Flask apps, like /blog or /docs. You’ll also see tips for cross-linking sitemaps so search engines understand your entire site’s structure, even across static and dynamic app sections.

Discover how Talk Python replaced its aging Pyramid setup with modern, async-capable Quart. Learn why frameworks like Django, FastAPI, and Litestar were strong contenders, but ultimately lost out to the simplicity and popularity of Flask’s ecosystem. Dive into the two-phase migration approach: first rewriting code to use Quart (staying synchronous), then upgrading critical database calls to async/await. You’ll see how this boost in concurrency trimmed response times from 42ms down to single digits, while eliminating legacy bottlenecks. If you’re evaluating Python web frameworks, this chapter offers a behind-the-scenes migration roadmap.

Discover why Talk Python chose to develop its own platforms rather than relying on third-party solutions. You’ll see how self-hosting the podcast site, courses, and bespoke integrations benefits both the business and its audience, delivering features like automated YouTube live stream announcements and advertiser dashboards with zero tracking. Beyond that, building your own tech fosters deep coding experience and keeps you in touch with real-world production challenges. While not everything warrants custom development, credit card processing, static sites, and more may benefit from outside tools, owning select parts of your stack can be a game-changer.

In this chapter, Michael Kennedy recounts Talk Python’s switch from DigitalOcean to Hetzner's new US data center. By migrating 20-plus services and databases, he gained superior CPU speeds, an 8x bandwidth boost, and cost savings of nearly $1,500 annually. You’ll see how server benchmarks and hands-on comparisons revealed Hetzner’s surprisingly affordable and powerful cloud VMs. Michael also explains why modernizing Talk Python’s “one big server” made this move straightforward, just export and re-deploy the containerized infrastructure. If you’ve ever wondered whether hosting abroad might benefit performance and budget, this Hetzner retrospective offers a firsthand look at the decision process.

Learn why the "lift-and-shift to your own data center" mindset isn’t a valid counterpoint to hyperscale, microservice-heavy "cloud-native" stacks. Instead, this chapter introduces "stack-native": a philosophy centered on running just enough containers (e.g., Flask, NGINX, Granian, and a database) on one well-chosen VM. It avoids vendor lock-in, scales seamlessly for many real-world apps, and remains fully owned by your small team. You’ll see why this approach, replete with Docker orchestration, custom volumes, and self-hosted databases, achieves the reliability of Kubernetes without the complexity or runaway cloud costs.

In Chapter 18: Conclusion, we finalize the journey of “stack-native” development, where simplicity, flexibility, and cost-effective ownership are front and center. You’ve seen how to deploy Python apps using Docker, NGINX, container orchestration, and more, all on a single, powerful VM. This approach ensures minimal complexity, straightforward management, and maximum autonomy. Whether you adopt all these practices or adapt only a few, you now have the tools and confidence to run Python in production, without lock-in or unnecessary cloud-native overhead. Stay connected through mkennedy.codes and the book’s GitHub discussions to share your success stories and keep learning!