Learn Ruby - Web Frameworks & Building APIs

#Introduction

In episode 13 you built a simple socket server. Now it's time to jump into the real world: web frameworks that handle routing, params, JSON, and error handling professionally. This is where Ruby truly shines — its web ecosystem is one of the most productive in the world.

This episode 14 dissects it layer by layer: the Rack interface that became Ruby's web standard, the thread-based Puma web server, middleware, the Sinatra micro-framework, an overview of Rails 8.x for large applications, then the practice of building a REST API with routing, JSON responses, params, and error handling.

#Rack and Web Servers

#The Rack Interface

Almost every Ruby web framework stands on Rack — a simple interface bridging applications and web servers. A Rack application is just an object that responds to call(env) with an array of three elements: a status code, a header hash, and a body:

The file above is config.ru — short for rackup. run app tells Rack which application to run. Because the interface is so small, you can test middleware or API prototypes with pure Rack before moving to a framework.

#Puma and Middleware

Puma is the default web server of the Ruby ecosystem — thread-based, meaning one Puma process serves many requests concurrently through a pool of threads. It's far more efficient than a one-process-per-request model. Run it with rackup or directly:

Run a Rack app

gem install rack puma
rackup

rackup reads config.ru, runs the app on top of the Puma server, and serves it on port 4567. Middleware is a component that wraps the app — handling logging, authentication, or compression before the app is called. Both Ruby on Rails and Sinatra use this Rack middleware layer.

#Sinatra: A Micro-Framework for APIs

#Routing and Params

Sinatra is a micro-framework perfect for APIs and small services. Its DSL maps HTTP methods to blocks directly, with params containing all the input — from the query string, form body, to URL segments:

get "/pengguna/:id" do ... end defines a route that captures the :id segment. Inside the block, params["id"] retrieves that segment's value. .to_json turns a hash into a JSON string. Add gem "sinatra" and gem "puma" to your Gemfile, then run:

Run Sinatra

gem install sinatra
ruby app.rb

ruby app.rb runs Sinatra with its built-in server (or Puma when available). The server serves on localhost:4567. Sinatra can run without Bundler for prototypes, but for real projects always use Bundler as in episode 12.

#Error Handling in Sinatra

A good API handles errors explicitly. Sinatra provides the not_found handler for 404s and error for uncaught exceptions:

not_found do ... end returns JSON when no route matches, and error do ... end catches exceptions and returns a 500. For a specific status, use the status 201 helper before the response — for example when creating a new resource.

#An Overview of Rails 8.x

For large web applications — with authentication, background jobs, and many models — Rails 8.x is the primary choice. Rails provides an integrated full-stack solution: ActiveRecord for databases, Action Cable for realtime, and solid-cache and solid-queue as built-in cache and queue layers that replace Redis for many cases. Kamal handles deployment to servers without complex orchestrators, and Propshaft is the modern asset pipeline.

Creating a Rails project is as fast as Sinatra:

Create a Rails project

gem install rails
rails new blog --database=postgresql
cd blog
bin/rails server

rails new blog --database=postgresql creates a complete project with MVC structure, and bin/rails server runs it on port 3000. Rails 8.x makes many things "just work" — that's why it remains the most popular backend framework in the Ruby ecosystem.

#Building a Complete REST API

#Routing, JSON, and Params

Putting it all together: an API resource with Sinatra that handles simple CRUD. Routing is separated per HTTP method following REST conventions:

post "/tugas" do ... end handles POST requests that send data — params["judul"] retrieves a field from the form body or JSON. The per-route get, post, put, delete pattern is the same REST convention Rails uses with resources.

#Timeout and Middleware in Production

For production, consider: body request limits to prevent giant payloads, request logging via middleware, and JSON responses with a consistent shape — for example always { error: "..." } on failure. This consistency makes it easy for API clients to handle all possibilities. We'll continue the security aspects thoroughly in episode 15.

Info

Choose Sinatra when your service is small and focused (API gateway, webhook receiver). Choose Rails when you need full-stack: authentication, admin panels, background jobs, and a growing team. Both stand on Rack, so the principles you learn stay the same.

#Conclusion

Episode 14 brings Ruby into the realm of real applications: the simple Rack interface, the thread-based Puma web server, middleware, Sinatra for quick APIs, an overview of full-stack Rails 8.x, and the practice of building a REST API with routing, JSON, params, and error handling.

Key takeaways:

A Rack app is a call(env) object returning a status, headers, and body.
Puma is the default thread-based web server of the Ruby ecosystem.
Middleware wraps the app for logging, authentication, and transformation.
Sinatra maps HTTP methods to blocks with params as input.
not_found and error in Sinatra handle 404 and 500 with JSON.
Rails 8.x offers full-stack with solid-cache, solid-queue, and Kamal.
REST APIs are built from per-HTTP-method routing with consistent JSON responses.

In the next episode, episode 15, we will discuss security best practices — common vulnerabilities like SQL injection, command injection, XSS, and unsafe deserialization, the Brakeman and bundler-audit security tools, and handling secrets through environment variables. Security isn't an extra feature; it's a core part of development.