Ruby on Rails in the AI Era: Why don't need to switch to Python

Stoyan — Tue, 02 Jun 2026 16:56:36 +0000

Why Ruby on Rails Developers Don't Need to Switch to Python for AI

For the last few years, every AI conversation seemed to end with the same conclusion:

"If you want to build AI applications, learn Python."

And yes, Python is currently dominating the AI landscape. Most AI frameworks, tutorials, courses, and research projects are built around Python. Tools like PyTorch, Hugging Face, LangChain, and countless AI libraries make it the default choice for machine learning and AI development.

But what if you're already comfortable with Ruby and Rails (like me)?

Do you really need to switch?

I don't think so.

The AI Misconception

Many developers associate AI with:

Training neural networks
Building custom models
Deep learning research
Data science

But the reality is that most companies are not training the next GPT model.

They're building:

AI chatbots
Internal knowledge bases
AI-powered search
Customer support assistants
Workflow automation

These are software engineering problems.

Rails is already good at solving them

A modern AI stack can look surprisingly simple:

Rails API
+
RubyLLM
+
PostgreSQL + pgvector
+
Sidekiq
+
OpenAI / Claude / Gemini

With this setup you can build a complete RAG (Retrieval-Augmented Generation) application (I've built chatbot at Roomspilot with that stack).

For example:

Upload PDFs or documentation
Split content into chunks
Generate embeddings
Store them in PostgreSQL using pgvector
Retrieve relevant content through vector search
Send the context to an LLM

That's basically how many production AI assistants work today.

FastAPI vs Rails API Mode

A common AI stack in Python looks like this:

FastAPI
+
PostgreSQL
+
Vector Database
+
OpenAI

The Ruby equivalent is:

Rails API Mode
+
PostgreSQL + pgvector
+
RubyLLM
+
OpenAI

Different language.

Same architecture.

As Rails developers, we already know how to build APIs, background jobs, authentication systems, multi-tenant applications, and scalable products.

The AI part is often just another integration.

Where Python still wins

If your goal is:

Model training
Deep learning
Computer vision
AI research

Python is the clear winner.

No debate there.

Where Rails still shines

If your goal is shipping AI-powered products quickly, Rails remains an excellent choice.

You don't have to throw away years of experience just because AI became the hottest topic in tech.

Sometimes the smartest move isn't learning an entirely new stack.

It's adding new capabilities to the stack you already master.

Deploy Rails app with PostgreSQL, Redis and Sidekiq on Production and Staging using Kamal

Stoyan — Thu, 07 Mar 2024 08:13:09 +0000

Step 1: Install Kamal

Article is for those who already have installed kamal with ready to use servers but if you doesn't, just take a look on Kamal gem and make sure that is installed on your local machine:

gem install kamal

Step 2: Configure Deployment Settings

Move into the application directory and run:

kamal init

This process generates a deployment configuration file named config/deploy.yml, in addition to several other files. We will now delve into the different sections of the deploy.yml configuration file to understand their purposes and configurations.

deploy.yml

# Name of your application. Used to uniquely configure containers.
service: myrailapp

# Name of the container image.
image: mydockerhubuser/myrailapp


# Credentials for your image host.
registry:
  username: mydockerhubuser
  password:
    - KAMAL_REGISTRY_PASSWORD

# Inject ENV variables into containers (secrets come from .env).
# Remember to run `kamal env push` after making changes!
env:
  clear:
    RAILS_SERVE_STATIC_FILES: true
    DB_HOST: 10.0.0.6
  secret:
    - RAILS_MASTER_KEY
    - POSTGRES_PASSWORD

volumes:
  - "/storage:/rails/storage"

# Use accessory services (secrets come from .env).
accessories:
  db:
    image: postgres:15
    host: 66.100.100.10
    port: 5432
    env:
      clear:
        POSTGRES_ROOT_HOST: '%'
        POSTGRES_USER: 'db_uss1_app'
      secret:
        - POSTGRES_PASSWORD
    directories:
      - data:/var/lib/postgresql/data
  redis:
    image: redis:latest
    host: 61.111.111.1
    port: 6379
    directories:
      - data:/var/lib/redis/data

In our example, we utilize DockerHub and connect to it using the DockerHub username 'mydockeruser' and the repository name 'myrailapp' (which can be private). The password is configured via the KAMAL_REGISTRY_PASSWORD environment variable within the .env file, located in the root directory of the application. Additionally, it's crucial to remember to list .env files in the .gitignore to prevent them from being tracked and uploaded to version control systems.DB_HOST using local IP of the machine but you can use your public server address as well.

.env

KAMAL_REGISTRY_PASSWORD=dckr_pat_382391340045824911111
RAILS_MASTER_KEY=25345k34j543132432m5j4234
POSTGRES_PASSWORD=s0meR@andomPasw0rt

To separate the staging and production environments, we should create two additional files: deploy.staging.yml for staging and deploy.production.yml for production. In this scenario, the staging environment will be deployed on a single server, while the production environment will be deployed across two servers. Both environments will share a common server for the database and jobs (utilizing a Redis server), albeit with different databases to ensure separation of staging and production data.

deploy.staging.yml

servers:
  web:
    hosts:
      - 60.100.100.101
  job:
    hosts:
      - 61.111.111.1
    cmd: bundle exec sidekiq -e staging
env:
  clear:
    POSTGRES_DB: app_staging
    RAILS_ENV: staging

deploy.production.yml

servers:
  web:
    hosts:
      - 60.100.100.102
      - 60.100.100.103
  job:
    hosts:
      - 61.111.111.1
    cmd: bundle exec sidekiq -e production
env:
  clear:
    POSTGRES_DB: app_production
    RAILS_ENV: production

Do not forget to create .env.staging as well which can be a copy of the .env if the credentials are the same.

Step 3: Deploy Application

kamal setup

Daily operations:

kamal deploy -d staging

kamal deploy -d production

Here is how we do in Roomspilot, also check kamal docs for more commands and use cases.

DEV Community: Stoyan