# API first design

> type of software architectural system design

**Wikidata**: [Q110322927](https://www.wikidata.org/wiki/Q110322927)  
**Source**: https://4ort.xyz/entity/api-first-design

## Summary
API first design is a type of software architectural system design that prioritizes the application programming interface (API) as a foundational component of the development process. It is formally classified as a subclass of software architecture, distinguishing itself from traditional approaches like monolithic application design by treating interfaces as primary products rather than afterthoughts.

## Key Facts
- **Classification:** Subclass of software architecture.
- **Core Component:** Has part(s) include the application programming interface (API).
- **Architectural Opposite:** Identified as the opposite of monolithic application design.
- **Wikipedia Presence:** Has 1 sitelink, specifically in the Hungarian language.
- **External Resources:** Described by sources including `apifirst.vercel.app`, `swagger.io`, `medium.com`, and `utveckling.sundsvall.se`.
- **Definition:** Defined as a "type of software architectural system design."

## FAQs
### Q: How does API first design relate to software architecture?
A: API first design is a specific subclass or pattern within the broader discipline of software architecture. While software architecture encompasses the high-level structures and organization of any software system, API first design specifically focuses on systems where the API is the central element of the design.

### Q: How does API first design differ from monolithic application design?
A: API first design is explicitly described as the opposite of monolithic application design. While monolithic designs bundle all functionality into a single, indivisible unit, API first design treats the application programming interface as a distinct, primary component, facilitating modular interactions.

### Q: What is the primary component of API first design?
A: The application programming interface (API) is a fundamental part of this architectural style. This approach ensures that the API is defined and developed as a critical asset within the system's structure.

## Why It Matters
API first design matters because it addresses the modern necessity for interoperability and modularity in software development. As a distinct subclass of software architecture, it shifts the focus from internal code structure to external connectivity, ensuring that systems can communicate effectively with other services and clients from the outset. By positioning the API as a "first-class citizen" in the design phase, this approach mitigates the integration issues often found in monolithic application designs. It supports the creation of high-level structures that are inherently more flexible and scalable, aligning with the broader goals of software architecture to manage complexity and ensure system evolution.

## Notable For
- Being a distinct architectural pattern that serves as the opposite of monolithic application design.
- Prioritizing the application programming interface as a core structural component rather than a secondary feature.
- Existing as a specialized subclass within the academic and professional discipline of software architecture.
- Having specific documentation and strategy resources available in both English and Swedish (e.g., Sundsvall municipality's API strategy).

## Body
### Architectural Classification
API first design is formally classified as a subclass of **software architecture**. It inherits the principles of its parent discipline, which is defined as the high-level structure of a software system involving the organization of components, their relationships, and the principles guiding design and evolution. While software architecture is a broad academic discipline practiced by software architects and distinct from computer architecture (which deals with hardware), API first design represents a specific methodological approach within this field.

### Core Components and Structure
The structural definition of API first design relies heavily on the **application programming interface**. In this architectural style, the API is listed as a distinct "part" of the system's design. This implies a modular structure where the interface layer is critical to the system's operation, contrasting with designs where the UI or database might drive the architecture. This approach aligns with the broader software architecture goal of managing complexity through defined structures and patterns.

### Relationship to Monolithic Design
A defining characteristic of API first design is its classification as the **opposite of monolithic application design**. Where monolithic application design typically involves a unified, self-contained codebase where functions are managed within a single complex structure, API first design emphasizes the separation of concerns through interfaces. This distinction places it among modern architectural approaches that prioritize decoupling and interoperability.

### Documentation and Global Presence
The concept is supported by various resources and has a specific digital footprint. It is described at multiple URLs, including industry resources like Swagger.io and community discussions on Medium. Additionally, it is the subject of strategic documentation for specific regions, such as the API strategy for Sundsvall (`utveckling.sundsvall.se`). Its encyclopedic presence is currently limited, with a sitelink count of 1, specifically appearing in the **Hungarian** language version of Wikipedia.