Running in Production

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. Topics Include 2:10 – Launching an MVP after a few months of dev time as a solo developer 5:10 – Motivation for using Django and Python 7:39 – Batteries (mostly) included, using the Django Admin and Django REST Framework 10:51 – Using Stripe to build a single checkout page to buy gift cards 15:57 – It’s a monolithic app but it uses services like Airtable and Zapier 23:58 – Managing gift card funds and logic is the core of the business 30:34 – Tech stack includes SQLite and using PythonAnywhere for a host 39:50 – Cloudflare is mainly used for serving static files 42:59 – The process from development to production and secret management 49:10 – Performing hourly DB backups and using UptimeRobot for downtime notifications 54:19 – The new SCA compliant Stripe APIs are being used 58:33 – Best tips? Get your product out ASAP and be mindful of what happens if you leave 1:01:05 – Check out https://www.ethikdo.co and Antonin is also on Twitter Links ⚙️ Tech Stack django → python → airtable → bootstrap → cloudflare → discord → mailchimp → mailjet → python-anywhere → sqlite → stripe → uptime-robot → vue → zapier → 🛠 Libraries Used https://github.com/encode/django-rest-framework https://github.com/anymail/django-anymail https://github.com/zostera/django-bootstrap4 https://github.com/django-ckeditor/django-ckeditor https://github.com/python-pillow/Pillow https://github.com/peterbe/premailer Support the Show 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. Dive into Docker is a video course that takes you from not knowing what Docker is to being able to confidently use Docker and Docker Compose for your own apps. Long gone are the days of "but it works on my machine!". A bunch of follow along labs are included. Build a SAAS App with Flask is a video course where we build a real world SAAS app that accepts payments, has a custom admin, includes high test coverage and goes over how to implement and apply 50+ common web app features. There's over 20+ hours of video.

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. Topics Include 1:54 – Custom hardware appliance with an Orange Pi + USB modem 5:03 – Both the client (hardware) and server (Azure) use Flask 7:28 – Motivation for using Flask and Python 11:24 – What exactly is this hardware device and what software runs on it? 14:46 – The server side runs on 38+ Azure resources on 1 VM, provisioned by Terraform 18:23 – Docker Compose is being used in dev and production (they moved away from K8s) 20:00 – The server is running Ubuntu 18.04 LTS with 16 GB of memory / 4 CPU cores 21:37 – There’s SQLite, gunicorn and nginx but there’s no client side SSL certs 26:39 – What it’s been like working with Terraform to manage the infrastructure 29:52 – The deployment process is interesting to say the least! 35:31 – Everything that can get linted gets linted 37:14 – Accepting payments is not easy as it involves manually topping up SIM cards 44:27 – Debugging and accessing logs gets tricky on the client side 47:54 – Dealing with logs, error tracking and database backups on the server side 49:52 – Using SendGrid for sending emails and Cloudflare to handle DNS 53:21 – Best tips (Clemens)? Soft skills and focusing on making contributing code easy 55:36 – Best tips (Shaun)? Keep your tests easy to follow so you can see how something works 59:28 – If you’re interested in contributing, their code base is open source on GitHub Links 📄 References http://www.orangepi.org/ https://github.com/hadolint/hadolint https://github.com/koalaman/shellcheck https://github.com/adrienverge/yamllint ⚙️ Tech Stack flask → python → azure → cloudflare → docker → github-actions → lets-encrypt → nginx → rabbitmq → sendgrid → sqlite → terraform → ubuntu → 🛠 Libraries Used https://github.com/zalando/connexion https://github.com/celery/celery https://gunicorn.org/ https://github.com/PyCQA/flake8 https://github.com/python/mypy https://github.com/PyCQA/bandit Support the Show 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. Dive into Docker is a video course that takes you from not knowing what Docker is to being able to confidently use Docker and Docker Compose for your own apps. Long gone are the days of "but it works on my machine!". A bunch of follow along labs are included. Build a SAAS App with Flask is a video course where we build a real world SAAS app that accepts payments, has a custom admin, includes high test coverage and goes over how to implement and apply 50+ common web app features. There's over 20+ hours of video.

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. Topics Include 2:36 – It started part time but now it’s full time 4:28 – Motivation for using Python and Django mainly came down to confidence 8:05 – It’s pretty close to a monolith with a few Django apps 11:42 – Reasons for using a custom video player (looping, mirroring, etc.) 14:18 – Videos are uploaded directly to S3 with pre-signed URLs and no transcoding (yet) 19:51 – Using the Django RQ library for doing asynchronous work 21:36 – Having fun using React to write the custom video player 26:35 – Creating a first pass chat feature so students can ask questions 28:41 – Using Vagrant in development, with Ansible on a single $5 / mo DigitalOcean server 37:27 – For a web server they’re using gunicorn, nginx and Let’s Encrypt for SSL 41:27 – Using Stripe to handle payments has been a nice dev experience so far 49:16 – Using Mailgun for transactional emails and Mailchimp for email campaigns 53:59 – Mixing in jQuery as needed has been a pleasure to use, along with Webpack 55:54 – The deployment process from development to production 1:03:40 – S3 is trusted for video backups and database backups are done on every deploy 1:07:35 – Best tips? Keep learning but pick things you’re familiar with 1:10:02 – Check out their platform at https://goskillwell.com/ and they are on Instagram too Links 📄 References https://en.wikipedia.org/wiki/Acroyoga https://sendy.co https://www.cypress.io/ ⚙️ Tech Stack django → python → react → ansible → digitalocean → jquery → lets-encrypt → mailchimp → mailgun → nginx → postgres → redis → s3 → sentry → stripe → ubuntu → webpack → 🛠 Libraries Used https://github.com/boto/boto3 https://github.com/rq/django-rq https://gunicorn.org/ https://github.com/dj-stripe/dj-stripe https://www.fabfile.org/ Support the Show 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. Dive into Docker is a video course that takes you from not knowing what Docker is to being able to confidently use Docker and Docker Compose for your own apps. Long gone are the days of "but it works on my machine!". A bunch of follow along labs are included. Build a SAAS App with Flask is a video course where we build a real world SAAS app that accepts payments, has a custom admin, includes high test coverage and goes over how to implement and apply 50+ common web app features. There's over 20+ hours of video.

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. Topics Include 3:53 – There’s 2 developers and a manager who is also a database guru 6:58 – Motivation for using Django and Python 9:52 – It’s a monolithic app using Django templates with a touch of Vue + API endpoints 15:51 – Since it’s an internal app, here’s an explanation of what it does 22:52 – Celery isn’t being used but it’s on their list to start using it 26:23 – It’s a Microsoft shop using MS SQL as a database and Apache for a web server 33:19 – There’s a few beefy on-prem Windows servers and software is configured by hand 41:43 – Walking us through developing a feature in development to deploying it to prod 52:55 – Getting alerted in Slack if things go astray with the app 55:57 – Best tips? Test and log everything and try to keep up with the updates 59:02 – You can find Chris on GitHub, Twitter, Twitch (dev stream) and Instagram Links 📄 References https://bitbucket.org/product/features/pipelines ⚙️ Tech Stack django → python → vue → apache → bootstrap → jquery → mssql → slack → windows → 🛠 Libraries Used https://github.com/encode/django-rest-framework https://github.com/select2/select2 https://github.com/pytest-dev/pytest-django Support the Show 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. Dive into Docker is a video course that takes you from not knowing what Docker is to being able to confidently use Docker and Docker Compose for your own apps. Long gone are the days of "but it works on my machine!". A bunch of follow along labs are included. Build a SAAS App with Flask is a video course where we build a real world SAAS app that accepts payments, has a custom admin, includes high test coverage and goes over how to implement and apply 50+ common web app features. There's over 20+ hours of video.

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. Topics Include 3:01 – Initially building an app for 1 B2B client and designing features based on that 5:58 – Motivation for using Django and Python for this project 9:26 – Building a monolith with 14 Django apps but moving towards microservices 14:47 – Mostly server rendered Django templates but there are pieces done with Vue 20:50 – PostgreSQL is being used as a DB and a side topic about how nice TailwindCSS is 25:08 – Not using Docker and learning from the Django community when getting stuck 28:50 – Everything runs on a single DigitalOcean server using Ubuntu 18.04 LTS 32:30 – Using Gunicorn, nginx, Let’s Encrypt and Cloudflare 39:38 – Not waiting out for the best tools and being able to evolve your tech stack 41:58 – Deployment process from start to finish 46:14 – DigitalOcean’s alerting tools are enabled along with Uptime Robot 51:23 – Using DigitalOcean’s server snapshots for complete backups 56:05 – Best tips? Try to get your app in front of your customers as soon as possible 58:40 – Dave is on Twitter @davemerwin and check out their site https://purebluedesign.com/ Links 📄 References https://en.wikipedia.org/wiki/Health_Insurance_Portability_and_Accountability_Act https://tailwindcss.com/ https://gist.github.com/davemerwin/75420b25ae8a975ec6916d5141eb39d4 (server set up) ⚙️ Tech Stack django → python → vue → cloudflare → digitalocean → lets-encrypt → nginx → nuxt → postgres → systemd → ubuntu → uptime-robot → 🛠 Libraries Used https://gunicorn.org/ Support the Show 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. Dive into Docker is a video course that takes you from not knowing what Docker is to being able to confidently use Docker and Docker Compose for your own apps. Long gone are the days of "but it works on my machine!". A bunch of follow along labs are included. Build a SAAS App with Flask is a video course where we build a real world SAAS app that accepts payments, has a custom admin, includes high test coverage and goes over how to implement and apply 50+ common web app features. There's over 20+ hours of video.

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. Topics Include 1:28 – Creating a custom platform lets Jon come up with new blog post / course ideas 4:51 – It has roughly 15,000 active users and he built 2 separate platforms initially 11:02 – Motivation for using Golang and figuring out when to add new features 13:17 – Using Gumroad licenses to handle course access for users 15:19 – It’s a monolithic app that was rewritten a few times to be ~15k LOC 25:09 – Sweating over hello world requests per second benchmarks isn’t worth it 28:24 – Server rendered templates using Golang’s template package + gotchas 33:46 – Using TailwindCSS with PostCSS and Vimeo / YouTube for the videos 36:56 – Using Golang’s built in web server and SQLite as a primary database 39:00 – Only tracking stats about users that Jon plans to act on 43:01 – Caddy sits in front of the Golang web server and deals with SSL certificates 44:57 – Docker is being used in the React / PostgreSQL code update 49:13 – Working with DigitalOcean block storage volumes and Spaces (S3-like object store) 55:23 – The single $5 / month server is running Ubuntu 14.04 LTS and was set up manually 59:11 – The deploy process from development to production 1:04:25 – Spend your innovation tokens wisely 1:06:22 – How Jon assembles his courses with data structures in his source code 1:12:24 – Daily backups of the droplet and how Jon deals with logging / errors / email 1:18:09 – Best tips? Start simple and really stick to it 1:19:13 – Jon is on Twitter at @joncalhoun and check out his site at https://www.calhoun.io/ Links 📄 References https://github.com/heartcombo/devise https://github.com/gorilla https://gobuffalo.io/en/ https://mcfunley.com/choose-boring-technology ⚙️ Tech Stack golang → react → caddy → convertkit → digitalocean → docker → gumroad → logdna → mailgun → slack → sqlite → systemd → tailwindcss → ubuntu → vimeo → 🛠 Libraries Used https://github.com/gorilla/mux https://gorm.io/ Support the Show 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. Dive into Docker is a video course that takes you from not knowing what Docker is to being able to confidently use Docker and Docker Compose for your own apps. Long gone are the days of "but it works on my machine!". A bunch of follow along labs are included. Build a SAAS App with Flask is a video course where we build a real world SAAS app that accepts payments, has a custom admin, includes high test coverage and goes over how to implement and apply 50+ common web app features. There's over 20+ hours of video.

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. Topics Include 3:25 – Measuring key business metrics with OKR and KPI analysis 6:25 – Motivation for choosing Django as the back-end for the native mobile app 13:29 – From trying to learn GitOps and Kubernetes to using Heroku in the end 17:53 – Using Django templates, Django REST Framework and Websockets 28:29 – They are using PostgreSQL and Heroku’s APS for background jobs for now 33:00 – Using (1) Heroku hobby Dyno and aiming for a 90+ Lighthouse score 38:57 – Using the first paid plan of Heroku’s PostgreSQL and a few Heroku add-ons 49:23 – Interesting Python / Django packages used to help build this service 55:23 – The process of getting a feature developed locally and pushing it to production 1:04:13 – Uploading user files to S3 and working on an automated test suite 1:11:42 – Best tips? Try to validate your idea before coding it to completion 1:14:55 – Check out https://litt.nyc/, they are on Instagram / Twitter too Links 📄 References https://en.wikipedia.org/wiki/OKR https://en.wikipedia.org/wiki/Performance_indicator https://stackoverflow.com/q/61552070 https://developers.google.com/web/tools/lighthouse https://12factor.net/ ⚙️ Tech Stack django → python → react → bootstrap → heroku → papertrail → postgres → pusher → s3 → sendgrid → 🛠 Libraries Used https://github.com/encode/django-rest-framework https://pypi.org/project/django-geo/ https://github.com/evansd/whitenoise https://github.com/psf/black https://github.com/boto/boto3 Support the Show 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. Dive into Docker is a video course that takes you from not knowing what Docker is to being able to confidently use Docker and Docker Compose for your own apps. Long gone are the days of "but it works on my machine!". A bunch of follow along labs are included. Build a SAAS App with Flask is a video course where we build a real world SAAS app that accepts payments, has a custom admin, includes high test coverage and goes over how to implement and apply 50+ common web app features. There's over 20+ hours of video.

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. Topics Include 3:34 – Building 3 different MVPs in 6 months to satisfy his client’s needs 6:33 – Motivation for using Django, how the 3D model viewer works and GDPR compliance 12:52 – It’s a monolithic app that runs on 2 Heroku Dynos and it uses Celery 16:42 – The app it about ~1k lines of Python code and uses Material Design Lite 21:24 – Docker is being used in development and production and Jesse likes it 24:47 – Both Heroku Dynos are the hobby (paid) tier with the free tiers of Postgres and Redis 33:13 – Database backups are run through Celery’s periodic tasks with django-dbbackup 34:54 – The deploy process from dev to prod when using Heroku 40:06 – Best tips? Try to learn best practices when you can from podcasts, books, courses, etc. 45:45 – Check out Jesse’s consultancy’s site at https://www.creon-it.de/ Links 📄 References https://docs.djangoproject.com/en/3.0/topics/class-based-views/ https://getmdl.io/ https://djangochat.com/ ⚙️ Tech Stack django → python → docker → heroku → papertrail → postgres → redis → s3 → 🛠 Libraries Used https://github.com/pennersr/django-allauth https://github.com/evansd/whitenoise https://github.com/celery/celery https://gunicorn.org/ https://github.com/django-dbbackup/django-dbbackup https://github.com/pytest-dev/pytest Support the Show 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. Dive into Docker is a video course that takes you from not knowing what Docker is to being able to confidently use Docker and Docker Compose for your own apps. Long gone are the days of "but it works on my machine!". A bunch of follow along labs are included. Build a SAAS App with Flask is a video course where we build a real world SAAS app that accepts payments, has a custom admin, includes high test coverage and goes over how to implement and apply 50+ common web app features. There's over 20+ hours of video.

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. Topics Include 3:03 – The MVP took about a week or 2 to make thanks to Django 6:24 – Prior to Covid-19, Cory was making about $2,000 / month selling $8 templates 9:40 – Processing the guest list that users upload and a few useful libraries 13:45 – It’s a monolithic application with a React front-end split for UI heavy pages 19:10 – The tech stack includes PostgreSQL, gunicorn, nginx, Redis and Let’s Encrypt 23:33 – This app and others are hosted on Linode with 2 CPU cores and 4 GB of memory 25:30 – Using Ubuntu on the server and moving towards using Ansible to configure it 29:30 – Using Linode and StatusCake for alerts on system health and monitoring 32:57 – Stripe is used to handle payments but have customers ever asked for PayPal support? 35:03 – Walking through the deployment process from development to production 42:27 – Disaster recovery is handled by automated backups through Linode 44:37 – Best tips? Avoid over engineering things and don’t chase perfection 47:14 – You can find Cory on Twitter @czue and his site is at https://www.coryzue.com/ 47:52 – Check out Cory’s SAAS building tool for Django at https://www.saaspegasus.com/ Links 📄 References https://en.wikipedia.org/wiki/Place_card https://en.wikipedia.org/wiki/You_aren%27t_gonna_need_it (YAGNI) ⚙️ Tech Stack django → python → react → ansible → lets-encrypt → linode → mailchimp → mailgun → nginx → postgres → redis → sentry → statuscake → stripe → supervisor → ubuntu → 🛠 Libraries Used https://github.com/pyexcel/pyexcel https://github.com/pygments/pygments https://github.com/jazzband/pip-tools https://gunicorn.org/ https://github.com/anymail/django-anymail Support the Show 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. Dive into Docker is a video course that takes you from not knowing what Docker is to being able to confidently use Docker and Docker Compose for your own apps. Long gone are the days of "but it works on my machine!". A bunch of follow along labs are included. Build a SAAS App with Flask is a video course where we build a real world SAAS app that accepts payments, has a custom admin, includes high test coverage and goes over how to implement and apply 50+ common web app features. There's over 20+ hours of video.

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. Topics Include 3:43 – Building a custom CMS / Django admin and open sourcing the Scarlet library 9:16 – Hundreds of thousands of trains, cars and product SKUs are on the CMS driven site 13:27 – Motivation for making a monolithic Django app instead of using Magento 16:32 – Using Solr to full text search through hundreds of thousands of products 20:30 – It’s primarily a server rendered app using Django templates and Ember 25:04 – Master / slave PostgreSQL set up using RDS and they use other AWS resources 29:42 – Load balancing, dealing with thousands of visitors and heavily caching responses 33:53 – Writing a custom open source framework called red-fab-deploy to deploy the app 37:59 – The EC2 web servers are using Ubuntu and have t2.medium’ish specs 41:35 – Rsync’ing files over to the server, the entire deploy process and testing 50:16 – Backing up admin uploaded files and the database, along with using Sentry for errors 54:09 – Dealing with secret keys and code reviews while self hosting BitBucket 56:44 – Best tips? Start with a base application and server architecture to help estimates 58:44 – Also know when to ask for help (such as hiring a contractor or asking questions) 1:00:24 – You can find Mark on Twitter @chick3ndinn3r Links 📄 References https://nvie.com/posts/a-successful-git-branching-model/ ⚙️ Tech Stack django → python → ember → aws → cloudfront → elasticache → nginx → postgres → rds → redis → route53 → s3 → sentry → solr → ubuntu → webpack → 🛠 Libraries Used https://github.com/django-haystack/django-haystack https://gunicorn.org/ Support the Show 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. Dive into Docker is a video course that takes you from not knowing what Docker is to being able to confidently use Docker and Docker Compose for your own apps. Long gone are the days of "but it works on my machine!". A bunch of follow along labs are included. Build a SAAS App with Flask is a video course where we build a real world SAAS app that accepts payments, has a custom admin, includes high test coverage and goes over how to implement and apply 50+ common web app features. There's over 20+ hours of video.