Running in Production

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. Topics Include 1:45 – High level overview of the hosting platform 7:01 – Splitting up compute resources for enterprise clients 8:44 – Motivation for choosing Go for a few of the back-end services 11:24 – Feeding data to the web dashboard with MongoDB, ECS, a load balancer and Go 15:53 – The Go proxy service was built using the standard library (no 3rd party libraries) 17:46 – Differences between the free and paid plans 22:49 – Displaying a custom page if your Meteor app happens to be down 26:28 – Going over a few services, starting with the Docker image builder 31:18 – The Go services are in a mono repo but they can be individually deployed 33:36 – The next service is the scheduler which is custom built 41:49 – How the web dashboard gets updated from events on the back-end 47:08 – The last service we’ll cover is for registering SSL certificates with Let’s Encrypt 50:21 – Monitoring is very important and they’re using Datadog, plus being on-call 54:26 – Postmark and SendGrid are both used to send emails 56:23 – Payments are handled through Recurly 1:00:28 – Loggly is used for logging and a bit of analytics 1:04:08 – Handling a lot of incoming notifications and making sense out of alerts 1:08:05 – Choosing AWS for hosting everything and using ECS over EKS 1:11:20 – It’s hosted across multiple AWS regions (Virginia, Ireland and Sydney) 1:15:55 – The open source side of Meteor is very very important 1:17:49 – How Terraform is being used to manage their infrastructure 1:20:31 – ScaleGrid is used to host their MongoDB instances 1:22:29 – How clients store their secrets 1:24:15 – How deployments are handled from development to production 1:32:34 – All data is backed up on a regular basis with lots of redundancy 1:36:01 – Handling big traffic spikes with little warning 1:38:38 – Best tips? Monitor everything and avoid premature optimization 1:41:43 – Check out Filipe on Twitter, his coding education platform and YouTube channel Links 📄 References https://www.meteor.com/ https://www.tinycapital.com/ (They acquired Meteor) ⚙️ Tech Stack meteor → node → golang → react → aws → datadog → docker → dynamodb → ecs → elasticache → graphql → lets-encrypt → loggly → memcached → mongodb → pagerduty → postmark → recurly → scalegrid → sendgrid → statuscake → terraform → websockets → 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, 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. Topics Include 3:04 – Motivation for switching from .NET to Rails 5:59 – It’s a Rails API with a React front-end, first class mobile support is important 9:34 – What type of screens does this app have? 11:58 – As the CTO, Chad doesn’t get a chance to code as much as he used to 13:15 – A few Rails features and gems being used (interactor, wisper and more) 16:35 – Third party sites that they integrate with 18:11 – Contracting companies are a lot more technical than you might think 22:39 – Every photo upload hits the Rails back-end but it’s not processed there 25:30 – Millions of jobs are being run through Sidekiq per day and payments 28:46 – Spending time on the company admin back-end vs user features 33:20 – Postgres (RDS), MongoDB, Elasticsearch and Redis are being used 36:13 – The Flipper gem is being used for feature flags 37:44 – Docker is being used in development with a transition to using them in production 39:30 – How things are currently deployed and where they’re going with AWS Fargate 41:03 – From Chef to Ansible with Capistrano handling app deployments 43:35 – Ubuntu is their distro of choice 44:00 – Moving over to ECS with Fargate and hiring dedicated ops folks 48:28 – A run down of which AWS resources they’re using 49:25 – The deployment process from development to production 54:59 – All developers on the team can use whichever OS they prefer 55:37 – Handling backups of all user data 58:22 – Logging, error monitoring and alerts 1:01:40 – Best tips? Design patterns are important, so is caching and saying no 1:03:48 – Their AWS bill is about $38,000 a month 1:05:03 – Check out https://companycam.com, they’re hiring! Links 📄 References https://readme.com/ https://buildbot.net/ ⚙️ Tech Stack rails → ruby → react → react-native → ansible → aws → cloudfront → datadog → docker → elasticache → elasticsearch → graphql → honeybadger → lambda → mongodb → nginx → postgres → pusher → rds → redis → route53 → s3 → scout → ses → slack → stripe → ubuntu → 🛠 Libraries Used https://github.com/collectiveidea/interactor https://github.com/krisleech/wisper https://github.com/mperham/sidekiq https://github.com/rubocop/rubocop https://github.com/ankane/searchkick https://github.com/mrkamel/search_flip https://github.com/jnunemaker/flipper https://github.com/capistrano/capistrano 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, 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. Topics Include 7:13 – The process to build a custom piece of hardware 12:33 – 3D printing a custom case 15:16 – The assembly process and selling about 150-200ish devices a month 16:20 – Ansible and a Bash script ensure everything gets installed on the device 20:16 – Everything including the OS can run on about 1.5GB of memory 22:01 – Motivation for using Flask and Python 25:29 – Using Python’s built in testing library and a few useful 3rd party packages 26:47 – Web components are being used quite heavily 31:44 – Getting started with web components 34:34 – Rendering everything at 30 frames per second at 1080p with SocketIO 38:34 – The differences between the regular and pro version 40:57 – There’s no bundling for JS and CSS 43:11 – Docker was considered but wasn’t included in the end 46:44 – Purchasing the pro version and ancillary services around the hardware 50:52 – Shopify is used as a store front and they make about 20-30k a month 54:26 – The deploy process and reviewing code from their freelance devs 1:00:09 – Hiring quality developers by making it a great place to work for 1:02:05 – Getting new versions of the code on user’s devices 1:07:35 – Is it possible to brick your own device? It hasn’t happened yet 1:11:40 – Best tips? Incrementally build and release your product as you go 1:16:26 – How Michael hired a few initial freelance developers 1:21:41 – Check out TinyPilotKVM, Michael has a blog and is on Twitter too Links 📄 References https://en.wikipedia.org/wiki/Raspberry_Pi https://en.wikipedia.org/wiki/Intelligent_Platform_Management_Interface https://css-tricks.com/an-introduction-to-web-components/ https://www.talkyard.io/use-cases https://runninginproduction.com/podcast/39-place-card-me-lets-you-create-printable-place-cards-online ⚙️ Tech Stack flask → python → ansible → bash → circle-ci → nginx → open-source → 🛠 Libraries Used https://github.com/miguelgrinberg/Flask-SocketIO https://github.com/wtforms/wtforms 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 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. Topics Include 2:49 – They support 6.5 million users on the platform which helped creators make $100m+ 4:19 – There’s 2 parts to the system, the admin for creators and the user experience 8:49 – BREAKING NEWS: Rails can scale and it’s working out nicely for them as a monolith 10:47 – Turbolinks and Liquid helped their app a lot 14:10 – It feels like a Rails app but uses VueJS and InertiaJS on the front-end 18:47 – A couple of interesting gems in their Gemfile, including using Fastly 21:38 – They have a great relationship with Mux for streaming video 25:25 – Approaching the latest stable version of Rails 27:05 – 19 Rails engineers are working on the monolithic code base 28:33 – Payments are supported with Stripe, PayPal and Authorize.net 31:42 – About 10 million emails are sent out every week through SendGrid 34:29 – Custom domains for customers and using Heroku with nginx / Let’s Encrypt 39:51 – Postgres is the main database along with ClickHouse (billions of events a week) 42:33 – What types of events are being logged and how can it be viewed? 46:20 – A custom nginx router that sits in front of Heroku 50:11 – Reasons for using Heroku and setting up an auto-scaler 54:51 – A couple of Heroku add-ons and using New Relic (NOTE: 10 billion rows = 250GB) 57:38 – The deployment process from dev to prod (CI, code reviews, GitHub discussions) 1:07:57 – What is ShapeUp which is Basecamp’s methodology around project management 1:09:06 – Backing up user data and more info about ClickHouse 1:14:51 – There’s value in performing soft deletes as long as you really delete it later 1:16:03 – OpsGenie, New Relic and Uptime Robot are used for alerting and being on-call 1:22:34 – Best tips? Follow standards when you can such as using built in Rails features 1:26:03 – You can find Nick on GitHub and Telegram Links 📄 References http://railscasts.com/ https://youtu.be/KJVTM7mE1Cc?t=600 (RailsConf 2015 “Backpack” reference) https://runninginproduction.com/podcast/31-mux-is-an-api-based-platform-that-lets-you-process-and-stream-videos https://basecamp.com/shapeup https://runninginproduction.com/podcast/12-learn-ruby-on-rails-through-screencast-tutorials-on-gorails ⚙️ Tech Stack rails → ruby → vue → authorize-net → clickhouse → digitalocean → fastly → heroku → kafka → lets-encrypt → mux → new-relic → nginx → opsgenie → paypal → postgres → redis → sendgrid → sentry → stripe → turbolinks → uptime-robot → webpack → 🛠 Libraries Used https://github.com/Shopify/liquid https://github.com/inertiajs/inertia https://github.com/mperham/sidekiq https://github.com/PNixx/clickhouse-activerecord 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, 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. Topics Include 4:16 – It took about a month to get the MVP out and a few months after for it to be sellable 6:52 – Motivation for using Rails 8:54 – How the app works and going over some of its screens 13:21 – ActiveJob is such a good abstraction it’s easy to forget what job library you use 14:14 – A bunch of useful gems that are being used 18:14 – The user experience can often impact the technical complexity of what you’re building 21:53 – Feature flags and swinging back to JSONB columns 26:21 – Stripe handles all of the payments 28:24 – The app is pretty much one big monolith and it’s a good thing 29:55 – About 25k lines of Ruby code and 40k lines of Typescript on the front-end 33:04 – If Turbo were around for years would you have used it over React? 36:37 – You shouldn’t be afraid to touch code in your codebase 38:42 – Getting a decent amount of things planned out before implementing the code 44:00 – Postgres, Redis, Mixpanel and Datadog for app and business alerts / logging 49:19 – Limiting access to production data from developers 51:17 – Heroku helped them get to market faster and they had YCombinator credits 54:36 – The deploy process from development to production 1:01:20 – Limiting access at the GitHub repo level and Heroku 1:04:48 – In general backups are handled by the providers they use (Heroku, S3, etc.) 1:07:21 – Heroku will send out alerts if something unexpected is happening with the site 1:09:31 – Best tips? Be pragmatic about testing and code coverage 1:11:58 – User design and UX is handled by a specific team member 1:14:09 – Check out https://greatquestion.co and they’re hiring too Links 📄 References https://github.com/excid3/jumpstart DHH’s YouTube video using esbuild and Tailwind’s CLI https://github.com/nickjj/docker-rails-example https://en.wikipedia.org/wiki/System_and_Organization_Controls ⚙️ Tech Stack rails → ruby → react → algolia → datadog → github-actions → mixpanel → mux → postgres → redis → s3 → sentry → stripe → 🛠 Libraries Used https://github.com/ErwinM/acts_as_tenant https://github.com/excid3/noticed https://github.com/mperham/sidekiq https://brakemanscanner.org/ https://github.com/roidrage/lograge https://github.com/basecamp/console1984 https://github.com/testdouble/standardrb 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, 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. Topics Include 1:52 – A little bit about how the service works 5:32 – Training an AI to process invoice items 8:33 – Thousands of clients and the motivation to use Ruby on Rails 10:28 – Using AWS Rekognition’s Textract and SageMaker for AI and ML decisions 14:55 – It takes about 2 minutes to get an initial result after uploading an invoice 18:12 – The mobile version is served through a responsive web application 21:36 – They’re using the latest stable Rails release with good test coverage 25:31 – Going over a few types of Sidekiq Pro driven background jobs that are running 29:28 – Action Mailbox was a huge win for them, it’s also a monolithic code base 31:54 – They’re using Heroku’s CI service 32:52 – Good old Sprockets is used for the asset pipeline at the moment 35:31 – Josh really likes Postgres, Redis is also being used quite a bit 40:22 – What it’s like to work with QuickBook’s imports and exports 46:30 – Most things are hosted on Heroku (2 worker and web Dynos) 49:05 – Papertrail, Sentry and Mailgun are being used 51:42 – Before sending emails most agriculture folks were faxing paperwork 52:50 – The deploy process from development to production 54:58 – Terraform is used to spin up the infrastructure, even on Heroku 59:48 – Avoiding real customer data when copying data from prod to dev 1:05:42 – Currently there’s no external monitoring checking the site for up-time 1:07:49 – Best tips? Don’t worry about being perfect, get something out there 1:09:43 – They’re hiring, you can email Josh and they’re on Twitter too Links 📄 References https://en.wikipedia.org/wiki/UAN DHH’s YouTube video using esbuild and Tailwind’s CLI https://www.terraform.io/cloud https://en.wikipedia.org/wiki/Hero%27s_journey ⚙️ Tech Stack rails → ruby → aws → heroku → jquery → mailgun → papertrail → postgres → redis → sentry → terraform → 🛠 Libraries Used https://aws.amazon.com/rekognition/ https://aws.amazon.com/sagemaker/ https://github.com/mperham/sidekiq https://github.com/gettalong/hexapdf https://github.com/jnunemaker/httparty https://github.com/vcr/vcr https://github.com/bear-metal/tunemygc https://github.com/roidrage/lograge https://github.com/flyerhzm/bullet 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, 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. Topics Include 2:26 – Rebuilding a similar app with a new tech stack is easier the 2nd time around 6:14 – Motivation for using Rails and live coding features right next to his client 9:33 – What the app does at a high level and what some of the screens do 12:20 – The app is running Rails 4.2 and it’s humming along with minimal maintenance 13:29 – Stripe handles accepting donations and keeping things as simple as possible 17:33 – Processing over $30 million dollars since the site went live 22:35 – It’s worth checking out which payment providers are available in different countries 24:51 – Using an older version of Stripe’s API but it’s super stable 27:22 – A couple of gems from 2015 which helped build this app 28:50 – (1) standard Heroku Dyno for the web app and (1) 2x size Dyno for the worker 32:15 – Postgres, Redis and Resque are being used along with Heroku’s cron scheduler 35:48 – Sending bulk emails out can be scary 39:42 – Using Rbenv locally to manage things in development 42:42 – The reasons for picking Heroku were mainly to avoid any type of ops work 46:03 – What it’s like to develop a new feature and push it up to production 47:58 – Not doing traditional TDD but tests are still written 51:18 – Heroku is in charge of performing daily database backups 55:40 – Handling background worker spikes with popular donation pages 57:42 – Tagging the current user in Rollbar errors and then emailing customers ASAP 1:00:27 – Best tips? Keeping it simple really drives down your maintenance 1:02:38 – CJ’s has a YouTube channel and a personal site at https://cjav.dev Links 📄 References https://www.youtube.com/CJAvilla https://stripe.com/payments/checkout https://stripe.com/docs/payments/payment-element https://faye.jcoglan.com/node.html ⚙️ Tech Stack rails → ruby → heroku → mailchimp → new-relic → papertrail → postgres → pusher → redis → rollbar → s3 → sendgrid → stripe → twilio → 🛠 Libraries Used https://github.com/collectiveidea/audited https://github.com/thoughtbot/paperclip https://github.com/gaffneyc/usps https://github.com/resque/resque 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 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. Topics Include 2:06 – The podcast is not sponsored and it’s done in Nick’s spare time after hours 2:30 – What’s involved end to end to put together an episode 8:50 – Each episode gets about 400 downloads or listens but it’s hard to track 10:41 – Motivation for using Jekyll and Ruby 13:03 – A couple of custom Jekyll plugins to help building a podcast site 16:55 – So many static generators to choose from, just pick one 18:09 – Use the tools that you like and don’t constantly second guess yourself 19:34 – What is Liquid (Jekyll’s templating language)? 21:01 – The custom audio player is the only real amount of JavaScript on the site 25:42 – Jekyll-Assets is being used to MD5 tag static file names for cache busting 26:34 – nginx is serving the site with Let’s Encrypt handling the SSL certificates 28:12 – The only SAAS tool being used is Google Analytics but I don’t use it for much 29:20 – A few static sites are all hosted on a $5 / month DigitalOcean server 32:06 – The server load is at 2-3% CPU with 60,000+ monthly visitors 33:06 – Debian Bullseye is running on the server 34:38 – Ansible is used to provision the server 38:47 – Deploying a new podcast episode to the site 41:59 – Making sure all tags are properly filled out 43:46 – Another shell script to auto-inject an episode’s length and file size in bytes 46:55 – There’s no secret management because there’s no secrets 47:29 – The code is backed up on GitHub and an external USB HDD 49:54 – DigitalOcean’s built in monitoring and alerting as well as Uptime Robot is being used 52:34 – Best tips? Find tools that you’re genuinely happy using and stick with them 54:39 – You can find Nick on his site, @nickjanetakis on Twitter and nickjj on GitHub Links 📄 References https://buildasaasappwithflask.com https://diveintodocker.com https://www.youtube.com/c/NickJanetakis https://www.audacityteam.org/ https://www.blackmagicdesign.com/products/davinciresolve/ https://github.com/nickjj/runninginproduction.com https://github.com/nickjj/runninginproduction.com/issues/1 https://nickjanetakis.com/blog/displaying-database-results-across-multiple-columns-with-1-line-of-css https://nickjanetakis.com/blog/using-ffmpeg-to-get-an-mp3s-duration-and-4-ways-to-get-the-file-size https://nickjanetakis.com/blog/transform-a-toshiba-chromebook-cb35-into-a-linux-development-environment-with-galliumos ⚙️ Tech Stack jekyll → ruby → ansible → bash → debian → digitalocean → lets-encrypt → nginx → open-source → turbolinks → uptime-robot → 🛠 Libraries Used https://github.com/sparklemotion/nokogiri https://github.com/envygeeks/jekyll-assets https://github.com/postmodern/chruby https://github.com/acmesh-official/acme.sh 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, 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. Topics Include 1:14 – The dream is to replace 9 separate systems with 1 custom solution 3:02 – Deploying on day 1 and what exactly is an EMR? 6:20 – Motivation for choosing Ruby on Rails to build a medical system 10:39 – Infrastructure as code is important 13:36 – The app does scheduling and soon emails will be sent to patients 15:29 – Specific things the app does and how Rails helps Jason accomplish them 21:56 – Custom generators are used for different modules 25:11 – Every 5 seconds certain forms are auto-saved and a few gems that are being used 27:56 – Rails can only help you so much, then you’re kind of on your own 34:10 – Making a distinction between imperative and declarative code 36:36 – Server rendered templates with sprinkles of Javascript (StimulusJS) 43:53 – Looking into using Hotwire Turbo in the distant future 45:41 – Migrating to use Elasticsearch and using it over PostgreSQL’s full text search 47:49 – Using AWS for hosting and landing on using Kubernetes with EKS 52:57 – 5% of Jason’s brain is taken up at all times knowing he’s on-call 55:22 – Switching from individual servers with Ansible to Kubernetes 59:37 – Using eksctl and Helm to move towards infrastructure as code 1:06:12 – The deploy process from development to production with Kubernetes 1:09:53 – Using feature flags and code reviews 1:11:35 – Handling database migrations with a load balanced application 1:15:13 – A strategy for writing Jira tickets 1:17:53 – RDS snapshots are handling database backups 1:21:14 – Monitoring, alerting and the idea of “sharpening the saw” 1:25:47 – Best tips? Make safe decisions and improve skills such as reading documentation 1:30:44 – Check out Jason’s site at https://www.codewithjason.com/ Links 📄 References https://twitter.com/dhh (Creator of Rails) https://en.wikipedia.org/wiki/Electronic_data_interchange Jason’s podcast where Nick was a guest talking about freelancing, Docker and Kubernetes https://rtpg.co/2021/06/07/changes-checklist.html (Database migration steps) https://nickjanetakis.com/blog/learning-a-new-web-framework-with-question-driven-development https://www.codewithjason.com/best-programming-tips/ ⚙️ Tech Stack rails → ruby → ansible → aws → eks → elasticache → elasticsearch → kubernetes → nginx → postgres → rds → redis → s3 → stimulusjs → 🛠 Libraries Used https://github.com/mperham/sidekiq https://github.com/heartcombo/simple_form https://github.com/weaveworks/eksctl https://helm.sh/ 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, 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. Topics Include 6:30 – Motivation for switching from PHP to Ruby on Rails 7:07 – Figuring out which gaming API to implement first and how their APIs are 10:27 – Reverse engineering undocumented API calls from the Windows Steam client 12:18 – Using a separate database for each gaming platform provider 15:05 – A few useful features of Rails that’s being used and Stimulus Reflex 20:19 – Switching from Webpacker to using Vite 23:14 – Using Slim instead of ERB and a few other gems being used 25:29 – It’s a single monolithic Rails app that’s using namespaces 28:36 – A lot of the time spent developing this app is working with the game APIs 31:00 – Using Sidekiq, a billion (!) gamer activities stored and millions of Sidekiq jobs 34:18 – It’s hosted on a single AWS T2.large instance (4 vCPUs / 16 GB memory) 36:13 – The database is on an R6g.large with 10+ billion records 39:14 – Ansible was used to set up the EC2 instance and it’s running Ubuntu 18.04 LTS 41:13 – A couple of AWS resources being used 43:01 – The process to ship a feature from development to production 44:16 – Switching to using TailwindCSS in a nicely controlled way 47:57 – At the moment the site is free with no desire to make it pay to win 49:55 – Hosting is $1,500 pounds a month and it’s been running for free for 7+ years 51:43 – There’s 7 terabytes of S3 storage and daily database backups 55:59 – 50ish mini servers spread across Heroku’s free tier to bypass API rate limits 59:45 – Being dialed into the ops side of things but there’s room for improvement 1:00:54 – Keeping up with a full date job and a long running passion project 1:02:25 – Best tips? Don’t forget to plan things out 1:05:56 – You can find Vlad on Twitter and Games Directory will be open source soon Links 📄 References https://www.giantbomb.com/api/ https://www.telerik.com/fiddler https://games.directory/u/pacmakaveli (Vlad’s profile) ⚙️ Tech Stack rails → ruby → ansible → aws → better-uptime → elasticache → elasticsearch → github-actions → lets-encrypt → memcached → mysql → nginx → rds → redis → s3 → sentry → tailwindcss → turbolinks → ubuntu → 🛠 Libraries Used https://github.com/stimulusreflex/stimulus_reflex https://vitejs.dev/ https://github.com/puma/puma https://github.com/slim-template/slim-rails https://github.com/github/view_component https://github.com/mperham/sidekiq 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.