⚡ Supercharge Your Rails APIs with Fast JSON API 🚀

Build Blazing Fast APIs in Ruby on Rails Like a Pro 🔥

“Your API is only as good as its response speed.” ⚡

Modern frontend applications:

• ⚛️ React
• ▲ Next.js
• 📱 Flutter
• 📲 React Native
• 🖥️ Vue

all depend heavily on APIs.

And if your Rails API becomes slow… 😭

Your entire application feels slow.

That’s where Fast JSON API comes in 💥

🌟 What You’ll Learn

By the end of this guide, you’ll know how to:

✅ Build super-fast JSON APIs ✅ Serialize Rails models cleanly ✅ Include relationships ✅ Customize responses ✅ Improve API performance ✅ Follow JSON:API standards ✅ Build production-ready APIs

And trust me…

Your API responses will become ✨ BEAUTIFUL ✨

🤔 What is Fast JSON API?

Fast JSON API is a blazing-fast serializer library originally built by:

Netflix 🔥

It helps Rails applications:

✅ Convert models into JSON ✅ Improve API performance ✅ Structure responses cleanly ✅ Reduce serialization time dramatically

😭 The Problem with Default Rails JSON

Most beginners do this:

render json: @users

And Rails returns EVERYTHING 😵

Example:

{
  "id": 1,
  "name": "Ravi",
  "created_at": "...",
  "updated_at": "...",
  "password_digest": "..."
}

Problems:

❌ Exposes unnecessary data ❌ Slow for large responses ❌ Hard to customize ❌ Poor API structure

🚀 Why Fast JSON API is Amazing

With Fast JSON API:

✅ Faster serialization ✅ Cleaner responses ✅ Better frontend integration ✅ Relationship support ✅ Smaller payloads ✅ Standardized APIs

🏗️ Final Architecture

Rails Model
     ↓
Serializer
     ↓
Fast JSON API
     ↓
Beautiful JSON Response 🚀

⚙️ Step 1 — Create Rails API App

You can use existing Rails app OR create API-only app.

rails new blog_api --api

Move into project:

cd blog_api

📦 Step 2 — Add Fast JSON API Gem

Open Gemfile

gem 'jsonapi-serializer'

Install gems:

bundle install

🤔 Wait… Why jsonapi-serializer?

The original fast_jsonapi gem became inactive.

Now the maintained version is:

jsonapi-serializer

And it’s AWESOME 🔥

🧱 Step 3 — Generate Sample Model

Let’s create a blog system.

rails generate model Post title:string content:text author:string
rails db:migrate

🧠 Step 4 — Create Some Data

Open Rails console:

rails console

Create sample records:

Post.create!(
  title: "Fast JSON API Guide",
  content: "Build blazing fast APIs",
  author: "Ravi"
)

🔥 Step 5 — Generate Serializer

Create:

app/serializers/post_serializer.rb

Add:

class PostSerializer
  include JSONAPI::Serializer
  attributes :title, :content, :author
end

🎉 Congratulations

You just created your first serializer 🚀

⚡ Step 6 — Use Serializer in Controller

Generate controller:

rails generate controller api/posts

🧠 Controller Code

class Api::PostsController < ApplicationController
  def index
    posts = Post.all
    render json: PostSerializer.new(posts).serializable_hash
  end
end

🛣️ Step 7 — Add Routes

namespace :api do
  resources :posts, only: [:index]
end

🚀 API Response

Visit:

GET /api/posts

Response:

{
  "data": [
    {
      "id": "1",
      "type": "post",
      "attributes": {
        "title": "Fast JSON API Guide",
        "content": "Build blazing fast APIs",
        "author": "Ravi"
      }
    }
  ]
}

🔥 CLEAN 🔥 STRUCTURED 🔥 PROFESSIONAL

✨ Step 8 — Add Custom Attributes

Want computed fields? 😎

class PostSerializer
  include JSONAPI::Serializer
  attributes :title, :content
  attribute :short_content do |post|
    post.content.truncate(50)
  end
end

🎯 Result

{
  "short_content": "Build blazing fast APIs..."
}

Magic ✨

🔗 Step 9 — Add Relationships

Let’s add comments.

Generate Model

rails generate model Comment body:text post:references
rails db:migrate

🧱 Associations

Post Model

has_many :comments

Comment Model

belongs_to :post

✨ Create Comment Serializer

class CommentSerializer
  include JSONAPI::Serializer
  attributes :body
end

🔥 Update Post Serializer

class PostSerializer
  include JSONAPI::Serializer
  attributes :title, :content
  has_many :comments
end

🚀 Include Relationships

render json: PostSerializer.new(
  posts,
  include: [:comments]
).serializable_hash

🎉 Result

Now API includes:

✅ Posts ✅ Associated comments

in ONE response 🔥

⚡ Step 10 — Improve Performance

Fast JSON API is FAST…

but you still need to avoid N+1 queries 😭

❌ Bad

posts = Post.all

✅ Good

posts = Post.includes(:comments)

Massive performance improvement 🚀

🧠 Step 11 — Conditional Attributes

Show fields only for admins.

attribute :internal_notes,
  if: Proc.new { |record, params|
    params[:admin] == true
  }

Usage

PostSerializer.new(
  posts,
  params: { admin: true }
)

🎯 Step 12 — Meta Information

Add pagination info.

render json: PostSerializer.new(
  posts,
  meta: {
    total: posts.count
  }
).serializable_hash

✨ Response

{
  "meta": {
    "total": 25
  }
}

🔥 Step 13 — Serializer Features You’ll Love

⚡ Lightning Fast

Much faster than:

• ActiveModelSerializers
• JBuilder

🎯 JSON:API Standard

Frontend developers LOVE standardized APIs 😍

🧼 Clean Code

Instead of messy controllers:

render json: ...

you move formatting into serializers.

Beautiful architecture ✨

🔗 Relationship Support

Easily serialize:

✅ has_many ✅ belongs_to ✅ nested relationships

📉 Smaller Payloads

Send ONLY required data.

This improves:

✅ Performance ✅ Mobile experience ✅ Frontend speed

🛡️ Step 14 — Production Best Practices

✅ Cache Serialized Responses

cache_options store: Rails.cache,
              namespace: 'jsonapi',
              expires_in: 1.hour

Huge speed boost ⚡

✅ Use Pagination

Never return 10,000 records 😭

Use:

• Pagy
• Kaminari

✅ Version Your APIs

Good practice:

/api/v1/posts

🚀 Step 15 — Real-World API Structure

app/
 ├── controllers/
 │    └── api/
 │         └── v1/
 │
 ├── serializers/
 │    ├── post_serializer.rb
 │    └── comment_serializer.rb
 │
 └── models/

Professional Rails architecture 🔥

🎉 Final Result

You now have:

✅ Fast Rails APIs ✅ Structured JSON responses ✅ Relationship serialization ✅ Better frontend integration ✅ Production-ready serializers ✅ High-performance API architecture

🌟 Bonus Ideas

Take it NEXT LEVEL 😎

Add:

• API authentication 🔐
• JWT tokens
• API rate limiting 🚦
• GraphQL
• API documentation 📚
• Swagger/OpenAPI
• JSON caching
• Background jobs

💬 Final Thoughts

Fast JSON API makes Rails APIs:

⚡ Faster 🧼 Cleaner 🚀 Scalable 🎯 Professional

Instead of dumping raw database data…

you start building APIs frontend developers LOVE ❤️

And honestly?

Once you use serializers properly…

there’s no going back 😎