Running in Production

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. Topics Include 3:05 – Rewriting an existing Django app into a new Django app with 90%+ test coverage 8:49 – Async features in Django and not using Celery 12:07 – A breakdown of gRPG and Protobuff 15:13 – The platform has about 300 daily active users, dead locks and monitoring 17:47 – A monolithic Dockerized app with 4 developers working on the project 20:05 – There’s only an API back-end in Django, the front-end is a native iOS app 22:51 – The SimpleJWT and Redis / ARedis libraries were very helpful in Python 27:04 – The phonenumbers library showed to be very useful too 30:02 – Using Docker Compose in development with a multi-stage Dockerfile 32:22 – Using Elastic Beanstalk in production and a number of other tech choices 38:06 – There’s no configuration management tools being used, but that’s next 42:09 – Most AWS instance types they are using are medium size 44:00 – The process to deploy code from development to production 49:20 – Dealing with backing up user generated data and encrypting messages 54:06 – Getting alerted of errors through Slack and email 58:01 – Best tips? When in doubt stick to the Zen of Python 1:00:53 – You can find Dash on GitHub and Twitter Links 📄 References https://en.wikipedia.org/wiki/Protocol_Buffers https://www.elastic.co/observability https://python-poetry.org/ https://www.python.org/dev/peps/pep-0020/ (The Zen of Python) ⚙️ Tech Stack django → python → swift → aws → circle-ci → docker → elasticache → nginx → rabbitmq → rds → redis → route53 → sentry → slack → terraform → 🛠 Libraries Used https://github.com/encode/django-rest-framework https://grpc.io/docs/languages/python/basics/ https://developer.apple.com/metal/ https://github.com/SimpleJWT/django-rest-framework-simplejwt https://github.com/andymccurdy/redis-py https://github.com/NoneGG/aredis https://github.com/daviddrysdale/python-phonenumbers https://github.com/theskumar/python-dotenv 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, 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. Topics Include 3:35 – Motivation for using Flask and Python 5:38 – Vue, MongoDB, Celery and other libraries / tools being used 8:28 – Dealing with a schemaless database 10:04 – It’s a monolithic app that uses Flask blueprints and dealing with permissions 14:58 – Each tenant / customer of the app gets their own virtual private server 17:24 – Vue is mixed in where needed, the app is not a dedicated API only back-end 22:29 – Parcel is being used to bundle assets and SASS is being used too 24:26 – Docker isn’t used yet but nginx + Let’s Encrypt and Ansible is being used 27:23 – Multiple hosting providers are used (AWS, Linode) with varied server specs 30:03 – uwsgi is being used mainly due to certain app features using websockets 32:39 – Ubuntu LTS is happily being used along with configuring the servers with Ansible 36:05 – The deploy process from development to production 41:16 – Environment variables for secrets and rate limiting with nginx 45:18 – Handling database backups for MongoDB 47:28 – Getting notified of system health issues with alarms and alerts 51:00 – Best tips? Keep moving forward because failure is always better than regret 53:50 – Nidal is on Twitter, GitHub and also has an agency at https://www.level09.com/ Links 📄 References https://mitogen.networkgenomics.com/ansible_detailed.html ⚙️ Tech Stack flask → python → vue → ansible → aws → cloudflare → lets-encrypt → linode → mongodb → nginx → parcel → redis → systemd → ubuntu → uptime-robot → websockets → 🛠 Libraries Used https://github.com/beautify-web/js-beautify https://github.com/xhtml2pdf/xhtml2pdf https://github.com/MongoEngine/mongoengine https://github.com/celery/celery https://github.com/sh4nks/flask-caching https://github.com/unbit/uwsgi https://github.com/zeekay/flask-uwsgi-websocket 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, 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. Topics Include 3:59 – Building a beta version of the site during a 4 day hackathon 5:38 – Motivation for picking Django and Python 10:11 – Leaning heavily on the built in Django admin and other libraries 12:24 – Mostly server rendered Django templates with a touch of React 16:03 – It’s mostly a monolithic app but it has a few services pulled out 20:54 – PostgreSQL is the main database and Celery / Redis is heavily used 24:58 – gunicorn + Caddy, Route53 for DNS and a load balancer, Docker end to end 27:45 – Tens of thousands of lines of code, ~3,500 files and good test coverage 31:11 – Webpack is being used to handle the front-end assets (SASS and ES6 JS) 34:36 – Static files are cached on CloudFront and in general development is pretty hard 39:07 – RDS is being used and the production web app has 4 vCPUs & 16GB of RAM on EC2 42:46 – New Relic, PagerDuty and Sentry are being used for monitoring and alerts 46:11 – There’s no configuration management tools being used to set up the EC2 server 48:13 – Going from developing a feature to deploying it into production 53:56 – RDS is configured for backups and there’s a lot of backing up in general 55:39 – Storing ~200k questions each having 10-20 DB rows + 120k registered users 56:32 – Their AWS bill fluctuates between $2,000 and $3,000 USD per month 58:29 – Best tips? There’s a lot to learn out there but focus on keeping your users happy 1:00:28 – Want to volunteer? Contact them at hello@careervillage.org 1:01:04 – CareerVillage.org is on Twitter, facebook and Instagram - so is Jared Links 📄 References https://www.atlassian.com/git/tutorials/comparing-workflows/gitflow-workflow https://en.wikipedia.org/wiki/Chaos_engineering#Chaos_Monkey ⚙️ Tech Stack django → python → react → aws → caddy → cloudfront → docker → elasticache → env-key → jenkins → lambda → metabase → new-relic → pagerduty → postgres → rds → redis → route53 → s3 → sentry → slack → ubuntu → webpack → 🛠 Libraries Used https://github.com/celery/celery https://github.com/encode/django-rest-framework https://github.com/Suor/django-cacheops https://github.com/benoitc/gunicorn https://github.com/PyCQA/flake8 https://github.com/jazzband/django-debug-toolbar 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, 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. Topics Include 4:26 – Motivation to rewrite the prototype from Java to Phoenix and Elixir 6:45 – Live View likely would have been used if it were around when they started 9:17 – 30+ microservices in 1 git repo and deployment isn’t really a pain 12:46 – This Stacker service is pretty big with about 90 Elixir modules 18:06 – On the front-end it’s just a little bit of vanilla Javascript 21:44 – Useful libraries in their mix.exs file 23:59 – Most of the other services are written in Ruby (for now) 25:25 – Running on Heroku, but moving to AWS with Docker and Kubernetes with EKS 28:32 – Terraform is used to manage their infrastructure as code with Circle CI 32:09 – Load balancers, AWS API Gateway and using Lambda for backups 34:09 – Sentry for error reporting and an ELK stack for viewing logs 34:55 – Deploying code from development to running live on the Kubernetes cluster 40:36 – Backups are handled by Amazon’s managed services 42:59 – Best tips? Don’t be afraid to jump into OTP and leverage process state 45:31 – Sascha is on Twitter, he has a personal site and Better Doc is hiring Links 📄 References https://github.com/phoenixframework/phoenix_live_view https://aws.amazon.com/elasticsearch-service/the-elk-stack ⚙️ Tech Stack phoenix → elixir → aws → circle-ci → docker → eks → elasticache → elasticsearch → heroku → kafka → kubernetes → lambda → redis → sentry → serverless → slack → terraform → 🛠 Libraries Used https://github.com/bitwalker/distillery https://github.com/rrrene/credo https://github.com/edgurgel/httpoison 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, 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. Topics Include 6:06 – Motivation for choosing Phoenix and Elixir 10:34 – The MVP didn’t require too many changes to make it deployable 13:43 – It’s an open source monolithic app in 1 git repo and it doesn’t use contexts 17:35 – Gerhard was happy to see it was a monolithic app when it came to deploying it 21:09 – A few useful libraries that help power the podcast CMS 24:09 – Using embedded schemas for handling email subscription settings 25:19 – Using Docker but Jerod hasn’t gone all-in with it in development 33:47 – It’s mostly server side templates with sprinkles of JavaScript and Turbolinks 37:45 – Choosing not to use Live View because Turbolinks is working at the moment 41:51 – nginx, Linode’s load balancer, Fastly as a CDN and handling metrics 47:42 – Motivation for choosing Linode and using their Kubernetes Engine 54:42 – Serving about 200 requests per minute and how caching is done with ETS 59:54 – Creating very thin wrapper modules for certain libraries when it makes sense 1:02:36 – The deployment process from development to production 1:08:29 – What was it like to transition to using Kubernetes? 1:11:45 – Polling for new versions of the app instead of giving CI the keys to the kingdom 1:13:38 – Dealing with inserting secrets into the app through Kubernetes 1:17:48 – The embodiment of dev and ops working very well together 1:19:01 – Database backups, making small changes and health checks 1:27:43 – Best tips (Jerod)? Team up with people who fill in your knowledge gaps 1:30:16 – Best tips (Gerhard)? Be honest about what you like and enjoy doing 1:31:57 – Gerhard has a personal site, Jerod is on Twitter & check out https://changelog.com/ Links 📄 References https://twitter.com/adamstac https://github.com/edeliver/edeliver https://www.youtube.com/watch?v=0hd0FPd47II (3h+ podcast on Changelog’s history) https://github.com/thechangelog/changelog.com/blob/master/mix.exs https://skaffold.dev/ https://changelog.com/posts/why-we-chose-turbolinks https://changelog.com/posts/the-new-changelog-setup-for-2020 https://www.lastpass.com/ https://www.youtube.com/watch?v=sTt-jdDEWAw (epic Predator handshake scene) https://github.com/derailed/k9s https://github.com/thechangelog/changelog.com ⚙️ Tech Stack phoenix → elixir → circle-ci → docker → fastly → grafana → kubernetes → lets-encrypt → linode → nginx → pingdom → postgres → prometheus → s3 → turbolinks → webpack → 🛠 Libraries Used https://github.com/quantum-elixir/quantum-core https://github.com/stavro/arc https://github.com/thoughtbot/bamboo https://github.com/thoughtbot/ex_machina https://github.com/asaaki/cmark.ex https://github.com/drewolson/scrivener https://github.com/sasa1977/con_cache 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, 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. Topics Include 3:28 – Being profitable early on and spinning up a VPS for each dedicated account 6:22 – 4-5 million browser sessions per day, with peaks up to 30+ million 8:03 – Motivation for choosing Express and Node 14:31 – The vm2 library helps a ton to eliminate things like remote code execution 19:39 – There’s 4 main parts to the app (containers, load balancer, API server and Redis) 25:12 – For the pay as you go accounts, you top your account off with credits 27:12 – Redis is their primary database 31:29 – Using official SDKs are nice, especially if they are written in TypeScript 32:43 – Preact is being used on the front-end as an alternative to React 37:22 – Docker is being used in development and production 42:01 – Testing Stripe locally in development along with nginx (it’s not Dockerized) 52:36 – Using DigitalOcean to host everything (droplets, cloud firewall and floating IPs) 57:40 – Files like PDFs are dynamically served, they are not static files 59:34 – All of the servers run Ubuntu 20.04 LTS 1:01:41 – There’s close to 1,000 servers running at any given time 1:05:37 – The deployment process from development to production (includes Dokku) 1:11:51 – A custom Node CLI helps automate quite a bit of deployment tasks 1:14:00 – The core tool is open source on GitHub 1:18:38 – Email notifications get sent out if any of the servers get overloaded 1:23:01 – An endless sea of text messages from 500s while on vacation in Bora Bora 1:25:44 – Best tips? Know when to pivot and try to talk with folks who cancel your service 1:29:58 – Joel is on GitHub, checkout https://www.browserless.io/ along with @browserless Links 📄 References https://developers.google.com/web/tools/puppeteer https://github.com/tj?tab=repositories https://openresty.org/en/ https://www.nginx.com/products/nginx-amplify/ ⚙️ Tech Stack express → node → preact → digitalocean → docker → graphql → lets-encrypt → namecheap → netlify → nginx → redis → sendgrid → stripe → ubuntu → websockets → 🛠 Libraries Used https://github.com/http-party/node-http-proxy https://github.com/patriksimek/vm2 https://github.com/dokku/dokku 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, 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. Topics Include 4:48 – Motivation for using Phoenix and Elixir to build the licensing server 7:36 – Processing millions of background jobs a day with PostgreSQL as a queue back-end 11:55 – Live View powers the demo page and using prefixed jobs to keep things separate 16:43 – It’s almost always worth using a dedicated background tool even in Elixir 18:14 – Keeping Live View and Phoenix updated to their latest stable versions 22:26 – How licensing for the pro version works at the Hex package level 27:03 – Docker is being used in production but not development 31:38 – Challenges of getting Phoenix to reload files outside of the main code base 34:04 – A bunch of useful libraries that were used to help build the pro site 43:00 – Building out a custom admin to help manage customers, plus custom analytics 46:41 – About $100 a month to host everything on Heroku (2 Dynos + Postgres) 50:47 – The deployment process from development to production 56:21 – Backing up the database is handled very nicely by Heroku 1:00:03 – Best tips? Try to keep as much as you can open and contributable by others 1:00:34 – Check out Parker on Twitter and GitHub, his wife is on GitHub too Links 📄 References https://hex.pm/docs/private https://asdf-vm.com/#/ https://hexdocs.pm/plug/Plug.BasicAuth.html ⚙️ Tech Stack phoenix → elixir → docker → github-actions → heroku → honeybadger → postgres → sendgrid → stripe → tailwindcss → 🛠 Libraries Used https://github.com/sorentwo/oban https://github.com/phoenixframework/phoenix_live_view https://github.com/elixirs/faker https://github.com/falood/exsync https://github.com/thoughtbot/bamboo https://github.com/hexpm/hex_core https://github.com/boydm/phoenix_markdown 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, 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. Topics Include 7:28 – Motivation for moving from WordPress to using Flask and Python 10:55 – It’s a video course platform to learn Python through Fantasy Football 13:08 – A couple of useful Python / Flask libraries that helped move things along quickly 16:07 – The React front-end and Flask API back-end are in the same repo 21:58 – PostgreSQL (prod) / SQLite (dev) are being used and the app is hosted on Heroku 27:56 – Tech stack recap and how Stripe is implemented with PaymentIntents 32:38 – Sending emails out with Mailchimp and gmail’s SMTP servers 35:34 – Everything is running on the hobby tier of Heroku for $7 / month 38:27 – The deployment process from development to production 41:04 – Database backups happen every 24 hours and manually before DB migrations 45:36 – Maybe implementing a custom forum into the platform later 48:44 – Best tips? Use your bread and butter skills to get to market as soon as possible 50:16 – Check out the platform or find FFDataPros on Twitter and GitHub Links 📄 References https://learnpythonthehardway.org/ https://jupyter.org/ ⚙️ Tech Stack flask → python → react → gulp → heroku → mailchimp → postgres → sqlite → webpack → 🛠 Libraries Used https://github.com/python-pillow/Pillow https://github.com/maxcountryman/flask-login https://www.sqlalchemy.org/ 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, 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. Topics Include 3:58 – Motivation to rewrite the app in Django and Python 6:29 – It’s 1 monolithic Django app that’s split up with Django apps 11:12 – Django REST Framework is used as an API back-end with React on the front-end 15:48 – It’s about 200k lines of Python and 78k lines of JS split across 2 git repos 18:13 – Picking the right NLP Python library (he went with spaCy in the end) 23:44 – Redis is the back-end for Celery and it’s used for caching too 27:41 – Using Ant Design Pro to help manage front-end assets (which uses Webpack) 30:36 – Docker is being used for everything except nginx runs directly on the host 33:47 – It’s hosted on a single EC2 instance (free tier) on AWS running Ubuntu 18.04 LTS 41:34 – The server was set up manually by mostly following tutorials 42:40 – Using Mailgun and Sentry, also right now Creative Hire is free during early access 45:58 – The process to develop and deploy code to production 53:13 – Database backups happen about once a week and how alerts happen 56:12 – Best tips? Have a test environment and make small changes when pushing new code 58:28 – Besides their site, Creative Hire also has a Facebook page Links 📄 References https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-credits-baseline-concepts.html ⚙️ Tech Stack django → python → react → aws → circle-ci → firebase → lets-encrypt → mailgun → netlify → nginx → postgres → redis → s3 → sentry → ubuntu → webpack → 🛠 Libraries Used https://github.com/boto/boto3 https://github.com/celery/celery https://github.com/encode/django-rest-framework https://spacy.io/ https://github.com/alexfernandez/loadtest https://pro.ant.design/ https://gunicorn.org/ https://github.com/KristianOellegaard/django-health-check 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, 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. Topics Include 7:04 – Motivation to rewrite the app in Django and Python 9:24 – The Django admin and having a monolith split into 10-15 Django apps 14:59 – About 50k lines of Python code, 10k of Django templates and 10k of JS 20:38 – Interesting Python / Django libraries used in the project 28:35 – Postgres as a main SQL DB and Redis for caching + SQS & Celery for bg jobs 32:24 – Docker is being used in development, nginx + uwsgi is being used too 35:24 – Going all-in with AWS for hosting and ISO 27001 compliance 45:35 – Dealing with a massive amount of user uploads, virus scanning, etc. 48:58 – Linting the code base with Black 50:28 – Deploying code with Fabric, the Python AWS SDK and baking AMIs 55:36 – Database backups, S3 is super reliable and CloudWatch alarms 59:40 – Using Sentry for error reporting and APM solutions 1:03:06 – Best tips? Use boring technology whenever you possibly can 1:05:15 – Kye has a site with 1 blog post and he’s also on Twitter Links 📄 References https://aws.amazon.com/compliance/iso-27001-faqs/ https://en.wikipedia.org/wiki/Application_performance_management ⚙️ Tech Stack django → python → aws → backbone → cloudformation → cloudfront → cloudwatch → docker → nginx → postgres → rds → redis → route53 → s3 → sentry → ses → sns → sqs → ubuntu → webpack → 🛠 Libraries Used https://github.com/pandas-dev/pandas https://github.com/numpy/numpy https://github.com/BetterWorks/django-impersonate https://github.com/encode/django-rest-framework https://bridgekeeper.leigh.party/ https://github.com/celery/celery https://github.com/unbit/uwsgi https://github.com/psf/black/ 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.