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.