Introduction

This talk, delivered by Ben Curtis at RailsConf 2025, explores the 20-year evolution of deploying Ruby on Rails applications. Curtis takes the audience on a historical journey, highlighting the technologies, tools, and processes that have defined and transformed Rails deployment from the early days of the web to the present, culminating with today's Docker- and Kamal-driven workflows.

Key Points

• Early Web Deployments (1991–late 90s):

  • Initial web pages were plain HTML, deployed via editing files directly on servers (often using vi) or via FTP.
  • The advent of CGI (Common Gateway Interface) in the early '90s enabled interactivity and dynamic content, typically using Perl scripts. Deployment still relied on insecure methods like FTP.
  • Shared hosting was common, with little user control over server configurations.

• Emergence of Server-Side Scripting:

  • PHP 3.0 (1997) simplified deployment by embedding the interpreter within the web server (e.g., Apache), eliminating the need for CGI process spawning.
  • Attempts to similarly integrate Ruby via mod_ruby existed but suffered from reliability and security issues, making it unsuitable for serious use.
  • SCP and rsync started overtaking FTP as more secure deployment mechanisms.

• Rise of Ruby on Rails and Early Deployments (2004–mid 2000s):

  • Rails' debut in 2004 leveraged learnings from PHP, integrating best practices like view templating and database abstraction.
  • Early Rails apps were deployed via CGI and mod_ruby, both of which were problematic for production use due to performance and security limitations.
  • FastCGI, borrowed from the Windows/IIS world, emerged as a solution, running apps as a separate daemon. This improved performance but introduced operational brittleness and frequent need for manual restarts.

• Mongrel and Clustered Deployment:

  • Mongrel introduced efficient HTTP parsing, enabling Rails apps to handle requests directly. Apache became a proxy to Mongrel processes.
  • Mongrel Cluster allowed running multiple Mongrel instances for handling concurrent requests.
  • This era saw the rise of system administration and process management tools like Monit and God to ensure process uptime.

• Capistrano and Deployment Automation:

  • Capistrano (formerly SwitchTower) launched as a deployment automation tool, reducing the complexity of multi-step manual deployments using SSH and Git/SVN integration.

• Passenger and Further Abstraction:

  • Passenger incorporated Rails directly into web servers like Apache and Nginx, improving isolation, Ruby version management, and simplifying deployments further.
  • Shared hosting began to fade, encouraging greater adoption of VPS providers and more control over environments.

• Modern App Servers (2009–onward):

  • Unicorn, Puma, and Thin brought new approaches to handling concurrency (processes, threads, and event-driven models respectively), with process management features built in.

• Heroku and the PaaS Revolution:

  • Heroku revolutionized developer experience with 'git push heroku', removing the need for server administration and making Rails deployment effortless, albeit at a higher cost.

• Docker and Container-based Deployments (2013–present):

  • Docker solved versioning and environment consistency issues, enabling developers to create portable application containers.
  • Modern deployments leverage CI/CD pipelines to automate building and deploying containers.
  • Kamal (described as Capistrano 2.0) automates deployment of Docker containers across multiple servers, inspired by Capistrano's approach but focused on container workflows.
  • Alternatives like Dokku and Coolify provide Heroku-like Docker-based deployment on personal VPS.

Conclusion / Takeaways

• Deploying Rails applications has evolved from insecure and manual FTP-based approaches through fast CGI, clustered servers, automation tools like Capistrano, the simplicity of Heroku, and today’s containerized workflows with Docker and Kamal.
• The Rails deployment journey reflects broader trends in web development: increased automation, abstraction, improved security, and a relentless drive for developer productivity and convenience.
• While many tools and methods have come and gone, the overarching lesson is one of continual adaptation and innovation in pursuit of simpler, more reliable ways to deliver Rails applications to production.

Overall Message

This talk is a celebration of the Rails operations community and the remarkable technical progress over 20 years, encouraging attendees to recall the past and appreciate how much simpler, safer, and more flexible deployment has become.