🚀 From Google Podcasts to Moon FM in No Time: Your Hassle-Free Migration Guide
👉

Running in Production

Nick Janetakis - Full stack developer

Folks talking about web app deployment topics

  • 1 hour 43 minutes
    Meteor Cloud Is a Full Service Hosting Solution for Meteor Apps

    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
    ⚙️ Tech Stack

    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.
    20 December 2021, 5:00 am
  • 1 hour 5 minutes
    CompanyCam Helps Contractors Document Their Job

    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
    ⚙️ Tech Stack
    🛠 Libraries Used

    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.
    22 November 2021, 5:00 am
  • 1 hour 22 minutes
    TinyPilotKVM Lets You Remote Control Your Server from Your Browser

    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
    ⚙️ Tech Stack
    🛠 Libraries Used

    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.
    18 October 2021, 4:00 am
  • 1 hour 26 minutes
    uscreen Is a Platform That Helps Content Creators Build a Business

    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
    ⚙️ Tech Stack
    🛠 Libraries Used

    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.
    11 October 2021, 4:00 am
  • 1 hour 15 minutes
    Great Question Makes It Easy for Teams to Perform Customer Research

    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
    ⚙️ Tech Stack
    🛠 Libraries Used

    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.
    4 October 2021, 4:00 am
  • 1 hour 10 minutes
    Robot Accounts AI Provides a System to Let You Categorize Invoices

    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
    ⚙️ Tech Stack
    🛠 Libraries Used

    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.
    27 September 2021, 4:00 am
  • 1 hour 3 minutes
    Fundraze Is a Flexible Fund Raising and Campaign Management Service

    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
    ⚙️ Tech Stack
    🛠 Libraries Used

    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.
    20 September 2021, 4:00 am
  • 55 minutes 54 seconds
    Running in Production Is a Podcast Where Devs Chat about Tech Stacks

    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
    ⚙️ Tech Stack
    🛠 Libraries Used

    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.
    13 September 2021, 4:00 am
  • 1 hour 31 minutes
    A Custom Electronic Medical Record System for an Ophthalmology Clinic

    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
    ⚙️ Tech Stack
    🛠 Libraries Used

    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.
    6 September 2021, 4:00 am
  • 1 hour 6 minutes
    Games Directory Lets You Sync Your Games and Achievements in 1 Place

    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
    ⚙️ Tech Stack
    🛠 Libraries Used

    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.
    30 August 2021, 4:00 am
  • 49 minutes 58 seconds
    School Bus Hero Helps School Bus Drivers and Aides Find a Job

    In this episode of Running in Production, Dieter Lunn goes over building a job board site for school bus drivers and aides using Ruby on Rails. It’s hosted on DigitalOcean with HatchBox.

    Dieter talks about using a bit of StimulusJS to add pins to a map, keeping things simple with a monolithic app, working on the code base with another developer, upgrading to the latest versions on a regular basis and using HatchBox to manage the servers.

    Topics Include

    • 3:13 – What the site does and examples of what types of pages it has
    • 5:21 – Motivation for using Ruby on Rails
    • 7:02 – Specific features of Rails and gems being used
    • 11:04 – Using StimulusJS for placing pins on an embedded 2D map
    • 14:02 – One feature lets you get emailed when new positions open at a company
    • 15:40 – It’s a server rendered monolithic Rails app with sprinkles of JS
    • 19:14 – Keeping your gems up to date
    • 23:15 – Using Pundit to manage authorization
    • 25:27 – Keeping up with the latest versions and having an app starter project
    • 27:09 – It’s hosted with HatchBox on DigitalOcean
    • 32:02 – Walking us through developing a feature and deploying it to production
    • 38:07 – Payments are handled outside of the Rails app
    • 39:39 – Automation feels pretty good!
    • 43:45 – Currently Honeybadger sends notifications if the site is down
    • 45:47 – Best tips? Take your time and trust what others have built
    • 48:08 – You can find Dieter on GitHub and on Twitter

    Links

    📄 References
    ⚙️ Tech Stack
    🛠 Libraries Used

    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.
    23 August 2021, 4:00 am
  • More Episodes? Get the App
About Running in Production
Links
Listeners Also Subscribed To
© MoonFM 2024. All rights reserved.