Overview - REST API fundamentals review

What is it?

REST API fundamentals cover how web services communicate using standard web protocols. REST stands for Representational State Transfer, a style that uses simple HTTP methods like GET, POST, PUT, and DELETE to perform actions on resources. These resources are identified by URLs, and data is often exchanged in formats like JSON or XML. Understanding REST APIs helps you test and interact with web services effectively.

Why it matters

Without REST APIs, different software systems would struggle to talk to each other easily over the internet. REST APIs provide a simple, standardized way to access and manipulate data remotely. This makes building, testing, and maintaining software faster and more reliable. If REST APIs didn’t exist, developers would spend much more time creating custom communication methods, leading to more bugs and slower progress.

Where it fits

Before learning REST API fundamentals, you should understand basic web concepts like HTTP and URLs. After mastering REST APIs, you can explore advanced API testing techniques, automation with tools like Postman, and concepts like authentication, versioning, and API design.

Mental Model

Core Idea

REST APIs let clients and servers exchange data by using simple, standard HTTP methods to act on resources identified by URLs.

Think of it like...

Using a REST API is like ordering food at a restaurant: you tell the waiter (server) what you want (resource) and how you want it (HTTP method), then the waiter brings your order (response).

┌───────────────┐       HTTP Request       ┌───────────────┐
│    Client     │ ───────────────────────▶ │    Server     │
└───────────────┘                         └───────────────┘
       ▲                                         │
       │                                         │
       │           HTTP Response                  │
       └─────────────────────────────────────────┘

Resources identified by URLs:
GET /users/123  → Get user 123
POST /users     → Create new user
PUT /users/123  → Update user 123
DELETE /users/123 → Delete user 123

Build-Up - 7 Steps

1

FoundationUnderstanding HTTP Methods Basics

Concept: Learn the main HTTP methods used in REST APIs and what they do.

There are four main HTTP methods in REST: - GET: Retrieve data from the server. - POST: Send new data to the server. - PUT: Update existing data on the server. - DELETE: Remove data from the server. Each method tells the server what action to perform on a resource.

Result

You can identify what action a REST API call will perform just by looking at its HTTP method.

Knowing HTTP methods is essential because they define the basic actions you can perform on resources in REST APIs.

2

FoundationResources and URLs in REST

3

IntermediateRequest and Response Structure

4

IntermediateUsing Postman for API Testing

5

AdvancedHandling Status Codes and Errors

6

AdvancedREST API Idempotency and Safety

7

ExpertREST API Versioning and Evolution

Under the Hood

REST APIs work over HTTP, where clients send requests to servers using URLs and methods. The server processes the request, accesses or modifies resources, and sends back a response with status codes and data. Internally, servers map URLs to functions or database queries. HTTP headers carry metadata like content type and authentication tokens. The stateless nature means each request is independent, so servers don’t keep client state between calls.

Why designed this way?

REST was designed to use existing web standards simply and flexibly. By using HTTP methods and URLs, it avoids inventing new protocols. Statelessness improves scalability and reliability because servers don’t need to remember clients. This design fits the web’s distributed nature and allows many clients and servers to interact easily.

┌───────────────┐       HTTP Request       ┌───────────────┐
│    Client     │ ───────────────────────▶ │    Server     │
│ (Postman)     │                         │ (API Logic)   │
└───────────────┘                         └───────────────┘
       ▲                                         │
       │                                         │
       │           HTTP Response                  │
       └─────────────────────────────────────────┘

Server internals:
┌───────────────┐
│ URL Routing   │
├───────────────┤
│ Controller    │
├───────────────┤
│ Business Logic│
├───────────────┤
│ Database      │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does a 200 OK status code always mean the API request succeeded perfectly? Commit to yes or no.

Common Belief:A 200 OK status code means the API request was successful and the data is correct.

Tap to reveal reality

Quick: Can POST requests be safely repeated without causing duplicate data? Commit to yes or no.

Common Belief:POST requests are safe to repeat because they just send data to the server.

Tap to reveal reality

Quick: Is REST API communication always stateful, remembering previous requests? Commit to yes or no.

Common Belief:REST APIs keep track of client state between requests to manage sessions.

Tap to reveal reality

Quick: Does changing an API always require clients to update immediately? Commit to yes or no.

Common Belief:Any API change breaks existing clients and forces immediate updates.

Tap to reveal reality

Expert Zone

1

Understanding that REST’s statelessness improves scalability but requires clients to handle state, which affects test design.

2

Knowing that HTTP caching headers can affect API responses and tests, sometimes causing stale data if not handled properly.

3

Recognizing that some APIs mix REST principles with RPC or GraphQL styles, requiring flexible testing approaches.

When NOT to use

REST APIs are not ideal when you need real-time communication or complex queries; alternatives like WebSockets or GraphQL may be better. Also, for very simple internal services, lightweight protocols like gRPC might be preferred.

Production Patterns

In real-world projects, REST APIs are tested using automated Postman collections integrated into CI/CD pipelines. Versioning is carefully managed to avoid breaking clients. Tests include checking authentication, rate limiting, and error handling to ensure robustness.

Connections

HTTP Protocol

REST APIs build directly on HTTP methods and status codes.

Understanding HTTP deeply helps you grasp why REST APIs behave as they do and how to troubleshoot issues.

Software Design Patterns

REST follows architectural principles like statelessness and resource-based design.

Knowing design patterns clarifies why REST APIs are structured for scalability and simplicity.

Supply Chain Management

Both REST APIs and supply chains manage resources and state transitions systematically.

Seeing REST as managing resource states like supply chains manage goods helps understand the importance of clear state and action definitions.

Common Pitfalls

#1Ignoring HTTP status codes and only checking response data.

Wrong approach:if (response.body) { console.log('Success'); }

Correct approach:if (response.status === 200) { console.log('Success'); }

Root cause:Misunderstanding that status codes communicate success or failure separately from response content.

#2Sending POST requests repeatedly without checking for duplicates.

Wrong approach:post('/users', newUserData); post('/users', newUserData);

Correct approach:Check if user exists before POST or use idempotent methods like PUT for updates.

Root cause:Not knowing POST is not idempotent and can create multiple resources.

#3Assuming REST APIs maintain session state automatically.

Wrong approach:Send request 1 without auth, then request 2 expecting server remembers user.

Correct approach:Include authentication info in every request, e.g., tokens in headers.

Root cause:Confusing REST statelessness with stateful web sessions.

Key Takeaways

REST APIs use standard HTTP methods and URLs to perform actions on resources, making communication simple and consistent.

Understanding HTTP methods, status codes, and request/response structure is essential for effective API testing.

Tools like Postman make it easy to send requests, inspect responses, and automate tests for REST APIs.

REST APIs are stateless, so each request must contain all necessary information, which affects how tests are designed.

Proper API versioning and error handling ensure APIs evolve without breaking clients and help maintain reliable software.