Running in Production

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. Topics Include 2:39 – Motivation for using Ruby on Rails (and yes Rails does scale!) 3:50 – Using interactors and Action Cable with StimulusReflex 6:06 – Things to think about for using Hotwire Turbo Streams vs other solutions 10:56 – Action Cable is embedded into the main web server 12:25 – The workflow gem and how payments are handled with Stripe and PayPal 16:15 – Recently upgrading to Sidekiq Enterprise and also using flipper for feature flags 19:40 – Using Knapsack Pro to help speed up tests in CI 21:18 – Code to test radio is about 1 to 1.5 and there’s about 38k lines of non-test code 24:03 – Examples of when they’re using Sidekiq’s batching feature 26:38 – Mostly using the asset pipeline but also using Webpacker and using StimulusJS 30:07 – Most developers at Podia touch most areas of the code base 31:37 – The run down on how the site editor works and using Trix plus Active Storage 34:41 – It’s 2021 and uploads still aren’t a fully solved problem 36:57 – Handling bulk video uploads from Podia to Wistia 38:38 – PostgreSQL is the main database, Docker isn’t being used and on-boarding new devs 40:53 – How they’re using Caddy and Let’s Encrypt to link custom domains to customers 42:48 – Using Postmark for transactional emails and SparkPost for email campaigns 44:18 – Full text search with PostgreSQL and building the Podia admin dashboard 47:38 – It’s hosted on Heroku and they use the Rails Autoscale add-on 49:43 – Surviving Black Friday without any problems 51:25 – The end to end process and time to deploy code from development to production 53:01 – Gems and strategies to help run database migrations at scale 56:44 – Using Diffend to audit gems and switching from Heroku’s scheduler to Sidekiq 1:01:42 – The DB is backed up on Heroku’s schedule and everything else is backed up too 1:03:21 – Avoiding tons of third party API calls by storing certain things locally 1:05:16 – Their payment code builds upon the official Ruby SDKs from Stripe and PayPal 1:06:11 – Using Uptime Robot, Cronitor, OpsGenie and Slack for monitoring and alerts 1:09:13 – Best tips? Build a friendly team of co-workers and automate as much as you can 1:11:03 – You can find Jason on Twitter at @jmcharnes Links 📄 References https://www.speedshop.co/blog/ https://hotwire.dev/ https://courses.jasoncharnes.com/stimulus-reflex https://gorails.com/episodes/how-to-use-cable-ready https://anycable.io/ https://remoteruby.transistor.fm/113 (DHH on the Remote Ruby podcast) https://elements.heroku.com/addons/rails-autoscale https://github.com/contribsys/faktory ⚙️ Tech Stack rails → ruby → react → bootstrap → caddy → cronitor → heroku → jquery → lets-encrypt → metabase → opsgenie → paypal → postgres → postmark → redis → s3 → slack → spark-post → stripe → uptime-robot → wistia → 🛠 Libraries Used https://github.com/collectiveidea/interactor https://github.com/hopsoft/stimulus_reflex https://github.com/hopsoft/cable_ready https://github.com/geekq/workflow https://github.com/mperham/sidekiq https://github.com/jnunemaker/flipper https://github.com/KnapsackPro/knapsack_pro-ruby https://stimulus.hotwire.dev/ https://github.com/basecamp/trix https://github.com/Casecommons/pg_search https://github.com/ilyakatz/data-migrate https://github.com/ankane/strong_migrations https://diffend.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, 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. Topics Include 4:16 – Motivation for using Django and Python 6:27 – The Django admin is not being used 8:20 – Using Ansible to automate spinning up VMware based VMs 10:17 – It’s a monolithic application and it does use Django apps 12:14 – A high level overview of what the app does to help visualize it 15:14 – It’s using Django templates and they tuned a few database queries 18:19 – PostgreSQL is used for some data and maybe Celery will be used soon 21:07 – nginx is serving static files and Kubernetes’ ingress controller handles SSL certs 23:43 – Docker Compose is being used in dev and what Kubernetes has been like so far 28:42 – Pretty much all of their servers are hosted on premises 31:17 – Using Grafana, Splunk and Prometheus for logging and monitoring 34:26 – For the Linux servers, they’re running CentOS with Rancher 38:50 – The entire flow for pushing code from development to production 45:37 – Database backups and planning for disasters 51:50 – Best tips? Containerize your app quickly 55:05 – You can find Sean on GitHub, Twitter and he has a blog at https://callaway.dev Links 📄 References https://en.wikipedia.org/wiki/Active_Directory ⚙️ Tech Stack django → python → ansible → aws → centos → docker → grafana → influxdb → jenkins → kubernetes → mssql → nginx → postgres → prometheus → rancher → slack → windows → 🛠 Libraries Used https://openpyxl.readthedocs.io/en/stable/ https://gunicorn.org/ https://github.com/Lucterios2/django_auth_ldap3_ad 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, 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. Topics Include 5:05 – Motivation for using Django and Python 7:15 – The Django admin isn’t perfect but it helps save a lot of time 9:16 – Using Django Guardian and Django Rest Framework 11:05 – It’s a monolithic API back-end with 1 extra small service to handle private keys 13:12 – The back-end is about 1,000 or 2,000 lines of code 14:03 – It’ll be a small amount per month to use and all of your data will be private 16:42 – Using React on the front-end and why the back-end is an API 18:26 – The back-end will likely be open source in the future 20:35 – Developing the API back-end alongside the React + mobile app front-ends 22:04 – The site is hosted on Heroku’s free tier (including PostgreSQL too) 26:43 – The process to develop a feature and then have it be live on the site 29:55 – The database and encrypted keys are being backed up 30:45 – The Vault service is running on a $5 / month DigitalOcean server 34:01 – The server is running Ubuntu and we share a fun trip down memory lane with Gentoo 37:04 – Best tips? Discovering Vault and being able to use it to secure user data 42:54 – Check out http://passwordspace.com/ Links 📄 References https://en.wikipedia.org/wiki/Don%27t_repeat_yourself https://www.vaultproject.io/ ⚙️ Tech Stack django → python → react → digitalocean → heroku → postgres → sendgrid → ubuntu → webpack → 🛠 Libraries Used https://github.com/encode/django-rest-framework 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, 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. Topics Include 4:50 – Motivation for using Laravel and PHP over a bunch of other choices 8:20 – It’s using Laravel 6 with VueJS on the front-end for some parts 11:30 – The app will get updated to the TALL stack but not quite yet 13:04 – It’s a monolithic app in 1 git repo 16:07 – It’s mostly using Blade templates with Vue thrown in where needed 19:12 – MySQL is powering the database which is managed by RDS 21:09 – Reading in RSS feeds in background jobs and processing Open Graph images 26:07 – You need to get approved by Mubs before you can submit episodes 28:35 – Redis is powering the background jobs 33:11 – nginx / Let’s Encrypt and it’s hosted on DigitalOcean using Forge 39:06 – The deployment process from development to production 45:49 – There’s about 3k lines of PHP code and a few hundred lines of JS 47:16 – Secrets are managed through an env file that you put on your server 48:41 – Database backups happen every day and everything else is backed up too 51:38 – Sentry is in charge of exception handling and Uptime Robot for site monitoring 55:26 – Best tips? Understand the nuances of the app you’re building 56:30 – Web tech is moving fast, will HTML over the wire be main stream soon? 59:06 – Mubs has his own site at https://mubs.me and he’s on Twitter too Links 📄 References https://transistor.fm/ https://twitter.com/taylorotwell (creator of Laravel) https://twitter.com/calebporzio/ (creator of Livewire) https://twitter.com/jeffrey_way (creator of Mix / Laracasts) https://forge.laravel.com/ https://podcastindex.org/ ⚙️ Tech Stack laravel → php → vue → digitalocean → lets-encrypt → mysql → nginx → rds → redis → sentry → slack → uptime-robot → webpack → 🛠 Libraries Used https://github.com/spatie/browsershot 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, 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. Topics Include 3:55 – With no prior programming experience an MVP was shipped in 6 part time months 6:25 – Motivation for choosing Django and Python 9:02 – Gift selection involves using a 3rd party API to provide this feature 10:02 – A lot of work is done with Celery, such as scheduling future gifts 12:09 – It’s mostly using Django templates with sprinkles of vanilla JavaScript 13:44 – Dealing with non-standard payment use cases with Stripe was a challenge 17:34 – It really is vanilla JavaScript with Halfmoon for the CSS 18:32 – A few Python and Django libraries that helped move things along 20:28 – PostgreSQL is the main database and Docker is being used too 23:52 – Switching from SendGrid to AWS’ SES for sending emails out 25:10 – Why Heroku was picked to host the application and using it with Docker 28:31 – Using Sentry for error reporting and Uptime Robot for health checks 30:57 – The deployment process from development to production 32:18 – How Stripe is being tested in development and database backups 36:14 – Best tips? Keep things simple and develop your app through your customer’s eyes 39:37 – You can find Jonathan on Twitter and check out https://joyful.gifts Links 📄 References https://openai.com/ https://www.gethalfmoon.com/docs/introduction/ https://diveintodocker.com ⚙️ Tech Stack django → python → docker → heroku → namecheap → postgres → redis → sentry → ses → stripe → uptime-robot → 🛠 Libraries Used https://github.com/dj-stripe/dj-stripe https://github.com/pennersr/django-allauth https://github.com/python-pillow/Pillow https://github.com/furious-luke/django-address 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.

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. 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, 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. Topics Include 3:58 – Millions of API queries per day and 2-5 billion DNS queries per month 6:40 – How Rails, Go and Erlang are being used along with why they were chosen 12:54 – How DNS lookups happen and the importance of DDoS protection 16:40 – The Erlang service has ~10k LOC and was written before Elixir existed 21:23 – Go is responsible for a lot of glue services 24:50 – A monolithic Rails app (server rendered templates) powers the web dashboard 28:08 – Sidekiq (Enterprise), Redis, PostgreSQL and all services run on Ubuntu LTS 29:41 – For cloud hosted services they end up on AWS or Heroku depending on what it is 31:45 – There’s 2 PostgreSQL instances and only the Rails app writes to it 34:55 – nginx is sitting in front of the Rails app 35:43 – Topping out at 5-10k requests per second through the Erlang service 42:44 – You can spin things up locally with or without Docker 47:15 – Datadog is used to help view metrics and logs to detect potential issues 50:10 – What exactly is Anycast? 52:07 – Picking out hardware for their data centers (roughly 70 physical servers) 59:29 – Chef is being used to configure all of the servers 1:02:23 – What the process is like to develop something and then deploy it to production 1:07:59 – Toggling feature flags, managing database migrations at scale and API versioning 1:16:15 – How developers add new features through pull requests and then deploy code 1:21:53 – Stripe handles all of the payments for each subscription tier 1:24:26 – Handling database backups with snapshots and streaming the data offsite 1:26:45 – Bugsnag is used for error handling and logs get written to Datadog as well 1:29:16 – Everyone’s been working remotely from day 1 and there is no centralized office 1:31:39 – Best tips? Have good processes in place as you grow in size 1:34:07 – Check out https://dnsimple.com/ and you can find Anthony on Twitter Links 📄 References https://en.wikipedia.org/wiki/Anycast https://www.cloudflare.com/learning/ddos/dns-amplification-ddos-attack/ https://miro.com/ ⚙️ Tech Stack rails → ruby → erlang → golang → vue → aws → bugsnag → chef → cloudflare → datadog → docker → env-key → heroku → lets-encrypt → memcached → nginx → pingdom → postgres → redis → slack → statuspage → stripe → ubuntu → webpack → 🛠 Libraries Used https://github.com/hanami/hanami https://github.com/dnsimple/erldns https://github.com/dnsimple/dns_erlang https://github.com/wal-e/wal-e 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, 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. Topics Include 3:50 – It’s a weeknights / weekend project and dealing with 100k+ email spikes 11:42 – Motivation for using Django, choosing “boring tech” and email validation 20:08 – It’s a monolithic app in a mono repo but broken up into ~8 Django apps 27:48 – It used to be mostly a DRF API back-end with Vue on the front-end 30:04 – Storybook is a tool for developing UI components 32:06 – Useful Python / Django libraries that were helpful for this project 35:39 – Spending an innovation token on using websockets for link checking 41:10 – rq is a powerhouse for scheduling and sending emails in the background 47:35 – Dealing with issues and errors when sending emails out at scale 50:43 – Sentry and Datadog make for a great duo of services 54:19 – Using Stripe and avoiding dark patterns around subscription pausing 59:35 – A few strategies to prevent bad actors from sending email spam 1:03:09 – Reasons for going with Heroku to host most things (roughly 12 dynos) 1:12:13 – A few Heroku add-ons and plugins that are being used 1:16:37 – The deployment process from development to production 1:21:26 – Dealing with database and front-end changes with zero down time deploys 1:28:10 – Performing database backups and backing up other user uploads 1:34:45 – Getting notified of errors if something goes wrong 1:37:53 – Best tips? Framing out when and where to record things (ie. events, etc.) 1:43:19 – Using Notion to track bugs, roadmaps and collect user feature requests 1:47:23 – Justin has a personal site and check out Buttondown Links 📄 References https://en.wikipedia.org/wiki/Click-through_rate (CTR) https://mcfunley.com/choose-boring-technology https://storybook.js.org/ https://tailwindcss.com/ https://github.com/heroku/heroku-pg-extras https://github.com/nickjj/flask-pg-extras https://12factor.net/ ⚙️ Tech Stack django → python → vue → datadog → fathom → github-actions → heroku → mailgun → notion → postgres → postmark → rds → redis → s3 → sentry → ses → slack → statuspage → stripe → webpack → 🛠 Libraries Used https://gunicorn.org/ https://github.com/encode/django-rest-framework https://github.com/evansd/whitenoise https://github.com/rq/rq https://github.com/prettier/prettier https://github.com/eslint/eslint https://github.com/psf/black 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, 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. Topics Include 2:59 – Converting an older PHP app into Django and motivation for picking Django 6:13 – Switching from Django templates to a DRF API back-end with a React front-end 10:58 – Webpack is being used to bundle all of the assets 12:34 – Hosted on DigitalOcean, gunicorn and nginx is being used, plus cron jobs too 15:09 – Switching from PostgreSQL back to SQLite and being productive 17:47 – Useful Python and Django libraries that helped get things going 19:56 – nginx is serving SSL certs created by Let’s Encrypt and picking DigitalOcean 26:03 – The server was set up by hand and he also uses WSL on Windows for local testing 27:30 – What it’s like to deploy a new feature from development to production 32:37 – Database backups are done manually and also by DigitalOcean’s backup feature 36:34 – Database migrations are kind of a pain 39:09 – Best tips? Don’t be afraid to read other people’s source code 42:08 – You can find Denis on GitHub at https://github.com/Denis-Step/ Links 📄 References https://material-ui.com/ https://nickjanetakis.com/blog/a-recycled-ip-address-caused-me-to-pirate-390000-books-by-accident ⚙️ Tech Stack django → python → react → digitalocean → lets-encrypt → nginx → sqlite → ubuntu → webpack → 🛠 Libraries Used https://github.com/encode/django-rest-framework https://material-table.com https://gunicorn.org/ https://github.com/omab/django-social-auth https://github.com/pennersr/django-allauth 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, 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. Topics Include 1:35 – Motivation for using Phoenix, Elixir and Live View 4:14 – How the site works, it saves data to a combination of PostgreSQL and the file system 5:48 – The experience of developing the app with Phoenix Live View 8:42 – Adding features quickly based on user feedback 11:13 – It’s an open source monolithic code base sitting in 1 git repo on GitHub 14:43 – nginx is sitting in front of the cowboy server and terminals SSL 16:57 – It’s hosted on DigitalOcean for $20 / month (2 vCPUs and 4 GB of RAM) 18:56 – The OS is Ubuntu 20.04 LTS and DigitalOcean’s automated backups are on 20:17 – The server was set up and configured manually without using Elixir releases too 22:36 – The deployment process from development to production 26:41 – The BEAM takes about 5 seconds to restart which is a bit of down time 28:50 – DigitalOcean’s Cloud Firewall is being used along with their monitoring tools 32:00 – nginx is taking care of basic rate limiting by IP address 34:20 – Best tips? Phoenix is a great choice for side projects but beware of websockets 36:11 – Not having end to end tests before launching was kind of a mistake 37:34 – Check out the site at https://textdb.dev/ Links 📄 References https://news.ycombinator.com/item?id=23948234 https://www.youtube.com/watch?v=MZvmYaFkNJI (Real-time Twitter clone Live View demo) https://applitools.com/wp-content/uploads/2019/05/pasted-image-0.png https://en.wikipedia.org/wiki/BEAM_(Erlang_virtual_machine) https://github.com/artilleryio/artillery ⚙️ Tech Stack phoenix → elixir → digitalocean → dnsimple → lets-encrypt → nginx → open-source → postgres → ubuntu → 🛠 Libraries Used https://github.com/phoenixframework/phoenix_live_view 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.