API Design

0%Certificate0/124

Join the Community

What Is an API?

Why API Design Matters

APIs vs SDKs vs Libraries

Public, Private, Partner, and Internal APIs

The API Landscape

Principles of Good API Design

Synchronous vs Asynchronous APIs

Anatomy of HTTP Request and Response

HTTP Method Semantics

Safety, Idempotency, and Cacheability

Headers, Media Types, and Content Negotiation

HTTP Caching Semantics and Conditional Requests

Thinking in Resources

URL Design Rules

Mapping Operations to HTTP Methods

Modeling Actions and State Transitions

Resource Hierarchies and Nested URLs

Relationships, Links, and Resource Navigation

Identifier Design

Designing Create APIs

Designing Read APIs

Designing Update APIs

Partial Updates and Field Masks

Upserts and Conditional Creation

Designing Delete APIs

Filtering Collections

Sorting Collections

Designing Search APIs

Offset vs Cursor Pagination

Bulk and Batch Operations

Choosing the Correct HTTP Status Code

Error Response Design

Validation Errors

Retryable vs Non-Retryable Errors

Partial Failures

Understanding Idempotency

Idempotency Keys

Retries and Duplicate Requests

Concurrent Updates and Lost Updates

Optimistic Concurrency Control

Authentication vs Authorization

OpenID Connect and Identity

JWTs and Bearer Tokens

Access Tokens, Refresh Tokens, and Scopes

Service-to-Service Authentication

Authorization Models: RBAC, ABAC, and Resource-Level Authorization

OWASP API Security Top 10 Walkthrough

Abuse Prevention

Quotas and Usage Limits

Transport and Browser Security: CORS and CSRF

Data Protection

Latency Budgets and Tail Latency

Timeouts, Retries, and Exponential Backoff

Connection-Level Performance

Payload Optimization

Production API Caching Strategies

CDN and Edge Caching for APIs

Asynchronous API Patterns

Long-Running Operations

Webhook Operations

Long Polling vs SSE vs WebSockets

WebSocket Protocol Design

Streaming Responses

Event-Driven Contracts

Why APIs Change

Breaking vs Non-Breaking Changes

Backward-Compatible API Design

API Versioning Strategies

Schema Evolution

Deprecating API Features

Sunset Policies and Client Migration

Introduction to OpenAPI

OpenAPI Document Structure

Defining Paths and Operations

Defining Parameters and Request Bodies

Defining Schemas and Responses

Reusable Components and References

API-First vs Code-First Development

API Mocking, Reference Documentation, and Client Generation

GraphQL Schema Design

Queries and Mutations

GraphQL Pagination

Error Handling and Authorization

N+1 Queries and Performance

Schema Evolution and Deprecation

Introduction to gRPC

Protocol Buffers

gRPC Service Design

Unary and Streaming RPCs

Deadlines, Cancellation, and Errors

Transcoding and Gateways

REST vs gRPC vs Thrift for Microservices

LLM API Patterns

Designing Tool-Friendly APIs

Agent-Safe Design

Backend-for-Frontend

SLIs, SLOs, and Error Budgets

API Test Strategy

API Observability: Logs, Metrics, and Tracing

API Design Reviews

API Style Guides

API as a Product

Anti-patterns Catalog

API Design

Welcome

Course Roadmap
Join the Community

API Fundamentals

What Is an API?
Why API Design Matters
APIs vs SDKs vs Libraries
Public, Private, Partner, and Internal APIs
The API Landscape
Principles of Good API Design
Synchronous vs Asynchronous APIs

HTTP Fundamentals

How HTTP Works
Anatomy of HTTP Request and Response
HTTP Method Semantics
Safety, Idempotency, and Cacheability
Headers, Media Types, and Content Negotiation
HTTP Caching Semantics and Conditional Requests

Resource Modeling

Thinking in Resources
URL Design Rules
Mapping Operations to HTTP Methods
Modeling Actions and State Transitions
Resource Hierarchies and Nested URLs
Relationships, Links, and Resource Navigation
Identifier Design
Payload Design

Collection Design

Designing Create APIs
Designing Read APIs
Designing Update APIs
PUT vs PATCH
Partial Updates and Field Masks
Upserts and Conditional Creation
Designing Delete APIs
Filtering Collections
Sorting Collections
Designing Search APIs
API Pagination
Offset vs Cursor Pagination
Cursor Design
Bulk and Batch Operations

API Error Handling

Choosing the Correct HTTP Status Code
Error Response Design
Validation Errors
Retryable vs Non-Retryable Errors
Partial Failures

Idempotency and Concurrency

Understanding Idempotency
Idempotency Keys
Retries and Duplicate Requests
Concurrent Updates and Lost Updates
Optimistic Concurrency Control

Authentication and Authorization

Authentication vs Authorization
API Keys
OAuth 2.0
OpenID Connect and Identity
JWTs and Bearer Tokens
Access Tokens, Refresh Tokens, and Scopes
Service-to-Service Authentication
Authorization Models: RBAC, ABAC, and Resource-Level Authorization
Multi-Tenancy

API Security

OWASP API Security Top 10 Walkthrough
Input Handling
Rate Limiting
Abuse Prevention
Quotas and Usage Limits
Transport and Browser Security: CORS and CSRF
Data Protection

API Reliability, Performance, and Caching

Latency Budgets and Tail Latency
Timeouts, Retries, and Exponential Backoff
Connection-Level Performance
Payload Optimization
Production API Caching Strategies
CDN and Edge Caching for APIs

Real-Time and Event-Driven APIs

Asynchronous API Patterns
Long-Running Operations
Webhooks
Webhook Operations
Long Polling vs SSE vs WebSockets
WebSocket Protocol Design
Streaming Responses
Event-Driven Contracts

Versioning and API Evolution

Why APIs Change
Breaking vs Non-Breaking Changes
Backward-Compatible API Design
API Versioning Strategies
Schema Evolution
Deprecating API Features
Sunset Policies and Client Migration

API Specifications

Introduction to OpenAPI
OpenAPI Document Structure
Defining Paths and Operations
Defining Parameters and Request Bodies
Defining Schemas and Responses
Reusable Components and References
API-First vs Code-First Development
API Mocking, Reference Documentation, and Client Generation

GraphQL

Why GraphQL?
GraphQL Schema Design
Queries and Mutations
Resolvers
Subscriptions
GraphQL Pagination
Error Handling and Authorization
N+1 Queries and Performance
Schema Evolution and Deprecation
Federation
Security

gRPC

Introduction to gRPC
Protocol Buffers
gRPC Service Design
Unary and Streaming RPCs
Deadlines, Cancellation, and Errors
Transcoding and Gateways
REST vs gRPC vs Thrift for Microservices

Designing AI APIs

LLM API Patterns
Designing Tool-Friendly APIs
MCP Servers
Agent-Safe Design

Production API Design

API Gateways
Backend-for-Frontend
SLIs, SLOs, and Error Budgets
API Test Strategy
API Observability: Logs, Metrics, and Tracing
API Design Reviews
API Style Guides
API Governance
API as a Product
Anti-patterns Catalog

SLIs, SLOs, and Error Budgets

Medium Priority

Premium Content

Subscribe to unlock full access to this content and more premium articles.

Backend-for-Frontend API Test Strategy