Eventually, these developers discover AdonisJS.
Adonis is literally famous for being the “Ruby on Rails of Node.js”. It gives you a beautiful MVC (Model-View-Controller) structure, an ORM for the database, and everything comes pre-configured. It is, without a doubt, the best backend framework in the JavaScript ecosystem.
But if it is so good, why do I still use Ruby on Rails in 2026?
I have built projects with both. While Adonis is a massive upgrade for Node.js developers, here is my honest breakdown of why Rails is still the ultimate tool for getting things done.
AdonisJS is built entirely with TypeScript. For a lot of people, this is a huge plus. TypeScript catches errors before you even run your code, which is great for massive teams.
But for a solo developer or a small startup, TypeScript can feel like wearing handcuffs. You have to define types, write interfaces, and constantly satisfy the compiler. It slows down your prototyping.
Ruby, on the other hand, was built for Developer Happiness. It is expressive and reads almost like plain English.
# ruby
3.days.ago
users.map(&:name)
if user.active? && user.subscribed?
When I write Ruby, I feel like I am just writing down my thoughts. When I write TypeScript, I feel like I am filling out legal paperwork.
Adonis comes with a fantastic ORM called Lucid. It is heavily inspired by Rails and Laravel. It handles migrations, models, and relationships very well.
// adonis (TypeScript)
const users = await User.query()
.where('is_active', true)
.orderBy('created_at', 'desc')
It is very good. But ActiveRecord in Rails is simply magic. It has been polished for over 20 years. The sheer amount of built-in features, scopes, and association helpers in ActiveRecord makes querying the database effortless.
# rails
@users = User.active.order(created_at: :desc)
Plus, Rails handles database migrations slightly better. If you need to roll back a migration, Rails almost always knows how to reverse it automatically. In Adonis, you often have to write the “up” and “down” logic manually.
AdonisJS pairs beautifully with Inertia.js (which lets you build your frontend in React, Vue, or Svelte without an API). If you love the Javascript ecosystem, this is a dream setup.
But it still means you have a complex build step. You still have a package.json file with 50 dependencies. You still have to wait for Vite or Webpack to compile your frontend code.
Rails 8 takes a completely different path. With Hotwire and Importmaps, Rails eliminates the build step entirely.
You write standard HTML (ERB) views, and Hotwire makes the page feel as fast as a React app without writing any custom JavaScript. If you want to add a library, you just pin it with Importmaps. Your computer’s hard drive isn’t clogged with massive node_modules folders, and your app boots instantly.
The NPM (Node Package Manager) registry is huge. You can find a package for literally anything. The problem? A lot of NPM packages are tiny, abandoned, or don’t play nicely together.
In the Ruby world, gems are usually built specifically for Rails.
devise or has_secure_password.avo.solid_queue built right in.Because Rails enforces “The Rails Way” (Convention over Configuration), almost every gem plugs into your app perfectly. You don’t have to waste a weekend writing glue code to make a library work with your framework.
I have a lot of respect for AdonisJS. It brings much-needed sanity to the chaotic Node.js world.
I tried the “Rails of Node”, but it turns out, I just prefer the real thing.
]]>In the past, my answer was always no. The thought of setting up a Bitcoin node, managing private keys, and constantly checking the blockchain for confirmations sounded like an absolute nightmare for a solo developer.
But in 2026, accepting crypto is exactly like accepting credit cards. You do not need to touch the blockchain directly. You just use a payment gateway (like Coinbase Commerce, NowPayments, or BTCPay Server) that handles the wallet generation and gives you a simple REST API and webhooks.
Here is how to integrate a crypto payment gateway into your Rails 8 app in 4 easy steps. I will use the standard API approach, which works for almost any major crypto provider.
First off, we need a way to track the payment. When a user clicks “Pay with Crypto”, the gateway will generate a unique payment ID. We need to save this ID in our database so we can update the order when the user actually sends the funds.
Let’s generate a simple Order model:
rails g model Order user:references amount_in_cents:integer status:string crypto_charge_id:string
rails db:migrate
In our model, we can set a default status:
# app/models/order.rb
class Order < ApplicationRecord
belongs_to :user
# Statuses: pending, unconfirmed, completed, failed
after_initialize :set_default_status, if: :new_record?
def set_default_status
self.status ||= 'pending'
end
end
When the user clicks the checkout button, we need to tell our crypto provider to generate a payment page with the exact amount and currency.
We don’t need a heavy SDK for this. We can just use the http gem to make a fast POST request to the provider’s API (in this example, I’ll use the Coinbase Commerce API structure, as it is the industry standard).
# app/controllers/crypto_checkouts_controller.rb
require 'http'
class CryptoCheckoutsController < ApplicationController
def create
@order = current_user.orders.create!(amount_in_cents: 50_00) # $50.00
# 1. Call the Crypto Gateway API
response = HTTP.headers(
"X-CC-Api-Key" => ENV['CRYPTO_API_KEY'],
"X-CC-Version" => "2018-03-22",
"Content-Type" => "application/json"
).post("https://api.commerce.coinbase.com/charges", json: {
name: "Pro Subscription",
description: "One year of Pro access",
local_price: {
amount: "50.00",
currency: "USD"
},
pricing_type: "fixed_price",
metadata: { order_id: @order.id } # We pass our internal ID here!
})
# 2. Parse the response
charge_data = JSON.parse(response.body)["data"]
# 3. Save their unique charge ID
@order.update!(crypto_charge_id: charge_data["id"])
# 4. Redirect the user to the generated Crypto payment page
redirect_to charge_data["hosted_url"], allow_other_host: true
end
end
This is the easiest part. You don’t need to build a complex UI with QR codes. The gateway handles that for you. You just need a button.
<!-- app/views/pricing/index.html.erb -->
<div class="pricing-card">
<h2>Pro Plan - $50</h2>
<!-- Credit Card Button -->
<%= button_to "Pay with Stripe", stripe_checkout_path %>
<!-- Crypto Button -->
<%= button_to "Pay with Crypto", crypto_checkouts_path, class: "btn-crypto" %>
</div>
When the user clicks this, they are redirected to a secure, hosted page where they can pick their coin (BTC, ETH, USDC), scan the QR code with their wallet, and send the money.
Crypto transactions take time. Bitcoin can take 10 minutes to confirm. Because of this, the user might close their browser before the payment finishes.
To solve this, the crypto gateway will send a background Webhook (a POST request) to your Rails app the moment the blockchain confirms the money has arrived.
We need to create a controller to catch this request, verify it is actually from the gateway (and not a hacker), and update our order.
# app/controllers/webhooks/crypto_controller.rb
class Webhooks::CryptoController < ApplicationController
# We must skip the CSRF token check because this request comes from an external server
skip_before_action :verify_authenticity_token
def create
payload = request.body.read
signature = request.headers['X-CC-Webhook-Signature']
# 1. Verify the signature (Crucial Security Step!)
# We use OpenSSL to generate a hash using our secret key and the payload
digest = OpenSSL::Digest.new('sha256')
computed_signature = OpenSSL::HMAC.hexdigest(digest, ENV['CRYPTO_WEBHOOK_SECRET'], payload)
unless ActiveSupport::SecurityUtils.secure_compare(computed_signature, signature)
render plain: "Invalid signature", status: 400
return
end
# 2. Process the event
event = JSON.parse(payload)
event_type = event.dig("event", "type")
# The gateway passes back the metadata we gave it in Step 2
order_id = event.dig("event", "data", "metadata", "order_id")
order = Order.find_by(id: order_id)
if order
case event_type
when "charge:pending"
order.update!(status: 'unconfirmed')
when "charge:confirmed", "charge:resolved"
order.update!(status: 'completed')
# Here you would trigger an email or grant access to the product
when "charge:failed"
order.update!(status: 'failed')
end
end
# 3. Always return a 200 OK so the gateway knows we got the message
head :ok
end
end
Don’t forget to add the route for this webhook:
# config/routes.rb
namespace :webhooks do
post 'crypto', to: 'crypto#create'
end
That’s pretty much it! Integrating cryptocurrency payments into Rails is no different than integrating Stripe or PayPal.
By using a hosted gateway, you completely avoid the legal and technical nightmares of holding private keys or managing blockchain nodes. You just write clean Ruby code and let the provider handle the heavy lifting.
]]>apt-get update, and pray that it didn’t break your system dependencies. If you used Arch Linux instead of Ubuntu, you had to hope someone made an AUR package for it.
Today, the Linux desktop is much better. We have “Universal Package Managers”. They bundle the app and all its dependencies into one single package that runs on any Linux distribution.
But now we have a new problem. There are three competing standards: Snap, Flatpak, and AppImage.
I have used all of them extensively over the years. Here is my honest breakdown of how they work, the pros and cons of each, and which one you should actually use.
AppImage is the simplest of the three. It is the closest thing Linux has to a Windows .exe file or a macOS .dmg file.
How it works: You don’t actually “install” an AppImage. You just go to a website, download a single file, make it executable, and double-click it.
# Download the file
wget https://example.com/cool-app.AppImage
# Make it executable
chmod +x cool-app.AppImage
# Run it
./cool-app.AppImage
The Good:
The Bad:
Snap was created by Canonical (the company behind Ubuntu). It was designed to solve package management for both servers and desktop computers.
How it works: You install it via the terminal, similar to standard package managers.
sudo snap install spotify
The Good:
The Bad:
lsblk in your terminal, you will see a massive, ugly list of “loop devices” clogging up your screen.Flatpak was developed with backing from Red Hat. Unlike Snap, it was built specifically and exclusively for Desktop GUI applications.
How it works: You add the Flathub repository, and then you can install apps either through your graphical software center or the terminal.
# Install an app
flatpak install flathub com.spotify.Client
# Run the app
flatpak run com.spotify.Client
The Good:
Flatseal that lets you toggle permissions (like Network, Filesystem, Microphone) for every Flatpak app with simple switches.The Bad:
If you are setting up a Linux workstation for development or daily use, here is the golden rule I follow:
snapd from my system entirely.That’s pretty much it. The universal package war was messy for a few years, but in 2026, the community has spoken, and Flatpak is the clear winner for the Linux desktop.
]]>Very often I see developers jumping into complex JavaScript setups (like Next.js + a separate backend) just to build a simple AI wrapper. They spend a week just gluing the database, the API, and the frontend together.
In 2026, building AI apps is all about speed. And surprisingly, the best tool for the AI era is one of the oldest: Ruby on Rails.
Here is why Rails is the absolute best framework for building AI products today.
If you use AI tools like Cursor, GitHub Copilot, or ChatGPT to write code, you know they can sometimes get confused. If your project has a custom folder structure and weird configuration files, the AI will hallucinate and put code in the wrong place.
Rails is built on Convention over Configuration.
Every Rails app looks exactly the same. Models go in app/models, controllers go in app/controllers, and database changes happen in db/migrate.
Because Rails is so standardized and has been around for 20 years, AI models are incredibly good at writing Rails code. If you tell an AI, “Create a User model that has many Documents”, it knows exactly what to do. It generates the perfect migration, the perfect model associations, and the perfect routes without you having to explain your folder structure.
When you make a request to OpenAI or Anthropic, it takes time. Sometimes it takes 2 seconds, sometimes it takes 15 seconds.
If you put that API call directly inside your web controller, your app will freeze. The user will sit there staring at a loading spinner, and the browser might even timeout. You must use background jobs for AI.
In other frameworks, setting up background workers is a headache. You have to install Redis, configure workers, and manage separate processes.
In Rails 8, background jobs are built-in by default using Solid Queue.
# app/jobs/generate_summary_job.rb
class GenerateSummaryJob < ApplicationJob
queue_as :default
def perform(document_id)
document = Document.find(document_id)
# Call the slow AI API
response = OpenAiClient.generate_summary(document.text)
document.update(summary: response)
end
end
You just call GenerateSummaryJob.perform_later(@document.id) in your controller, and Rails handles the rest perfectly.
When using AI, users expect to see the text typing out on the screen chunk by chunk, just like ChatGPT.
To do this in React or Vue, you usually have to set up WebSockets, manage complex frontend state, and write a lot of boilerplate code to append text to a div.
With Rails and Hotwire (Turbo Streams + ActionCable), this is ridiculously easy. You don’t need to write any custom JavaScript.
When your background job gets a chunk of text from the AI, you just broadcast it directly to the HTML:
# Inside your job or service
Turbo::StreamsChannel.broadcast_append_to(
"document_#{@document.id}",
target: "ai_output",
html: "<p>#{ai_text_chunk}</p>"
)
The browser automatically receives the HTML and updates the page instantly. It feels like magic, and it saves you hours of frontend work.
Most AI apps today use RAG (Retrieval-Augmented Generation). This means you take user data from your database, mix it with a prompt, and send it to the AI.
To do this well, your database interactions need to be flawless. ActiveRecord is still the most powerful and easiest-to-use ORM in the world. Need to grab a user’s last 5 completed projects and pass their titles to the AI?
prompt_data = @user.projects.completed.last(5).pluck(:title).join(", ")
It is one line of plain English. Trying to write that in raw SQL or a clunky JavaScript ORM takes way more mental energy.
Also, with the neighbor gem, you can even store and query AI vector embeddings directly inside your standard PostgreSQL database using ActiveRecord.
The AI era is not about inventing new web technologies. It is about taking an AI API and wrapping it in a solid, reliable product.
As a solo developer, you want to focus 100% of your time on the AI prompt logic and the user experience. Rails gives you the database, the background jobs, the real-time UI, and the structure out of the box.
That’s pretty much it. While everyone else is fighting with Webpack and API endpoints, you can use Rails to launch your AI startup in a weekend.
]]>Very often I see beginners getting completely stuck trying to install Ruby on their Mac or Linux machine. You read one tutorial, and it tells you to install RVM. You read another, and it tells you to use rbenv. Then someone on Twitter tells you to use asdf.
It is very confusing. Why do we even need these tools?
Because different Rails projects require different Ruby versions. If you try to run a legacy Rails 6 app on Ruby 3.3, it will crash. You need a tool to quickly switch between Ruby versions depending on which project folder you are in.
Here is my honest breakdown of all the popular version managers, how they work, and which one you should actually use today.
RVM (Ruby Version Manager) is the oldest tool on this list.
How it works: It overrides your terminal commands (like cd) to switch Ruby versions automatically. It also has a feature called “gemsets” to keep your gems separated.
The Verdict: Do not use this.
In the past, RVM was amazing. But today, Bundler handles gem isolation for us, so “gemsets” are useless. RVM is too heavy, messes with your shell too much, and is generally considered outdated.
This is probably the most popular choice in the Ruby community right now.
How it works: It uses “shims”. A shim is a fake executable. When you type ruby -v, rbenv catches that command, checks if you have a .ruby-version file in your current folder, and then passes the command to the correct physical Ruby installation.
# .ruby-version
3.3.0
The Verdict: Highly Recommended. It is lightweight, does exactly one thing, and stays out of your way. If you only write Ruby code, this is a perfectly safe choice.
If you hate “magic” and fake executables, chruby is for you.
How it works: It does not use shims. When you switch Ruby versions, it simply modifies your computer’s $PATH variable to point directly to the correct Ruby folder.
# Terminal command to switch versions
chruby ruby-3.3.0
The Verdict: Great, but manual.
It is incredibly fast and clean. The only downside is that it doesn’t automatically switch versions when you enter a directory unless you install a secondary tool (like auto.sh or direnv).
Eventually, you will realize you don’t just need to manage Ruby. You also need to manage Node.js versions, Python versions, and maybe Postgres versions.
How it works: asdf uses a plugin system. You install the tool once, and then add plugins for whatever languages you need. It uses a file called .tool-versions instead of .ruby-version.
# .tool-versions
ruby 3.3.0
nodejs 20.0.0
The Verdict: Good, but getting slow.
It is extremely useful to have one tool for all languages. However, asdf is written in Bash, and when you have many plugins, it can actually make your terminal commands noticeably slower.
Previously known as rtx, this is taking over the developer world right now.
How it works: mise is basically a clone of asdf, but it is written in Rust. This makes it blazing fast. It doesn’t use shims like rbenv or asdf, it modifies your $PATH like chruby.
The best part? It is backwards compatible. It automatically reads your old .ruby-version, .nvmrc, and .tool-versions files and just works.
# Installing ruby with mise
mise install ruby@3.3.0
mise use ruby@3.3.0
The Verdict: The Best Choice Today.
If you are setting up a new computer, install mise. It manages all your languages, it is incredibly fast, and you don’t have to deal with slow terminal boot times.
I added this to the list because people often get confused by it. direnv is not a Ruby version manager.
How it works: It is an environment variable manager. You put a .envrc file in your project folder, and when you cd into that folder, direnv automatically loads those variables into your terminal (like API keys or Database URLs).
# .envrc
export STRIPE_KEY="sk_test_123"
People often pair direnv with chruby or rbenv to trigger the Ruby version switch automatically. But if you use mise, you don’t really need direnv anymore, because mise manages environment variables too!
That’s pretty much it. Setting up your environment is annoying, but once you pick a modern tool like mise or rbenv, you never have to think about it again.
I start typing out my code, and naturally, I write something like this:
if my_variable.present?
puts "We have data!"
end
And immediately, my script crashes with NoMethodError: undefined method 'present?' for nil:NilClass.
This is the moment every Ruby developer realizes a shocking truth: Methods like .present?, .blank?, and 3.days.ago are NOT part of the Ruby language. They are part of Rails.
But what if you want to use these awesome methods without generating a massive, heavy Rails application?
You can. All of these “magic” methods live inside a single gem called ActiveSupport. You can easily extract it and use it in any plain Ruby script. Here is how to do it.
First off, let’s install the gem. If you are using a Gemfile for your script, just add this:
source 'https://rubygems.org'
gem 'activesupport'
Run bundle install. If you are just writing a single .rb file without a Gemfile, you can install it directly in your terminal by running gem install activesupport.
Now open your ruby script. The easiest way to get all the Rails magic is to require the entire ActiveSupport library at the very top of your file.
# script.rb
require 'active_support/all'
# Now you can use time helpers!
puts 3.days.ago
# You can check for blank arrays or strings!
empty_array =[]
puts empty_array.blank? # => true
# You can format strings!
puts "my_custom_class".camelize # => "MyCustomClass"
This is great, but there is a catch. active_support/all is huge. It loads thousands of methods into memory. If you are building a tiny, fast script, loading the entire library just to use .blank? is overkill and will make your script boot up much slower.
Instead of loading everything, ActiveSupport allows you to require only the specific extensions you actually need.
ActiveSupport groups its methods by the Ruby class they extend (like String, Integer, Date, Array, etc.).
Here is how you cherry-pick exactly what you want:
# script.rb
# 1. I only want .blank? and .present?
require 'active_support/core_ext/object/blank'
if "".blank?
puts "String is empty"
end
# 2. I only want the time calculation helpers (like 2.days.from_now)
require 'active_support/core_ext/integer/time'
require 'active_support/core_ext/numeric/time'
puts 2.weeks.from_now
# 3. I only want string manipulations (like .squish or .pluralize)
require 'active_support/core_ext/string'
puts " too much spacing ".squish # => "too much spacing"
puts "apple".pluralize # => "apples"
By doing this, your script boots up instantly, uses almost zero RAM, but you still get to use your favorite Rails helpers.
If you are wondering what else lives inside ActiveSupport, here are a few methods I use all the time in my standalone scripts:
1. Array .in_groups_of
Perfect for processing large lists of data in batches.
require 'active_support/core_ext/array/grouping'
users = [1, 2, 3, 4, 5, 6]
users.in_groups_of(2) do |group|
puts group.inspect
end
# Outputs:[1, 2], then [3, 4], then [5, 6]
2. Hash .with_indifferent_access
Have you ever tried to get a value from a hash using my_hash[:name] but the key was actually a string "name"? This fixes that annoyance completely.
require 'active_support/core_ext/hash/indifferent_access'
data = { "name" => "Zil" }.with_indifferent_access
puts data[:name] # => "Zil" (It works with a symbol too!)
3. Enumerable .pluck
If you have an array of hashes (like an API response), you can easily extract just one specific key from all of them.
require 'active_support/core_ext/enumerable'
api_response =[{ id: 1, name: "Zil" }, { id: 2, name: "John" }]
puts api_response.pluck(:name)
# Outputs: ["Zil", "John"]
ActiveSupport is basically the ultimate utility belt for Ruby.
When you learn how to use it outside of Rails, you realize that Rails isn’t just one big magic black box. It is a collection of really well-written, separate tools. Pulling activesupport into your plain Ruby scripts will save you from writing hundreds of lines of custom helper methods.
That’s pretty much it. Next time you write a web scraper or a background worker, don’t suffer with plain Ruby time calculations. Just require ActiveSupport.
]]>It is almost impossible to ignore. The creator of Elixir, José Valim, was a core contributor to Rails. He built Elixir because he loved Ruby’s beautiful syntax, but he wanted to fix Ruby’s biggest problem: handling high concurrency and real-time features.
Very often I see developers asking if Phoenix is the “new Rails” and if they should abandon Ruby to learn it. Here is my honest breakdown of how Ruby on Rails and Elixir Phoenix compare in 2026, and which one you should actually use for your next project.
The biggest difference between these two frameworks isn’t the frameworks themselves. It is the language they are written in.
Ruby is strictly Object-Oriented. You create classes, you initialize objects, and those objects hold “state” (data that changes over time). Elixir is a Functional programming language. There are no classes and no objects. Data is immutable. You pass data into a function, and it returns new data.
# ruby (Object-Oriented)
user = User.new(name: "zil")
user.capitalize_name!
puts user.name # Outputs: Zil
# elixir (Functional)
user = %{name: "zil"}
# We pass the user data through a pipe of functions
updated_user = user |> Map.update!(:name, &String.capitalize/1)
IO.puts updated_user.name # Outputs: Zil
If you have only ever written Ruby or JavaScript, learning Elixir will literally rewire your brain. It takes time to get used to it.
This is the main reason people switch to Phoenix.
Under the hood, Elixir runs on the Erlang VM (BEAM). This technology was built decades ago by Ericsson to run telephone switches. It was designed to handle millions of phone calls at the exact same time without crashing.
If a process crashes in Elixir, it doesn’t take down your server. It just restarts that tiny process instantly.
Because of this, Phoenix can handle millions of active WebSocket connections on a single server. If you are building a real-time chat application, a live multiplayer game, or a stock trading platform, Phoenix will absolutely destroy Rails in performance and server costs.
When we use Rails, we use ActiveRecord. It is famous for being incredibly easy to use. It hides the SQL database from you.
# rails
@users = User.where(active: true).order(created_at: :desc)
In Phoenix, you use Ecto. Ecto is not an ORM (Object-Relational Mapper) because Elixir doesn’t have objects. It is a database wrapper that forces you to be very explicit about what you are doing.
# elixir
query = from u in User,
where: u.active == true,
order_by: [desc: u.inserted_at]
users = Repo.all(query)
The Good: Ecto makes it very hard to accidentally write slow database queries. There is no “N+1” magic hiding behind the scenes. The Bad: You have to write a lot more code. ActiveRecord is much faster for prototyping and building MVPs (Minimum Viable Products).
Both frameworks realized that building separate React/Vue frontends is exhausting. They both created solutions to let you write interactive, SPA-like apps using only server-side code.
Both are amazing. LiveView is slightly more powerful for deeply complex real-time UI, but Hotwire is simpler to deploy and scale because it relies on standard HTTP caching.
This is where Rails pulls ahead for solo developers.
If you want to add user authentication to Rails, you use has_secure_password or Devise. If you want to integrate Stripe, there is an official Stripe Ruby gem with thousands of StackOverflow answers. If you want background jobs, Rails 8 gives you Solid Queue out of the box.
Elixir’s package manager (Hex) is growing, but it is nowhere near the size of RubyGems. If you are building a standard SaaS app and you need to integrate with five different third-party APIs, you will probably have to write the API wrappers yourself in Elixir. In Ruby, you just type bundle add ....
The truth is, 95% of web applications do not need the insane concurrency power of Elixir.
That’s pretty much it. Both communities are fantastic, and learning functional programming with Elixir will make you a better Ruby developer anyway. But for getting a business off the ground quickly? I’m sticking with Rails.
]]>When I first started building modern Rails apps, managing JavaScript was always the most annoying part. We had Webpacker, package.json, and massive node_modules folders that took up gigabytes of space on my computer.
Very often I found myself tired of waiting for Webpack to compile my code just to see a small JavaScript change in the browser. It felt very heavy, especially for solo developers.
Then Rails introduced Importmaps. At first, I was very confused. How could I use libraries like Lodash, Chart.js, or Stimulus without running npm install?
Once I understood how it actually works under the hood, I realized it is a genius solution. Here is a simple explanation of how Importmaps work in Rails and how to use them.
Modern web browsers are actually very smart now. They natively understand ES Modules. This means if you write import canvasConfetti from 'canvas-confetti', modern Chrome or Firefox knows what to do.
But there is one problem. The browser doesn’t know where to find that file on the internet.
An Importmap is basically just a dictionary that lives in your HTML <head>. It tells the browser: “Hey, if the Javascript code asks for ‘canvas-confetti’, please download it from this specific CDN URL.”
Here is how we set this up in Rails in 4 simple steps.
Instead of using npm install or yarn add, Rails gives us a simple terminal command to add a Javascript library to our app. We call this “pinning”.
Let’s say we want to add the popular canvas-confetti library. Go to your terminal and run:
bin/importmap pin canvas-confetti
When you run this, Rails goes to a fast CDN (like jspm.io), finds the exact URL for that library, and saves it to your configuration.
If you open the file config/importmap.rb, you will see what Rails actually did in the background.
# config/importmap.rb
# These are your local files
pin "application"
pin "@hotwired/turbo-rails", to: "turbo.min.js"
pin "@hotwired/stimulus", to: "stimulus.min.js"
pin "@hotwired/stimulus-loading", to: "stimulus-loading.js"
# This is the new library we just pinned!
pin "canvas-confetti", to: "https://ga.jspm.io/npm:canvas-confetti@1.9.2/dist/confetti.module.mjs"
This file is just a list of names and URLs. You can even manually edit this file to point to different CDNs if you want.
Now that the library is “pinned”, we can use it anywhere in our JavaScript files just like we would in a React or Node.js app.
Open your app/javascript/application.js (or a Stimulus controller) and simply import it:
// app/javascript/application.js
import confetti from "canvas-confetti";
// Let's trigger it!
confetti({
particleCount: 100,
spread: 70,
origin: { y: 0.6 }
});
Because we pinned the name "canvas-confetti", the browser knows exactly what we are talking about.
So how does the browser actually read this dictionary?
In your app/views/layouts/application.html.erb, you should have this standard Rails helper in the <head> section:
<%= javascript_importmap_tags %>
When a user visits your website, Rails turns that helper into a literal JSON script tag. If you inspect your page source in the browser, it looks like this:
<script type="importmap">
{
"imports": {
"application": "/assets/application-xyz123.js",
"canvas-confetti": "https://ga.jspm.io/npm:canvas-confetti@1.9.2/dist/confetti.module.mjs"
}
}
</script>
When the browser hits your application.js file and sees import confetti from "canvas-confetti", it looks at this JSON map, finds the URL, downloads the file directly from the CDN, and executes it.
There are a few massive reasons why I prefer Importmaps over the old Webpack/Node.js way:
node_modules: Your Rails project stays incredibly small and clean. You don’t have a 500MB folder of Javascript dependencies sitting on your hard drive.Importmaps remove a huge layer of complexity from frontend development. If you are building a standard Rails app with Hotwire and Stimulus, you really don’t need a JavaScript bundler anymore.
]]>Very often I found myself tired of this approach. Managing JSON responses, CORS issues, and duplicating routing logic is just annoying.
Thankfully, the industry realized this was too complex for solo developers. Two massive solutions appeared to fix this: Hotwire (created by the Rails team) and Inertia.js (popularized by the Laravel community).
Both of these tools let you build modern “SPA-like” apps without building an API. But they work in very different ways. Here is my breakdown of how they compare, and why I personally favor Hotwire.
Inertia.js acts as a glue between your backend (Rails/Laravel) and your frontend (React/Vue/Svelte).
With Inertia, you still use Rails for your routes and controllers. But instead of rendering an HTML file (.html.erb), your controller sends data to a JavaScript component.
Here is how an Inertia controller looks in Rails:
# app/controllers/dashboards_controller.rb
class DashboardsController < ApplicationController
def show
@user = current_user
# Instead of rendering ERB, we render a React/Vue component
render inertia: 'Dashboard', props: {
user: @user.as_json
}
end
end
And your frontend is a standard React file:
// app/javascript/Pages/Dashboard.jsx
import React from 'react';
export default function Dashboard({ user }) {
return (
<div>
<h1>Welcome back, {user.name}!</h1>
</div>
);
}
The Good: You get to use React or Vue. If you love the React ecosystem and want to use components like Material UI or Tailwind UI React, this is amazing. The Bad: You are sending JSON over the wire. Your browser still has to download the heavy JavaScript framework, parse the JSON, and build the HTML on the user’s device.
Hotwire takes the opposite approach. It says: “JavaScript is too heavy. Let the server do the work.”
With Hotwire, you just write standard Rails controllers and standard ERB views.
# app/controllers/dashboards_controller.rb
class DashboardsController < ApplicationController
def show
@user = current_user
# Rails automatically renders show.html.erb
end
end
<!-- app/views/dashboards/show.html.erb -->
<div>
<h1>Welcome back, <%= @user.name %>!</h1>
</div>
When a user clicks a link, Hotwire intercepts the click, fetches the new HTML from the server in the background, and instantly swaps out the <body> of the page.
Both tools are great, but for a solo developer or a small team using Rails, I think Hotwire is the clear winner. Here is why.
If you use Inertia, you have to write Ruby in your controllers, and then switch your brain to write JavaScript/React for your views. You have to remember two different syntaxes, two different ways to loop through arrays, and two different ways to format dates. With Hotwire, you stay in Ruby and HTML almost 100% of the time.
To use Inertia, you must have Node.js, Webpack, or Vite running to compile your React/Vue code. This means dealing with package.json and node_modules.
With Rails 7 and Rails 8, Hotwire uses Importmaps. You literally do not need Node.js installed on your computer. You write plain code, and it just works in the browser. It makes your development environment much simpler.
In Inertia (or any React app), you have to worry about “State”. If you update a user’s name, you have to write Javascript to update that variable on the screen.
In Hotwire, the database is your only state. If something changes, you just tell the server to render that small piece of HTML again using a Turbo Stream. It deletes an entire category of bugs.
If you use Inertia in Rails, you are fighting against the current. The inertia_rails gem is good, but you miss out on built-in Rails features like standard form helpers and ActionCable broadcasting.
Hotwire is built directly into Rails by the creators of Rails. Everything works perfectly out of the box.
That’s pretty much it. For me, removing the Javascript build step and keeping all my logic in Ruby makes Hotwire the ultimate productivity tool.
]]>Nokogiri to download the HTML page, and then I would spend hours writing crazy CSS selectors to extract the text I needed.
If the website was built with React or Vue and the data loaded dynamically, I would boot up a heavy headless browser like Selenium or Playwright just to wait for the page to render.
Very often I find myself frustrated because websites change their CSS classes all the time, breaking my scraper. But recently, I changed my approach completely.
Modern websites are basically just empty shells that fetch data from internal, hidden APIs. If you can find that API, you can skip the HTML completely and just download perfectly structured JSON data. It is 100x faster and much more reliable.
Here is how to find and scrape hidden APIs in 4 easy steps.
You don’t need any special hacking tools for this. Just use your browser. Let’s say you want to scrape a list of products from an e-commerce store.
You will see a list of requests appear. Click on them one by one and look at the Preview or Response tab. You are looking for the one that returns a clean JSON object containing the product data.
Once you find the correct API request, you can’t just copy the URL and paste it into your Ruby script. Internal APIs usually require specific headers to work, like a User-Agent, an Accept header, or an authorization token.
Chrome makes it very easy to grab all of this.
Now you have the exact command, including all the secret headers the browser used, copied to your clipboard.
Now we need to translate that cURL command into a Ruby script. You can do this manually, but the fastest way is to go to a free site like curlconverter.com and paste your cURL command. It will instantly generate the Ruby code for you.
Here is what a typical request looks like using the http gem:
# scraper.rb
require 'http'
require 'json'
url = "https://api.example-store.com/v1/products"
# We pass the headers we copied from Chrome
headers = {
"User-Agent" => "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36...",
"Accept" => "application/json",
"Referer" => "https://example-store.com/category/shoes"
}
# Make the request to the hidden API
response = HTTP.headers(headers).get(url)
if response.status.success?
# Parse the JSON response
data = JSON.parse(response.body)
# Loop through the data easily!
data["items"].each do |product|
puts "Name: #{product['name']} - Price: $#{product['price']}"
end
else
puts "Failed to fetch data."
end
Usually, the first API request only gives you 20 or 50 items. If you want to scrape the whole category, you need to figure out how the API handles pagination.
Go back to your Chrome Network tab and look at the Payload (or the URL parameters) of the request.
You will usually see something like this:
?page=1?offset=20?cursor=abc123xyzTo scrape all the pages, you just wrap your Ruby request in a simple loop, incrementing the page number or cursor each time until the API returns an empty array.
# Example of a simple pagination loop
page = 1
loop do
response = HTTP.headers(headers).get("#{url}?page=#{page}")
data = JSON.parse(response.body)
break if data["items"].empty? # Stop when no more products
# Process items here...
page += 1
sleep(1) # Be nice to their server!
end
There are a few reasons why I prefer scraping hidden APIs over parsing HTML:
That’s pretty much it. Next time you need to scrape a modern website, don’t reach for Nokogiri or Selenium right away. Spend 5 minutes in the Network tab first. It might save you hours of work.
]]>