So you want to become a Ruby on Rails developer? Excellent choice. But before you dive headfirst into tutorials, let me lay down a quick reality check and save you months of wasted effort.

⚠️ A Quick Disclaimer Before We Begin:
If you ask me for a guaranteed 100% playbook to landing a Ruby job today, I’ll be completely honest: I don't have one, and frankly, nobody does. The market is tough right now, and junior positions are scarce.

However, Ruby has a ridiculously high proportion of fully remote jobs. The kind that allegedly lets you sip piña coladas on a lounge chair at some tropical resort. Okay, I'm joking about the beach (you wouldn't see your screen in the sun glare anyway), but fully remote work in Ruby isn't just an occasional perk, it's standard practice where 100% (or a vast majority) of the team is remote.

And while I can't guarantee 100% employment (because nobody can predict lightning), following this roadmap will 100% give you total confidence in your code. You’ll learn how to actually build and launch your own ambitious projects from scratch. Okay, maybe not the next Facebook on week two, but something seriously powerful that actually runs live in production.

Rule 1: A "Ruby Developer" Is (Almost Always) a Rails Developer #

First off, let’s get one thing clear: when a company advertises a "Ruby Developer" role, 9 times out of 10, they mean Ruby on Rails.

Yes, other full-stack Ruby frameworks exist. Hanami looks super promising, clean, and architecture-focused. It could genuinely give Rails a run for its money in the coming years. There are also micro-frameworks like Sinatra (which Figma uses on their backend) and Roda (which trails Express.js by a tiny 4% in certain benchmarks, as I covered in my previous post on Ruby performance).

   ┌─────────────────────────────────────────────────────────────┐
   │                  The Ruby Ecosystem Landscape               │
   ├─────────────────────────────────────────────────────────────┤
   │ Full-Stack Heavyweight  │ Ruby on Rails (Vast majority)     │
   │ Promising Alternative   │ Hanami                            │
   │ Micro-Frameworks        │ Sinatra, Roda                     │
   └─────────────────────────────────────────────────────────────┘

But realistically? The overwhelming majority of open vacancies today, and for the foreseeable future, are on Ruby on Rails. Your first job will almost certainly be a Rails job. So save yourself the existential crisis and focus on Rails first.

Rule 2: Rails Is Full-Stack (Embrace the Frontend!) #

Rails is inherently a full-stack framework.

Sure, you might find rare job postings where Rails is strictly used as a headless API backend. For instance, companies like Avvoka separate their Ruby on Rails backend from a Vue.js frontend, meaning their Rails devs rarely touch frontend code. But that is the exception, not the rule.

If you're learning Rails, you must know how to handle the frontend. That means understanding JavaScript, HTML, CSS, and likely Tailwind CSS.

The good news? You do NOT need to spend months learning a complex Single Page Application (SPA) framework like React, Next.js, or Vue.

Instead, master Hotwire (Turbo & Stimulus). 

  Traditional SPA Stack vs Modern Rails Hotwire Stack

  SPA Architecture:
  [ Rails API ] ◄── REST / GraphQL ──► [ React / Next.js SPA ] (2 codebases, high friction)

  Hotwire Architecture:
  [ Rails App + Turbo + Stimulus ] ──► HTML over the wire (1 unified codebase, rapid shipping)

Hotwire is deeply integrated into Rails 8, works out of the box, and you'll learn it naturally as you learn Rails itself.

Even better: once you build your web app with Hotwire, you can turn that exact same codebase into native iOS and Android mobile apps using Hotwire Native.

I didn't pull this out of thin air: this is literally how my team and I ship software every single day. It's insanely empowering for small teams to build backend, web frontend, and mobile apps without maintaining three separate engineering departments.

Rule 3: Don't Drown in the Gem Ecosystem (Trust Rails 8) #

To write solid backend code, you need a basic understanding of networking and basic SQL for databases. You don't need to be a senior Database Administrator on day one, but understanding how databases query and index data is mandatory.

Beyond what Rails provides out of the box, there's a whole universe of third-party gems. Here are just a few popular ones you're likely to encounter in the wild:

My advice? You don't need any of this to get started, and you definitely don't need it to land your first job.

Once you've got the fundamentals down, I'd especially recommend taking a closer look at ViewComponent. I personally think it's a fantastic tool for building reusable UI components. In fact, this very website you're reading right now is built with ViewComponent. But that's a "level 2" thing, not something you need on day one.

Rails 8 comes packed with incredible out-of-the-box features. Stick to standard Rails conventions, trust the Solid Trifecta (Solid Queue, Solid Cache, Solid Cable), and learn to love SQLite.

Using SQLite for both development and production simplifies your stack immensely. And don't worry, easing your life with SQLite in no way prevents you from getting hired at a company using PostgreSQL or MySQL. Database configuration is a "set it once and forget it" task anyway. In daily work, you’ll be writing ActiveRecord code, which abstracts the underlying database. And if you do write raw SQL, SQLite semantics are virtually identical.

So... just don't make your life harder than it needs to be. :)

Rule 4: In the AI Era, Localhost Is Not Enough #

In 2026, building a pet project that only lives on your localhost and a GitHub repo is no longer enough to impress anyone.

Your project must be live. It needs to be running on a real server, with a custom domain name, and proper SSL certificates configured.

Fortunately for us, Kamal makes deployment feel like magic. It's far easier than it looks.

  Deploying a Modern Rails App with Kamal

  [ Local Dev ] ──► `kamal deploy` ──► [ Docker Registry ] ──► [ VPS Server + SSL ]

And don't panic about costs:

  1. Domain name: ~$13/year on a registrar like Porkbun (I use them personally and love them).
  2. Compute: Cloud providers like AWS offer free credits (e.g. AWS frequently provides 6-12 months of free credits for starter workloads), or you can grab a cheap VPS for a few bucks a month.

Deploying a live app costs next to nothing, but it immediately puts you in the top tier of junior candidates.

What About AI? #

AI tools (Codex, OpenCode, Claude Code) are incredible productivity multipliers.

And here's the thing about multipliers: if the value of your idea or the clarity of your task is zero, it doesn't matter how powerful the multiplier is. Zero times anything is still zero. AI lets you generate output faster than ever before, but what you actually need is outcome. There's a huge difference.

If you want to understand that difference deeply, watch Jeff Patton's talk on User Story Mapping (recorded in 2014, and it still feels fresh and incredibly relevant). Even if you don't have a product manager handing you tasks, this will teach you how to think about and describe your own project clearly. You know, that portfolio project you absolutely need for your job search. Or hey, maybe it becomes your actual source of income. Who knows?

Use AI as Your Mentor First, Code Generator Second #

When you're learning, don't just ask AI to write code for you. Instead, treat it as your personal mentor:

  1. Ask it to help you think through the problem before jumping to a solution
  2. Do pair programming with it: you write, it reviews and suggests
  3. Ask it to explain the code and the decisions behind it
  4. Use it to learn, not to skip learning

Squeeze every drop of teaching out of AI. It's the most patient tutor you'll ever have.

Later, once you have solid fundamentals, the dynamic will flip. You'll use AI to generate tons of code, and your daily work will look a lot more like constant reading than writing. Yes, that's the reality we live and work in right now. But you'll still need to understand what was generated, and you'll almost always need to make manual edits and corrections. To do that confidently, you need to have spent some time writing code yourself first.

Personally, I delegate a ton of frontend work to AI. I love not having to hand-craft repetitive CSS and layout markup line-by-line because frontend isn't my primary love. AI is ridiculously good at writing Ruby too. Seriously, damn good. But you must understand what it's generating.

I'll be honest: writing these lines makes me a bit uneasy. No jokes here. I used to teach computer science before the AI boom, and during it. What a developer actually does has changed so dramatically. Writing code is no longer the main thing. AI does it faster and, let's be real, sometimes (or maybe not just "sometimes" anymore) better than us.

So... enough pessimism! Right now, the world still needs us. We're staying. As for my deeper thoughts on the evolving role of the software engineer? I'll save that for another post.

The Minimalist Tech Stack Checklist #

Before applying for jobs, here is what you actually need:

  • Technologies: Ruby, HTML, CSS, JavaScript, SQL, Hotwire (Turbo + Stimulus), and Kamal for deployment.
  • Proof of Work: At least 1 live, fully functional web application hosted on a server where you applied everything listed above.
  • Online Presence: Clean LinkedIn profile and a polished GitHub repository.

Where to Learn All This? (The Step-by-Step Roadmap) #

Eventually, I plan to create my own course series. I genuinely love teaching. In fact, I originally transitioned into software engineering from a teaching background!

While I don't have my own courses ready for you just yet, here is the exact step-by-step learning roadmap I recommend:

Step 1: Understand How the Web Works #

Before writing code, understand HTTP, servers, and clients. Master.dev (formerly Frontend Masters) has an amazing, completely free course on Internet Fundamentals. Don't be turned off if it looks a bit classic. The core physics of the web haven't changed.

Step 2: Get a Taste of Frontend #

Before touching Ruby, get comfortable with HTML/CSS/JS. Master.dev offers a free Frontend Bootcamp that gives you everything you need without overwhelming you.

Step 3: Meet Ruby #

Head over to Try Ruby for an interactive introduction. Pro-tip: Don't believe the marketing hype: it won't take 30 minutes, it will take much longer. Just give yourself time and don't rush.

Step 4: Take a Quick SQL Break #

Before tackling Rails, learn SQL basics. I really enjoyed the Boot.dev SQL Course (it is paid, so if you're on a tight budget, find a free equivalent). You don't need to become a SQL wizard, but understanding tables, foreign keys, and joins is essential for understanding ActiveRecord.

Step 5: Dive Deep into Ruby & Rails #

  • Setting Up Your Environment: Over on my YouTube channel, The Rubyist Way, I put together a step-by-step guide: How to Install Ruby on Windows in 2026 (WSL & Editor Setup). If you're on Windows, this is honestly the easiest, most up-to-date setup method available (and the workflow applies just as well to Linux and macOS users).
  • Your IDE of Choice: I also recorded a walkthrough on How to Setup RubyMine on Windows. In my opinion, JetBrains IDEs are the absolute best on the market, and RubyMine simplifies my daily dev workflow immensely. Once you land a job, your employer will either provide a license or you can easily afford one yourself. Best of all, RubyMine is completely free for non-commercial and open-source use!
  • If you're completely new to programming: Read Learn to Program by Chris Pine (3rd Edition). It's light, readable, has funny (most of the time) jokes, and teaches core programming concepts using Ruby.
  • If you already have coding experience: Pick up Agile Web Development with Rails 8. It gets straight to the point and includes a solid Ruby recap.
  • Video & Official Guides: Watch Typecraft's "Rails New" tutorial series on the official Ruby on Rails YouTube Channel, and work through the official Rails Getting Started Guide.

Step 6: Stop Tutorial Hell & Build! #

That's it! Stop taking more tutorials. You now know enough to start. Pick a real project idea, open your editor, and start shipping.

Where to Find a Job (and One Critical Rule) #

Where do you look for your first Rails job?

  • Developer Telegram/Discord chats
  • Community Slack groups
  • Tech meetups and local conferences
  • Twitter/X and LinkedIn networking
  • ...

Apply, reach out to engineering managers, build in public, and keep iterating. When will lightning strike and you land that offer? Nobody knows.

Which brings me to my final, most important advice:

If you currently have a day job: DO NOT QUIT IT.

Seriously, don't do it! Adding financial anxiety will not help you code faster or interview better. Watching your savings tick down to zero over N months breeds panic, forcing you to accept any miserable offer just to afford groceries.

Keep your day job, preserve your sanity, build your project in your spare time, and stay resilient. You've got this!

Have thoughts or feedback on this dispatch? GET IN TOUCH →