Setting Up Rails 8 with MongoDB and Mongoid: Guide for 2026

As Ruby on Rails continues to evolve, the release of Rails 8 has brought modern performance improvements, a cleaner asset pipeline, and better support for API-driven applications. While Rails has traditionally been paired with relational databases such as PostgreSQL or MySQL, many modern applications—especially those requiring flexible schemas, high scalability, or document-based storage—benefit from using MongoDB, the world’s most popular NoSQL database.

To integrate MongoDB seamlessly with a Rails application, developers use Mongoid, a mature and fully-featured Object-Document Mapper (ODM). Mongoid replaces ActiveRecord, allowing Rails apps to work smoothly with MongoDB collections and documents instead of relational tables and rows.

In this comprehensive guide, we will walk through how to set up Rails 8 with MongoDB and Mongoid, step by step. You’ll learn the installation process, project setup, configuration, model creation, routing, and testing—all without touching SQL or migrations. This makes Rails 8 + MongoDB a powerful combination for modern startups, microservices, content-driven applications, and real-time APIs.

Why Choose MongoDB for Rails 8?

Before diving into the installation steps, it’s important to understand why developers choose MongoDB for certain types of Rails applications.

1. Flexible Schema

MongoDB stores data as JSON-like documents, allowing you to evolve schemas without rigid migrations.

2. High Scalability

MongoDB supports horizontal scaling through sharding, making it suitable for high-traffic applications.

3. Ideal for API-Driven Backends

When building Rails 8 APIs that return JSON, MongoDB’s BSON format maps naturally to Ruby hashes.

4. Faster Development Cycles

No migrations, instant data structure changes, and easy embedding of nested objects accelerate development.

5. Great Fit for Microservices

If you’re using Rails in a microservice architecture, MongoDB provides lightweight and independent storage per service.

Mongoid enables Rails developers to enjoy these advantages without changing the familiar MVC structure.

Step 1: Install MongoDB

To begin integrating MongoDB with Rails 8, you need a running MongoDB server.

macOS (using Homebrew)

brew tap mongodb/brew
brew install mongodb-community
brew services start mongodb-community

Ubuntu / Debian

sudo apt update
sudo apt install -y mongodb-org
sudo systemctl enable --now mongod

Windows

Download and install the MongoDB Community Server from the official website.

Step 2: Create a New Rails 8 Project Without ActiveRecord

Rails 8 uses ActiveRecord by default, but MongoDB does not use SQL tables or migrations. So, when generating the Rails app, skip ActiveRecord entirely:

rails new myapp --skip-active-record
cd myapp


This avoids unnecessary SQL database files and configurations.

Step 3: Add Mongoid to Your Rails Application

Edit your Gemfile:

gem "mongoid", "~> 9.0"

Mongoid 9+ is optimized for Rails 7 & 8.

Install gems:

Bundle-Installation

Step 4: Generate Mongoid Configuration

Mongoid provides a generator to create the configuration file:
rails g mongoid:config

This creates:
config/mongoid.yml

Inside this file, you’ll see a default development configuration pointing to:
mongodb://localhost:27017/myapp_development

You can customize the database name or add replica sets, authentication, or SSL later.

Step 5: Configure the MongoDB Connection (Optional but Recommended)

You can modify the default section of mongoid.yml:

Entwicklung:
  Kunden:
    Standard:
         database: myapp_db
               Gastgeber:
                  - localhost:27017
               options:
                     server_selection_timeout: 5

MongoDB automatically creates the database when Rails inserts the first record.

Step 6: Create a Mongoid Model

Mongoid models look very similar to ActiveRecord but use modules instead of inheriting from ActiveRecord::Base.

Generate a model:

rails g model Article

Open the model file and modify it:

class Article
    Mongoid::Document einschließen   
   include Mongoid::Timestamps
    field :title, type: String
   field :body,  type: String
Ende

Key Mongoid Features:

• No migrations required
• Fields specified directly in the model
• Embedding documents is supported
• Associations include: embeds_one, embeds_many, has_many, belongs_to
  

Step 7: Add a Controller and Routes

Generate a controller:

rails g controller articles

Edit articles_controller.rb:

Klasse ArticlesController < ApplicationController
   Def-Index
   @articles = Article.all
      render json: @articles
Ende
 auf jeden Fall erstellen
 @article = Article.new(article_params)
  wenn @article.save
        render json: @article, status: :created
 anders
        render json: @article.errors, status: :unprocessable_entity
Ende
Ende
 Privat

def Article_params
       params.require(:article).permit(:title, :body)
Ende
Ende

Add the routes:

Rails.application.routes.draw tun
   Ressourcen: Artikel
Ende

Step 8: Start the Rails Server

Run your Rails 8 application:

Schienen s

Visit: 

http://localhost:3000/articles

You should receive an empty JSON array until you add data.

Step 9: Create Data with a POST Request

You can test the API using curl:

curl -X POST http://localhost:3000/articles \
     -H "Content-Type: application/json" \
     -d '{"article": {"title": "Hello MongoDB", "body": "Using Rails 8 with Mongoid!"}}'

Refreshing /articles will now return your stored documents.

Rails 8 + Mongoid: How It Works Behind the Scenes

Mongoid replaces ActiveRecord completely. Instead of interacting with SQL tables, it talks to MongoDB collections.

ActiveRecord Model (SQL)

• Stored in tables
• Requires migrations
• Strict schema

Mongoid Model (MongoDB)

• Stored as BSON documents
  
• Schema is flexible
• No migrations required
  
• Nested objects supported
  

Mongoid gives Rails the same high-level abstraction as ActiveRecord while using MongoDB’s powerful, scalable design.

Advantages of Using Rails 8 with Mongoid

1.  Migrations Are Gone

Every change to your model instantly reflects in the database.

2. Embedded Documents

MongoDB allows nested structures like:

embeds_many :comments

This reduces the need for joins.

3. Faster Iteration

Rapid development cycles, ideal for MVPs and startups.

4. Modern Architecture Ready

Perfect for:

• Headless Rails APIs
  
• Microservices
• Real-time apps
• Mobile backends

5. Full Rails Features Still Work

Routing, controllers, views, caching, and authentication libraries integrate seamlessly.

Common Use Cases for Rails 8 + MongoDB

1. Social Media Apps

Post structures vary and evolve constantly.

2. IoT and Sensor Data Apps

Large volumes of semi-structured data.

3. E-commerce Catalogs

Products with variable attributes.

4. Headless CMS or Content Platforms

Flexible schemas for articles and metadata.

5. Microservices

Lightweight services without SQL dependencies.

Best Practices When Using Mongoid

1. Create Proper Indexes

Mongoid allows:

index({ title: 1 })

2. Avoid SQL Mindset

Denormalize data when beneficial.

3. Use Embedded Documents Carefully

Use for small nested data; avoid embedding huge arrays.

4. Monitor Query Performance

Use MongoDB Compass or Atlas tools.

5. Secure Production Deployment

Enable:

• Authentication
  
• TLS/SSL
  
• Replica sets
  
• Connection pooling
  

Abschluss

Setting up Rails 8 with MongoDB using Mongoid is a smooth and powerful combination for building scalable, flexible, and high-performance applications. Mongoid’s ActiveRecord-like syntax makes working with NoSQL simple, while MongoDB’s document structure supports dynamic, real-time, and data-intensive features effortlessly.

As businesses move toward microservices, real-time dashboards, AI-driven insights, and flexible backend systems, this tech stack becomes even more relevant.

SchienenCarma, a trusted Ruby on Rails-Entwicklungsunternehmen, specializes in modern Rails architectures, MongoDB integrations, and scalable backend solutions. With deep expertise in Rails 8, NoSQL ecosystems, and high-performance app development, RailsCarma helps businesses build powerful applications tailored to growth and innovation.

If you’re planning to adopt MongoDB with Rails or modernize your existing application, partnering with a team like SchienenCarma ensures robust engineering, clean code, and future-ready solutions.