API-only application setup in Ruby on Rails - Step-by-Step Execution

Concept Flow - API-only application setup

Run rails new with --api

↓

Create minimal Rails app

↓

Skip views, assets, helpers

↓

Configure middleware for API

↓

Generate controllers with API responses

↓

Start server to serve JSON only

This flow shows how Rails creates a lightweight app focused on API, skipping UI parts and setting middleware for JSON responses.

Execution Sample

Ruby on Rails

rails new my_api --api
cd my_api
rails server

Creates a new Rails app optimized for API use, then starts the server to handle API requests.

Execution Table

Step	Command/Action	Effect	Resulting App State
1	rails new my_api --api	Creates new Rails app with API-only config	App folder with minimal files, no views/assets/helpers
2	cd my_api	Change directory to app folder	Ready to run commands inside app
3	rails server	Starts Rails server with API middleware	Server runs, ready to accept JSON API requests
4	Generate controller	Creates controller with JSON responses	Controller file ready to handle API endpoints
5	Send API request	Server processes request and returns JSON	Client receives JSON data
6	Stop server	Server stops running	App idle, no requests handled

💡 Server stops or app is closed, ending API service

Variable Tracker

Variable	Start	After Step 1	After Step 3	After Step 5	Final
App files	None	Minimal API files created	Server middleware loaded	Controllers handle JSON	App ready for API use
Server status	Stopped	Stopped	Running	Running	Stopped

Key Moments - 3 Insights

Why does the app have no views or assets after creation?

Because the --api flag tells Rails to skip UI parts, focusing only on backend API code as shown in execution_table step 1.

How does the server know to respond with JSON only?

The API-only middleware loaded at server start (step 3) configures Rails to handle requests and respond with JSON by default.

What happens if you try to access a normal HTML page?

Since views are skipped, the app will not serve HTML pages, only JSON API responses, as seen in the app state after step 1 and 3.

Visual Quiz - 3 Questions

Look at the execution_table, what is the app state immediately after running 'rails new my_api --api'?

A Full Rails app with views and assets

B Minimal API-only app without views or assets

C Empty folder with no files

D App with server running

💡 Hint

Check execution_table row 1 under 'Resulting App State'

At which step does the Rails server start running?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at execution_table row 3 under 'Command/Action'

If you remove the --api flag when creating the app, how would the execution_table change?

A Step 1 would create a full app with views and assets

B Server would not start at step 3

C Controllers would not be generated

D App would only respond with XML

💡 Hint

Refer to key_moments about what --api flag does in step 1

Concept Snapshot

rails new my_api --api
Creates a minimal Rails app focused on API only
No views, helpers, or assets included
Middleware set for JSON responses
Start server with rails server
App serves JSON API endpoints only

Full Transcript

This visual execution shows how to set up a Rails API-only application. First, running 'rails new my_api --api' creates a minimal app without views or assets. Then, changing directory and starting the server loads middleware configured for API use. Controllers can be generated to respond with JSON. The server runs and handles API requests, returning JSON data. The app does not serve HTML pages because it is API-only. Stopping the server ends the API service. Key points include understanding the --api flag skips UI parts and configures middleware for JSON responses.

Practice

1. What is the main purpose of creating a Rails application with the --api flag?

easy

A. To generate a full Rails app with HTML views and assets

B. To enable automatic frontend scaffolding

C. To create a lightweight backend that serves JSON responses only

D. To create a desktop application using Rails

Solution

1. Step 1: Understand the --api flag purpose

   The --api flag creates a Rails app optimized for API use, focusing on JSON responses without HTML views.

2. Step 2: Compare with full Rails app

   Full Rails apps include views and assets, but API-only apps skip these for lightweight backend.

3. Final Answer:

   To create a lightweight backend that serves JSON responses only -> Option C

4. Quick Check:

   API-only app = JSON backend [OK]

Hint: API-only means JSON backend, no HTML views [OK]

Common Mistakes:

• Thinking API-only apps generate HTML views
• Confusing API-only with full Rails app
• Assuming API-only creates frontend code

2. Which command correctly creates a new Rails API-only application named my_api?

easy

A. rails new my_api --full

B. rails new my_api --api

C. rails generate api my_api

D. rails create my_api --api-only

Solution

1. Step 1: Recall the Rails new command syntax

   The correct way to create an API-only app is using rails new app_name --api.

2. Step 2: Match the command with the app name

   Using rails new my_api --api matches the requirement exactly.

3. Final Answer:

   rails new my_api --api -> Option B

4. Quick Check:

   rails new + app name + --api = correct command [OK]

Hint: Use 'rails new app_name --api' to create API apps [OK]

Common Mistakes:

• Using --full instead of --api
• Using 'generate' instead of 'new'
• Incorrect flag like --api-only

3. Given this Rails API-only controller code, what will be the JSON response when accessing /api/greetings?

class Api::GreetingsController < ApplicationController
  def index
    render json: { message: 'Hello, API!' }
  end
end

medium

A. Redirect to root path

B. Hello, API!

C. Error: Missing view template

D. {"message":"Hello, API!"}

Solution

1. Step 1: Analyze the controller action

   The index action uses render json: to send a JSON response with a message.

2. Step 2: Understand API-only behavior

   API-only apps respond with JSON, so the output is the JSON string of the hash.

3. Final Answer:

   {"message":"Hello, API!"} -> Option D

4. Quick Check:

   render json = JSON output [OK]

Hint: render json sends JSON, not HTML [OK]

Common Mistakes:

• Expecting HTML output in API-only app
• Assuming missing view causes error
• Thinking it redirects automatically

4. You created a Rails API-only app but get an error: ActionController::UnknownFormat when requesting JSON. What is the likely cause?

medium

A. The controller action does not specify render json:

B. The app was created without the --api flag

C. The route is missing in routes.rb

D. The database is not migrated

Solution

1. Step 1: Understand the error meaning

   ActionController::UnknownFormat means the controller does not know how to respond to the requested format.

2. Step 2: Check controller response method

   If the action lacks render json:, Rails can't respond with JSON, causing this error.

3. Final Answer:

   The controller action does not specify render json: -> Option A

4. Quick Check:

   UnknownFormat = missing render json [OK]

Hint: Always use render json in API controllers [OK]

Common Mistakes:

• Assuming missing --api flag causes this error
• Thinking missing route causes UnknownFormat
• Blaming database migration for format errors

5. You want to add authentication to your Rails API-only app using token-based headers. Which setup step is essential to support this in an API-only app?

hard

A. Add middleware for session and cookies support manually

B. Generate views for login and logout pages

C. Use rails new without --api to enable sessions

D. Disable JSON responses to allow HTML forms

Solution

1. Step 1: Understand API-only app default middleware

   API-only apps exclude middleware for sessions and cookies by default to stay lightweight.

2. Step 2: Add middleware manually for token auth

   To support token-based authentication using headers, you often need session or cookie middleware added manually.

3. Final Answer:

   Add middleware for session and cookies support manually -> Option A

4. Quick Check:

   API-only needs manual middleware for sessions [OK]

Hint: Add session middleware manually for token auth [OK]

Common Mistakes:

• Expecting views for login in API-only app
• Recreating full app without --api flag
• Disabling JSON responses breaks API design