108 avsnitt • Längd: 65 min • Veckovis: Måndag
Hear about how folks are running their web apps in production. We’ll cover tech choices, why they chose them, lessons learned and more.
The podcast Running in Production is created by Nick Janetakis - Full stack developer. The podcast and the artwork on this page are embedded on this page using the public podcast feed (RSS).
In this episode of Running in Production, Filipe Névola goes over building a hosting platform for Meteor apps. It’s hosted on AWS with ECS and has been running in production since 2015.
Filipe talks about building critical services with Go, using Meteor to build front-end web dashboards, the importance of monitoring, using Recurly for subscription payments, multi-region AWS hosting and overall providing a highly available platform for thousands of clients.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Chad Wilken goes over building a service to help contractors document their job and communicate with their crew. It’s been up since 2014.
Chad talks about handling ~800k photo uploads per day, building a Rails API driven app, creating a great mobile experience with React Native, handling millions of daily Sidekiq (pro) jobs, transitioning to AWS ECS with Fargate, deploying with Capistrano and so much more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Michael Lynch goes over building a hardware device that lets you remote control your server without installing any software. It’s been available since mid-2020.
Michael talks about how it works, using Ansible to provision a Raspberry Pi, Using Flask with SocketIO, rendering 30 frames per second at 1080p with under 200ms latency, using web components, selling his devices on Shopify, hiring quality freelance developers and more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Nick Savrov goes over building a platform to help content creators build a business with Ruby on Rails. It’s hosted on Heroku and has been up and running in production since 2014.
Nick talks about supporting 6.5 million users, using Turbolinks, having a 19 developer team working on a monolithic app, sending millions of weekly emails, storing billions of weekly events, using ShapeUp to help manage the project and much more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, PJ Murray goes over building a customer research app with Ruby on Rails. It’s hosted on Heroku and has been up and running since mid-2020.
PJ talks about using feature flags, integrating Stripe with Jumpstart Pro, building out a React front-end, the value of having business metrics, taking data security very seriously, having a pragmatic approach around test coverage and tons more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Josh Kinabrew goes over building an AI driven invoice categorization system using Ruby on Rails. It’s hosted on Heroku and AWS and has been up and running since 2013.
Josh talks about training an AI system to scan and break down pictures of invoices, managing thousands of clients, using the latest stable version of Rails, using Sidekiq Pro, interfacing with QuickBooks and more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, CJ Avilla goes over building a fund raising platform with Ruby on Rails. It’s hosted on Heroku and has been running in production since 2015.
CJ talks about rewriting an app with Rails, processing $30 million dollars of donations, using Stripe, maintaining a Rails 4.2 app, carefully sending out bulk emails, ensuring good tests are written, keeping things simple and more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Nick Janetakis goes over building a podcast site with Jekyll and Ruby. It’s hosted on a single DigitalOcean server and has been running in production since October 2019.
Nick talks about what it takes to release an episode, keeping things simple, developing a custom audio player, hosting a bunch of sites on a single DigitalOcean server with nginx, using shell scripts to help reduce human errors and more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Jason Swett goes over building an internal medical record system with Ruby on Rails. It’s hosted on AWS using Kubernetes and it’s been up and running since 2019.
Jason talks about replacing a few 3rd party services with 1 custom solution, using custom generators, embracing PORO, transitioning from Ansible and individual servers to Kubernetes, making safe decisions while learning as you deploy new things and much more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Vlad Radulescu goes over creating a game directory site with Ruby on Rails. It’s hosted on AWS and has been up and running since 2014.
Vlad talks about having thousands of active users, interfacing with a few game platform APIs, running millions of Sidekiq jobs, storing 10+ billion database records, keeping things as a monolithic app, deploying the web app to 1 server and lots more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Dieter Lunn goes over building a job board site for school bus drivers and aides using Ruby on Rails. It’s hosted on DigitalOcean with HatchBox.
Dieter talks about using a bit of StimulusJS to add pins to a map, keeping things simple with a monolithic app, working on the code base with another developer, upgrading to the latest versions on a regular basis and using HatchBox to manage the servers.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Matthias Viehweger goes over building a service to help organize groups of people. It’s built with Ruby on Rails and is hosted on OpenShift with Kubernetes. It’s been running in production since 2012.
Matthias talks about building a Rails Engine abstraction, creating a multi-repo monolith, using Sphinx for full text search, making the most of Kubernetes / OpenShift and lots more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Kristian Dupont goes over building a SAAS app to manage access control to your existing SAAS subscriptions. It’s built with Koa, Node and React and is hosted on Heroku. It’s been running in production since 2018.
Kristian talks about validating his idea before coding it, really leveraging code linting tools, the challenges of adding a bunch of different SAAS app integrations, using ElephantSQL to host his PostgreSQL database and more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Andy Ide goes over building a SAAS app for horses with Django and Python. It’s hosted on a single Linode server and has been running in production since May 2021.
Andy talks about learning Django while building his app, using Django Unicorn, creating a Django monolith that’s broken up with Django apps, outsourcing setting up a server, the importance of having a good testing team and more.
Andy was kind enough to give listeners of this podcast 20% off for life if you
use promo code RUNNING20 when signing up, that
includes signing up for free since it carries over to a paid plan.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Karl Roos goes over building a B2B news and data platform with Rails, Node and Python. It’s hosted on AWS using Elastic Beanstalk and has been up and running since 2014.
Karl talks about writing a Rails API back-end, scraping 400+ sites, executing 500k+ daily jobs, using a bunch of AWS resources, what it’s like dealing with a ~500 GB MySQL database, the importance on taking action and more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Matt Oliver goes over building a chat platform with Akka, Scala and React Native. It’s hosted on DigitalOcean with Kubernetes and has been running in production since 2013.
Matt talks about rewriting his app a few times, handling tens of thousands of nightly TV shows, going all-in with Kubernetes, using Terraform, understanding it’ll take a while to learn things along the way and more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Maciej Delmanowski talks about building out a 40+ server / 200+ VM data center with Ansible. It’s hosted on premises, he’s been working on it all since 2007 and started using Ansible in 2013.
Maciej talks about automating everything with Ansible, being a sysadmin for over a decade, how he picked Debian, splitting up a project into 120+ git repos and then back to 1, writing 60k+ lines of YAML, using Linux Containers, maintaining an open source project and more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Adrian Marin goes over building a Ruby on Rails admin framework. It’s hosted on Heroku and has been available since late 2020.
Adrian talks about building a Rails engine, using Stripe Checkout, building the admin out with Hotwire Turbo, using View Component, creating a very automated CI / CD pipeline to publish the gem and much more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Przemek Matylla talks about building an image processing and optimization API with mostly C, Python and Node. It’s hosted on bare metal servers in a data center and has been running in production since 2019.
Przemek talks about handling 20-50 million+ daily API calls, how they’re using C, image detection techniques, using Lua scripting with nginx, building their own servers in a data center, using boring technology and much more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Chris Samiullah goes over building a video course hosting platform with FastAPI, Strapi and Gatsby. It’s hosted on ECS along with a bunch of AWS resources. It’s been running in production since early 2021.
Chris talks about combining a Gatsby static site with FastAPI, using AWS Fargate, streaming videos with Cloudflare, supporting both Stripe and Paddle, using a bit of Serverless Lambdas and tons more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Eduardo Messuti talks about building a status page and monitoring service with Phoenix and Elixir. It’s hosted on DigitalOcean and Heroku. It’s been up and running since 2017.
Eduardo talks about upgrading their code base to use Phoenix contexts, using Oban, creating a notification abstraction, going all-in with EEx rendered templates and a bit of jQuery, using Docker Compose in production and more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Jon Perl goes over building a service that automates creating browser tests for your web apps. It’s built with Node and React and is hosted on Netlify, Vercel, Azure Containers and DigitalOcean. It’s been running in production since 2019.
Jon talks about creating an open source tool and turning it into a SAAS app, using VNC and websockets to stream test runner data to the browser, keeping things as a mono repo, moving from Azure Containers to Kubernetes and much more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, David Parker talks about building a service to subscribe to people with Ruby on Rails and Sapper. It’s hosted on Heroku ($30 / month) and has been up and running since November 2020.
David talks about creating an API back-end with Rails, trying out Svelte and Sapper, the challenges of scraping names from websites, figuring out and fixing PostgreSQL performance issues, finding a good work / life balance and more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Ege Ersoz goes over building a project management service using Phoenix and Elixir. It runs on Gigalixir along with Heroku and has been up and running since early 2019.
Ege talks about using Elixir for the last few years, upgrading to use Phoenix contexts, building a monolithic app with an API back-end / VueJS front-end, building his own Stripe billing module, what it’s been like using Gigalixir and more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Jake Lazaroff talks about building a video rendering service with Express and Node. It runs on a few DigitalOcean servers and has been up and running in production since February 2019.
Jake goes over rendering ~30k+ videos over 2+ years, executing background tasks, sharing lots of code between the back-end and front-end, using both Stripe and PayPal, not using an ORM with PostgreSQL, setting up Blue / Green deploys with Terraform, Packer and nginx, plus tons more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Utsav Shah goes over building Dropbox with Pylons, Python, Rust and Go. It’s mostly hosted on their own data centers across 1,000+ servers. It’s been available since 2008. They have 700+ million users and handle 100k+ requests per second.
Utsav talks about working with hundreds of engineers on a multi-million line Python based monolithic app, handling payments without Stripe, storing exabytes of files, using Rust in the desktop client, having remote dev boxes, leveraging open source tools and tons more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Nate Rush goes over building a JupyterLab extension with Python. It runs locally in a Jupyter Notebook but they also host JupyterHub instances on a Kubernetes cluster running in EKS. It’s been running in production since late 2020.
Nate talks about building a cross platform Python installer, building and publishing a JupyterLab extension, leveraging Pandas, building the front-end with React / Typescript, hosting a version of their product on a Kubernetes cluster, the value in automating the hard stuff and more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Tigran Nazaryan covers building a WordPress hosting platform with Laravel, Python and Node. It’s hosted on GCP for their clients’ sites and OVH for their core services. It’s been up and running as a hosting platform since late 2020.
Tigran talks about working with a team of 34 engineers, using both MongoDB and MySQL, creating a bunch of services with a very well thought out architecture while keeping it simple enough for it to all run on a developer’s laptop. He covered a lot of ground.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Ian Eyberg goes over creating a Unikernel with C as well as host a few sites supporting his tool with Go. It’s hosted on Google Cloud and their own data center. Nanos has been available since 2020.
Ian talks about what a Unikernel is, their open source tools and how they manage their own services. This episode has a healthy mix between background knowledge on Unikernels and how they (as a company) set up their infrastructure.
It’s worth pointing out you can run your existing applications in a Unikernel without having to change how it’s written and they support running them on most major hosting providers (AWS, GCP, Azure, DigitalOcean, your own hardware, etc.).
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Cole Simmons goes over building an AI driven service for commercial real estate professionals with Flask and Python. It’s hosted on Google Cloud using GKE (Kubernetes) and has been up and running since 2017.
Cole talks about rewriting the initial prototype, the dangers of not using an ORM, splitting out the front-end from the back-end, using Google Functions, the importance in making sure you’re building what your users want and so much more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Jason Charnes goes over building a video course hosting platform. It’s built with Ruby on Rails and is hosted on Heroku. It’s been running in production since 2014.
Jason talks about using StimulusReflex / Action Cable, upgrading to Sidekiq Enterprise, writing tons of tests, setting up auto scaling on Heroku, tips to run zero down database migrations at scale, ways to reduce 3rd party API calls and more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Sean Callaway talks about building an app to help manage REI’s server infrastructure. It was built with Django and it’s mostly hosted on premises in their own data center.
Sean covers keeping the app mostly server rendered and goes into detail about using Ansible, Kubernetes and Rancher to help manage things.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Nick Hnatiw goes over building a password manager with Django and Python. It’s hosted on Heroku and DigitalOcean.
Nick talks about using Django Rest Framework because there’s a web app along with native mobile apps, the value in charging for a product to avoid having your data sold, using HashiCorp Vault to manage user’s private keys and more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Mubashar Iqbal talks about building a site to find podcast episodes with Laravel and PHP. It’s hosted on DigitalOcean using Forge and has been up and running since mid 2019.
Mubs talks about using a bit of Vue as needed, not upgrading to the latest Laravel immediately, interesting problems around parsing RSS feeds, how Forge lets him easily host his site, understanding the nuances of your app’s domain and more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Jonathan Adly goes over building a gift giving service with Django and Python. It’s hosted on Heroku’s hobby tier and has been up and running since November 2020.
Jonathan talks about shipping his first app, using Celery for background jobs, handling non-standard payment patterns with Stripe, not getting caught up with what everyone is saying to use for tech choices and trying to develop features based on using the app as a customer.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
This episode is no longer available at the moment because it’s being reviewed by 1 or more companies that own this service. It may or may not come back. It’s up to them.
If you’re wondering if something very secret was accidentally leaked, it wasn’t. We had a conversation similar to every other episode on this site.
However, as a podcast host (this is Nick writing all of this) I very much respect the decision of a company requesting that their episode gets removed until they have a chance to review it.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Anthony Eden covers building a domain management service with Rails, Go and Erlang. It’s hosted on a combination of 70+ bare metal servers, AWS and Heroku. It’s been been up and running since 2010.
Anthony talks about handling millions of API queries per day, ~5 billion monthly DNS queries, spikes of up to 10,000 requests per second, sticking with a Rails monolith for the web dashboard, scaling PostgreSQL, building multiple data centers, feature flags and tons more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Justin Duke goes over building an email newsletter service. It’s mostly hosted on Heroku and has has been up and running since late 2016.
Justin talks about how he handles sending out 100k+ emails, having a mix of Django templates and DRF + Vue, using rq to schedule emails, scaling with Heroku, balancing out what events to keep track of, how to figure out which features to develop and so much more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Denis Stepanenko talks about building an internal app to help manage finances around selling season tickets. It’s hosted on DigitalOcean and has been up and running since mid 2020.
Denis covers what the process was like to rebuild an old PHP app with Django, coding everything with 6 months of experience, using DRF and React, keeping deployments simple and not being afraid to read other people’s source code.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Ian Davidson goes over building a data sharing service using Phoenix and Elixir. It’s using Live View too. At its peak the site received a spike of 10k+ requests in a day and it’s hosted on a $20 / month DigitalOcean server.
Ian talks about quickly building the app, reacting quickly to add user requested features, using DigitalOcean for the first time, some pitfalls of using Live View / websockets when it comes to configuring nginx and more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Dash Winterson talks about building a new type of chat app for iOS using Django and Python on the back-end. It’s hosted on AWS using Elastic Beanstalk and has been up and running since mid 2020.
Dash covers creating async compatible code in Django, developing a monolithic back-end that a few developers develop against, investing in the AWS ecosystem, end to end message encryption and the Zen of Python.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Nidal Alhariri goes over building a sales and CRM tool with Flask and Python. It’s hosted on a few cloud providers such as AWS and Linode. It was created in mid-2019.
Nidal talks about using MongoDB, splitting tenants out with their own individual servers, mixing in Vue where needed, using Ansible and he also drops great advice around moving forward and shipping code without chasing perfection.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Jared Chung talks about building a community platform with Django and Python. It’s hosted on AWS and has been up and running in production since 2011. The beta version was intially built during a 4 day hackaton.
Jared talks about taking advantage of Django’s batteries included, heavily using Celery / Redis and hosting the main web app on a single EC2 instance. Their AWS bill is roughly $2,500 a month.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Sascha Wolf walks us through an internal tool he built to help deal with microservices. It’s written in Phoenix and Elixir and is hosted within a Kubernetes cluster on AWS using EKS. It’s been running in production since mid 2019.
Sascha talks about rewriting the prototype from Java to Elixir, taking advantage of Phoenix Channels, creating event driven systems, moving from Heroku to AWS and really making the most of OTP features such as using stateful processes.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Jerod Santo and Gerhard Lazu go over their news and podcast platform which is using Phoenix and Elixir. It was rewritten in Phoenix back in 2015 and it runs on Linode’s Kubernetes Engine across a 3 node cluster.
Jerod and Gerhard talk about building a context-less Phoenix app, using Turbolinks, caching, transitioning to using Kubernetes, automating as much as possible while focusing on patterns that work for small teams and so much more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Joel Griffith goes over building a service to run headless browsers using Express, Node and Docker. It’s been up and running since late 2017 and runs on just under 1,000 DigitalOcean servers.
Joel talks about handling millions of browser sessions, breaking the app up into a few pieces, using Redis as a primary database, using Stripe, creating a custom Node CLI for helping automate deployment tasks and so much more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Parker Selbert talks about building the licensing site for his Oban project using Phoenix and Elixir. It’s been up and running since March 2019 on Heroku.
Parker talks about using Live View for the demo page, how access control is handled with Hex’s private packages, a bunch of libraries he uses, hand rolling his Stripe implementation, building a custom admin with custom analytics and more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Ben Dominguez goes over building a video course platform to learn Python. It’s written in Flask and the MVP was finished in 3 weeks. He gets about 4,000 visitors a month. It’s hosted Heroku’s hobby tier.
Ben is the solo developer on the project. He talks about using techs you’re familiar with, keeping deployments simple with Heroku, using PaymentIntents with Stripe and much more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Kshitij Sinha walks us through his job finding platform called Creative Hire. It was written in Python and Django and is hosted on AWS’ free tier. It’s been up and running since early 2020 after the MVP was built in about 6 weeks.
Kshitij is the solo developer on the project. It’s a monolith split across a few Django apps with 2 git repos (one for the back-end and one for the front-end). It does a quite a bit of NLP to help categorize submissions and more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Kye Russell goes over running a formative school assessment tool for 800+ schools in Australia. It’s built with Django and it’s been running in production since 2017 on AWS.
Kye is the solo developer on the project. It’s a monolith split across 10+ Django apps. They’ve gone all-in with a bunch of AWS services and Kye sticks to a number of best practices such as having tests, linting and using services to help keep things running smoothly.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Anand Kulkarni goes over his app builder and deployer platform using Django. Over 15,000 customers have built and deployed their apps through it. It’s running on 1,000+ Heroku Dynos and has been up and running since early 2017.
Anand covers having a mono repo for the 100k+ lines of back-end code, switching to an API driven back-end, using Terraform, making use of Heroku’s eco-system and much more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Daniele Procida walks us through their cloud platform to manage web apps using Django. 10s of millions of web requests flow through their client’s applications. It’s running on multiple cloud providers and has been up and running since 2015.
Daniele covers the importance of a stable platform when you’re dealing with customers who have their own customers, writing upwards of a million lines of Python across their services, being vendor neutral with hosting infrastructure and more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Barton Ip talks us through building a custom CRM to help care for the elderly using Django. They are running on AWS with ECS and the site has been up and running since early 2019.
Barton talks about hiring contractors when needed, splitting logic across 40+ Django apps, heavily using Celery, incrementally improving their infrastructure over time and more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Dan Purcell goes over building an e-commerce store with Django that processes up to 3,000 orders per second. It’s running on 12+ web servers on DigitalOcean and the site has been up and running since 2014.
Dan covers building an API backed app with Vue on the front-end, handling thousands of concurrent websocket connections, using Authorize.Net for payments and deploying to a bunch of web servers that are managed by Ansible with Fabric.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Galen Rice walks us through building an internal inventory management system with Django and Python. It’s running on a single bare metal server and has been up and running since 2013.
Galen talks about replacing an Excel sheet with a custom app, using 20 Django apps, taking advantage of the Django admin and deploying everything onto a custom server.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Umar Hansa talks about building a video course platform with Express and Node. It’s hosted on a single $10 / month DigitalOcean server. It took about 3 months of part time development and has been up and running since late 2017.
Umar talks about keeping it simple, building a server rendered monolith, using SQLite and not being afraid to build something from scratch. He covered a lot of ground in this episode.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Dalton Polhill goes over building a text based course platform with Django and Python. It’s running on a single EC2 instance and was up and running after 2.5 months of development time.
Dalton talks about doing contract work for a client, how the Django admin was a big help, happily using SQLite, the value in using web frameworks and more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Paul Cappaert talks about building a leader board for a flight simulator that he developed at University. It’s built with Django and Python and runs on the Heroku free tier. It was in development for most of the 2019 school year.
Paul goes over using QR codes as a login mechanism and what it was like building an API back-end so that the game server (Unity) running the simulator can report back stats.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Dan Kolbman goes over using Django to build an internal tool that helps make sense of ~5 Petabytes of Genomic data that is then made available to clinicians. It’s running across many different AWS resources using ECS Fargate.
Dan walks us through what their app does, dealing with loads of data, using GraphQL, getting away from using Serverless and going mostly all-in with AWS. Their apps are open source too. The ones we’ll be talking about are on GitHub here and here.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Colin McFaul goes over using Django to build a social hiring platform for the food and beverage industry. It was in development for 9 months before it went live in early 2020. It’s hosted on Heroku.
Colin talks about building 2 separate apps and keeping the web app as a monolithic app with ~42k LOC, but it’s broken up with Django apps. Elasticsearch is used to power an auto-complete search feature. Billing isn’t implemented yet but it’s currently in development with Stripe.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Antonin Grêlé talks about using Django to build a gift card purchasing site for eco-friendly products. It’s hosted on PythonAnywhere and has been up and running since fall 2019.
Antonin developed it himself in a few months and covers tying together services using Zapier, what it’s like to manage gift card logic, the value in getting something up quickly and more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Clemens Wolff and Shaun Bathgate go over building an Orange Pi hardware appliance that uses Flask and various Linux tools to help rural communities get affordable email. Besides the client hardware, the server component is hosted on Azure.
Clemens and Shaun talk about the challenges of developing and debugging such a service, using Terraform to manage 38+ Azure resources, how it all comes together in about 7,500 lines of Python and linting everything.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, John Debs talks about building a video platform with Django that helps you get stronger and be more flexible. It’s hosted on a single $5 / month DigitalOcean server and has been up and running since fall 2019.
John really drives home the value in shipping something simple on the first pass and iterating on it if there ends up being demand for it.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Chris Goodwin talks about building a platform with Django to manage 15k+ students and 2.5k+ staff members across 29 locations. It’s all hosted on a few on-premises Windows servers and has been up and running since 2017.
Chris covers evolving a solution from Excel sheets, working with a large monolithic Django code base, being a Microsoft shop and the importance of tests and logging.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Dave Merwin goes over building a service that helps protect those that protect us. It’s a service written in Django and it’s hosted on a single DigitalOcean server. It’s been up and running since 2016.
Dave covers using Django apps, the benefits of keeping everything hosted on 1 server and getting your app up and in front of customers as soon as possible.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Jon Calhoun talks about building his video course platform with Golang. It’s hosted on a single DigitalOcean droplet and has been up and running in production since 2016.
Jon covers keeping it simple with a monolithic app that was rewritten a few times, using SQLite as his main database even with 15,000+ active users and spending his innovation tokens wisely.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Harry Moreno goes over building a platform with Django that lets you connect with people and find things to do in NYC. It’s hosted on Heroku and has been up and running in production since August 2019.
Harry covers building an API with Django, using React Native for a mobile app, the struggles of learning Kubernetes and how it’s a good idea to validate your idea before trying to code it.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Jesse Hunt talks about building a site with Django that lets you view 3D scans of cars with Twinner. It’s hosted on 2 Heroku hobby Dynos and has been up and running in production since January 2020.
Jesse talks about building a few MVPs for his client, getting everything together in ~1k lines of Python code and using Heroku to avoid having to do a bunch of sysadmin work.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Cory Zue goes over building a service to create and design place cards for weddings, parties and any other events using Django. It’s hosted on a single Linode server and has been up and running since May 2017.
Cory talks about trying to avoid over engineering things and this episode speaks truth to that. His service generates over $2,000 / month and had an MVP working in ~2 weeks as a solo developer.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Mark Miscavage talks about building a site to display hundreds of thousands of full text searchable products for Lionel. The site is powered by Django with a custom open source CMS. It’s been up and running since 2015 and is hosted on AWS.
The agency Mark worked at developed 100+ Django sites, including sites for the Avatar movie along with Hunger Games.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Austin Lewis goes over replacing an Excel sheet with a custom / internal Django app to manage his real estate business. It’s been up and running on the AWS free tier since April 2020.
It has processed over 300 orders in the few months it’s been up and Austin is sole developer of this project. It is one of the first apps he’s deployed.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Brendan Wood talks about building a portfolio management platform with Django and Python. It’s been running in production since mid 2017 and is hosted on DigitalOcean.
There’s about 3,000+ active users and overall they are responsible for managing hundreds of millions of dollars in funds for their users.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Ben Sassoon goes over building a site that helps you figure out how much toilet paper you have left. It’s a static site using pure HTML. It’s been running in production since March 2020 and it’s hosted on GitHub Pages.
The site has had over 10 million visitors and was featured on various cable TV news outlets and talk shows. The MVP was built as a joke for his friends in about 20 minutes.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Sean Parsons goes over building an e-commerce video course marketplace to sell Confectionery goods with Django and Python. It’s been running in production since December 2019 and it’s hosted on AWS.
The app has roughly ~100k lines of code and was solo developed part time over about 3 months before shipping an MVP.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Stuart Kelly lets us know what it’s like to build an insurance company from scratch with Django and Python. It’s been running in production since early 2017 and they’ve issued out 290+ million hours of insurance so far. It’s hosted on AWS.
Stuart covers building an MVP in 8 weeks, using Stripe with SCA, creating 25+ Django apps over time, working with a GraphQL API back-end, querying 45+ million DB rows quickly, making app deploys a pleasant experience for his team, achieving 99.99% uptime and so much more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Phil Gyford goes over building a community around 9+ years of diary entries from Samuel Pepys. The site was built with Django. It gets about 150k+ page views a month and has been up and running since 2002. It’s currently hosted on Heroku.
Phil talks about being in the sweet spot in terms of engagement while not being under high load, rewriting the platform with Django as a monolith, how Heroku helps him get it all up and running without needing to bother with servers and much more. The site is open source.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Dylan Jhaveri talks about building an API driven video platform called Mux. It uses Phoenix, Elixir and Go to handle billions of video views a month. It’s hosted on AWS and GCP with Kubernetes and has been up and running since early 2016.
Dylan covers how video streaming works, processing billions of events a month, taking advantage of Elixir and Phoenix’s features, providing a zero downtime public API, continuously deploying their products, working with massive databases, metered billing and tons more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Amit Jain goes over building an auctioning system that uses machine / deep learning and is powered by Flask and Python. It’s all hosted on AWS and has been up and running since mid 2011.
Amit goes over a few machine learning libraries, refactoring a 100k+ line monolith into microservices without any automated tests, the importance of machine learning accuracy, using a bunch of AWS services to deploy a large site, treating your infrastructure as code and more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Saad Malik talks about building a free cover letter analysis tool with Flask and Python. It uses NLP (Natural language processing) and has been up and running on Google App Engine since April 2020.
Saad goes over various Python NLP libraries, processing 400+ cover letters in his first month after shipping an MVP, using MongoDB as a primary database, keeping his front-end simple with a bit of jQuery, what it’s like to deploy a Python app using Google App Engine and more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Todd Gardner goes over how he built TrackJS. It’s written in .NET and pulls together a number of different technologies to get the job done. It’s all hosted on OVH using dedicated hardware and has been running in production since 2013.
Todd talks about how to track JavaScript errors in production, creating a data pipeline to ingest thousands of errors a minute in ~80 milliseconds, the benefits of pjax, how dedicated hardware ended up being half the price of cloud servers and using Ansible to configure all of the servers.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Peter Kazarinoff goes over deploying Jupyter Hub on DigitalOcean with Ansible. It’s running on a single $40 / month DigitalOcean server for his 24 students. He’s been doing this since summer 2018.
Peter talks us through what Jupyter notebooks are and what Jupyter Hub does, the process of learning DevOps related tasks to deploy a project he didn’t write, his journey of automating the process with Ansible and how it’s ok to make mistakes along the way.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Brett Kromkamp talks about building an open source knowledge management tool with Flask and Python. It’s running on a single $10 / month Linode server and has been up and running since February 2020. It already has 200+ users.
Brett goes over how a graph database model fits perfectly for modeling knowledge, an open source Topic map library he wrote in Python, the power and simplicity of Flask, the value of keeping an eye on your external dependencies and a whole lot more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Ty Cooper goes over building a cryptocurrency powered e-commerce store with Flask and Python. It’s hosted on Firebase along with PythonAnywhere and has been up and running since October 2019.
Ty talks about the challenges of accepting cryptocurrency (specifically Ethereum), how he hosts the site using Firebase and PythonAnywhere, why he chose those services, the value of end to end tests using Selenium, the benefits of working with someone else instead of trying to do everything alone and more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Scott Johnson talks about building a Covid-19 case tracking / anonymous survey / information site using Ruby on Rails. It’s all hosted on DigitalOcean using the Hatchbox.io service (it’s load balanced across 2 servers).
We talked a lot about using Jumpstart Pro, Hatchbox, working with team mates in the DOD and iterating on a project super quickly. The app’s initial release was created in less than 2 days and it’s currently serving 100,000+ visitors a day.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Seth Black goes over building a webcomic platform with Flask and Python. It runs on a multi-node Docker Swarm cluster on DigitalOcean and has been up and running since 2010. It gets up to 20,000+ visitors a day during traffic spikes.
Seth talks about the value of using nginx to cache Flask responses to keep the site from getting a hug of death from Reddit. He also talks about using nginx as a load balancer, running Docker Swarm, maintaining a web app that has been running for 10+ years, creating a flexible and robust deployment pipeline with GitHub Actions as a solo developer and a whole lot more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Francisco Barcena goes over building an internal food order processing system for the city of Los Angeles, CA with Flask and Python. It’s hosted on a single DigitalOcean server and has been up and running since 2016.
Francisco talks about developing a freelance project for a client as a solo developer, scraping the USDA’s site, working with Flask-SocketIO to create a real-time ordering service and getting everything up and running on a single server without using Docker, CI or configuration management tools.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Adam Conrad goes over building a Slack bot service with Phoenix and Elixir. It’s hosted with Gigalixir for about $50 / month and has been up and running since mid 2018.
Adam talks about the wonderful Elixir community along with how Elixir helps him manage a bunch of concurrent tasks for his service. He also goes over a number of features that you get from using Gigalixir to host your Elixir projects.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Nick Gregory walks us through what it’s like building Vortex Weather which uses Flask and Python to help understand the weather. It’s hosted on bare metal servers running in a colo on top of a self managed Kubernetes cluster.
Nick goes into detail on having to manage 750+ GB of data that needs to be recycled every 2 days and having his own servers with a combined, 24 physical CPU cores, 128+ GB of RAM and 10+ TB of disk space. The app is open source and it’s his side project, so he also talked about tips on how to manage his time and enforce self imposed deadlines.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Eric Meadows-Jönsson goes over building the Hex.pm site and surrounding services which was built using Phoenix and Elixir. It’s hosted on Google Cloud using their managed Kubernetes service (GKE). It’s been up and running since early 2014.
Eric talks all about creating a highly available package manager for Elixir, the value in breaking out independent services, working with Google’s managed Kubernetes service, keeping administrative tasks simple, his struggles with Stripe’s SCA and more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Henry Popp goes over building a platform to help explore your personal network which was built using Phoenix and Elixir. It’s hosted on Google Cloud using a self managed Kubernetes cluster. It’s been up and running since September 2019.
Henry went into great detail about the value of using a service oriented architecture, DDD, event driven design and running a self managed Kubernetes cluster. There’s a lot of great insights in this episode around general code design and scaling that apply to any web framework.
CrashLoopBackOff error with KubernetesThis episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Julien Blanchard goes over building Smart Music which uses a combination of Rails, Phoenix and .NET Core. It has roughly half a million users and it’s all hosted on AWS with EKS, ECS and Elastic Beanstalk. It’s been up and running since 2016.
There’s around 20 developers working on the project. We talked about managing git repos with a few apps, TDD, using GraphQL with Phoenix, contexts, multiple databases with Rails, InfluxDB, GitHub Actions and tons more.
ex_aws Elixir libraryThis episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Charley Stran goes over building the developer.va.gov API with Ruby on Rails and React. It’s running on 10+ auto scaling EC2 instances on AWS GovCloud and has been since mid-2018.
There’s around 140,000+ lines of code and ~20 developers. We covered what it’s like working on government contracts, how AWS GovCloud is different than the regular AWS platform, the code base being open source, code reviews and a whole lot more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Jack Slingerland goes over building his platform with Express / Node. It handles 2.5+ million requests a day and hosting costs about $65 / month on DigitalOcean for 2 web servers and a few other things. It’s been up and running since early 2015.
Jack wrote 100,000+ lines of code on his own in his spare time. We talked about buildings monoliths, switching from Apache to nginx during a 10 hour car ride, keeping your deployments as simple as possible (even with zero down time) and a whole lot more.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Ian Butler goes over building a collaboration tool for researchers called Scrollkeeper. Ian is all-in with AWS and hosting costs about $400 / month for a multi-node AWS ECS cluster. It’s been up and running since mid 2019.
His app is ~8,000 lines of Elixir code and there are a few things being done through AWS Lambda. We talked about ways to run various AWS services locally, auto-scaling, background workers, developing a custom caching solution and a whole lot more.
Plug.Upload goes straight to S3 to handle file uploadsThis episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Marcelo Lebre goes over building a remote job platform on remote.com. They serve about 100k+ requests a day and it’s all hosted on a small AWS ECS cluster. It’s been up and running since early 2019.
We covered a lot of ground, from using Elasticsearch to developing API based applications to Elixir’s ecosystem and everything in between. One takeaway is to be mindful of over engineering your code base and try to focus on the things that are important to your application.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Chris Oliver goes over how he builds and deploys his screencast tutorial platform called GoRails. The site handles about 2 million page views a year on a single $20 / month DigitalOcean server. GoRails has been up and running since 2014.
There’s a lot of useful nuggets of information in this episode around keeping a pulse on similar communities that you’re in. For example, Chris took a lot of inspiration from Laravel when it came to implementing the billing code for GoRails. Spoiler alert: Rails does scale.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Chase Granberry goes over running a logging platform that deals with 7+ billion log events per month. The back-end and front-end is powered by a Phoenix / Elixir application that’s running on Google Cloud (GCP).
6 pretty beefy servers power everything but for a long time it was all on 1 server. Also, Live View is being used for search results and a few counters on the web dashboard. Phoenix Tracker is being used for a cluster-wide rate limiter too. The app is open source on GitHub.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Gareth Thomas goes over running a platform that helps manage 3.5+ million students. There’s over 1,500 databases and it peaks at 65k requests per second. A legacy Zope server and a series of Flask microservices power it all on AWS Fargate.
ScholarPack been running in production since 2010. This episode is loaded up with all sorts of goodies related to running microservices at scale, handling multi-tenancy databases with PostgreSQL, aggressively using feature flags and so much more.
t3.2xlarge (8 CPU cores / 32 GB of memory) instances power the RDS databaseThis episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Dave Blakey goes over how their load balancing service (Nova) handles 33,000+ events per second across a 100+ server Kubernetes cluster that runs on both AWS and DigitalOcean. There’s a sprinkle of Serverless thrown in too.
If you ever wondered how a large scale app is developed and deployed, you’re in for a treat. Some of Nova’s clients spend $5,000,000+ a month on hosting fees. We covered everything from development best practices, how to create a scalable application architecture and how they replicate their environment across multiple cloud providers and regions.
P.S., Nova is also really useful for small sites too and they have a free tier with no strings attached, so you may want to give it a try. After this episode the first thing I thought was “wtf, why am I not using this?”. I’m going to start playing with it over the holidays for my own sites.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Junaid Kabani goes over how he built and deploys Openship which is a Shopify app that was written in Koa. The front-end uses React.
We covered a lot of ground in this episode, such as how Prisma, Apollo, Next.js and React all come together to build an app that uses Shopify’s API. There’s also quite a lot of details on the value of testing and how CI helps keep open source projects well tested.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Jamie Taylor goes over how he built Discworld Disorganizer which is a Discworld book series search engine. It’s written in .NET Core and hosted for free on Azure. It’s been running in production since 2017.
Jamie developed this app to scratch his own itch to help figure out which books he already owns. The API portion of the app is a separate app that is public and free to use. I learned a lot about the .NET eco-system and even Discworld in this episode thanks to Jamie!
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Lane Wagner goes over how he built Qvault which is an open source password manager that specializes in cryptocurrency. It’s built with Electron and has a Serverless component that uses Golang. It’s all hosted on AWS.
If you were ever wondering how Serverless works in the context of building a native or web application this episode has you covered. Lane talks about how a bunch of different AWS services all come together to make it work. We also talk about a Serverless framework called Serverless!
t2.micro since the DB is very simplenode_modules/ directoryThis episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Stetson Blake goes over how he built EarlyBrd using Flask which is a web framework written in Python. This SAAS app focuses on sending out emails and it also happens to use Stripe for subscriptions. It’s been up since March 2019.
Stetson’s motto has been to keep moving forward by writing code and making decisions instead of getting hung up in endless research loops. His set up is optimized for simplicity and to solve the problems he’s run into so far as a solo developer working on the project.
t2.micro EC2 instanceThis episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Dan Bader goes over how he built Real Python from scratch with Django which is a web framework written in Python. The site gets 4 million+ page views a month and it’s hosted on Heroku which costs about $700 USD / month.
What’s really cool about this project is Dan coded the site himself and his deploy process is very by the books which includes performing 1 person code reviews which I found to be great. We covered a lot of ground in this episode! Spoiler alert: he’s using the built-in Django admin.
standard-2x Dynos and (1) standard-1x Worker powers the whole siteThis episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Mark guides us through how he builds and deploys his video and article driven learning platform called Alchemist Camp. The site gets about 12,000+ visitors a month and it’s all hosted on a single $10 / month DigitalOcean server.
One takeaway is that you can be quite productive as a solo developer but the bar is constantly being raised for what developers need to learn. For example, at one point we talked about the new SCA workflows with Stripe since he collects payments for subscriptions.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Andrew Brown talks about how he and his team use Ruby on Rails to build an AWS certification training platform called Exam Pro. We talked about a huge range of AWS services and how they all come together to run and deploy his application.
They’ve gone all-in with AWS. Even their development environment is running on AWS using Cloud9 IDE. Exam Pro has been running in production since late 2018.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Gabriel Robertson talks about how he uses Phoenix and Elixir to build and deploy an ever changing internal web application that medical University employees, health officials and students use to access various systems and resources.
The application has a number of interesting security, up-time and browser compatibility requirements. It’s been running in production since 2017.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
In this episode of Running in Production, Nick briefly talks about the goal of this podcast which is to have developers / engineers on the show who are running any web application in production. Guests will go into why they chose their tech stack, lessons learned and everything in between.
This episode does not have a sponsor and this podcast is a labor of love. If you want to support the show, the best way to do it is to purchase one of my courses or suggest one to a friend.
En liten tjänst av I'm With Friends. Finns även på engelska.