Imagine you are an architect standing on an empty field. You wouldn't start laying bricks without a blueprint, right? The same principles apply to API development. I used to use a code-first approach, writing code first and documentation later, until I learned a design-first approach. A design-first approach is to create a detailed API definition before writing any code.

Overview of this guide

Before we dive in, let’s map out our goals. Think of this as your API planning roadmap:

• Learn the basics of API planning
• Explore two different methods
• Make wise choices
• Create your API plan

What you will learn:

1. What does API planning include
2. Code First Approach
3. Design first approach
4. Comparison between code first and design first
5. How to choose the right method
6. Practical steps for API planning

What does API planning include

The foundation of excellent API

API planning isn’t just about technical specifications – it’s also about building a product that others will love using. It's like designing a house where every room has its purpose and is logically connected to the others.

Key questions to answer:

• Who are the consumers? (Front-end developers, third-party partners, etc.)
• What operations does it support? (CRUD operations, integration, etc.)
• How to ensure its safety? (Authentication, rate limiting, etc.)

The Art of Planning

Compare API planning to drawing a masterpiece:

• Code first is like painting without drafting
• Design first is like planning the composition first

Code First Approach

A code-first approach is about jumping directly into coding and creating functionality before writing API structural documentation or design. When I started building APIs, I was a code-first advocate. Here's what I learned:

<code>// 第一天：“這看起來(lái)很簡(jiǎn)單！”
app.get('/users', getUsers);

// 第二周：“哦，等等，我需要過(guò)濾……”
app.get('/users', authenticateUser, validateQuery, getUsers);

// 第三周：“也許我應(yīng)該更好地規(guī)劃一下……”</code>

Quick Tip ?: Code-first works for prototypes, but document your decisions as you go!

How it works

• Start with backend development and mockups.
• Build API endpoints based on your database structure.
• Write API documentation after implementation.

Advantages

• Faster prototyping: ideal for small teams or personal projects.
• Straightforward implementation: focus on building functionality without upfront planning.

Challenge

• Inconsistent design: If multiple developers are involved, the API may lack consistency.
• Iteration is difficult: making significant changes after development can be costly.

Design first approach

The design-first approach emphasizes planning and defining the structure of your API before writing any code. It keeps everyone on the same page. After the API definition is agreed upon, stakeholders such as testers and technical writers can work in parallel with developers.

How it works

• Use tools such as Swagger/OpenAPI to design API patterns.
• Define endpoints, request/response formats and validation.
• Share designs with stakeholders to get feedback.
• Development begins after the design is finalized.

Advantages

• Collaboration: Facilitate early feedback from stakeholders.
• Consistency: Ensure endpoint consistency.
• Mock API: Allows front-end teams to start integrations earlier using mock responses.

Challenge

• Upfront effort: Initial design takes time.
• Expertise required: Developers must be familiar with design tools and best practices.

Code First vs. Design First: Comparison

Code First

• Speed: Faster for simple projects.
• Collaboration: Limited in initial stages.
• Consistency: This may vary by endpoint.
• Flexibility: Easy for solo development.
• Scalability: This may be difficult to scale.

Design first

• Speed: Slow due to early planning.
• Collaboration: Encourage early team collaboration.
• Consistency: Ensure standardized design.
• Flexibility: Great for teams or public APIs.
• Scalability: Designed with scalability in mind.

How to choose the right method

Select Code First if:

• You are building a quick proof of concept or internal API.
• API consumers are a single small team.
• You prioritize speed over design.

Please select Design Priority if the following conditions are met:

• Your API is exposed to external consumers or multiple teams.
• Collaboration and consistency are priorities.
• You are building a public API or a long-term API.

Practical steps for API planning

Step 1: Define the purpose of the API

Before we dive into endpoints and methods, answer these basic questions:

• What problem does your API solve?
• Who is your target user?
• What core functionality do you have to offer?
• What are your non-functional requirements?

Example statement of purpose:

<code>// 第一天：“這看起來(lái)很簡(jiǎn)單！”
app.get('/users', getUsers);

// 第二周：“哦，等等，我需要過(guò)濾……”
app.get('/users', authenticateUser, validateQuery, getUsers);

// 第三周：“也許我應(yīng)該更好地規(guī)劃一下……”</code>

Step 2: Identify core resources

Think of resources as nouns in the API. For our e-commerce example:

Main resources:

• Product
• Inventory
• Warehouse
• Inventory changes

Resource relationship:

<code>// 第一天：“這看起來(lái)很簡(jiǎn)單！”
app.get('/users', getUsers);

// 第二周：“哦，等等，我需要過(guò)濾……”
app.get('/users', authenticateUser, validateQuery, getUsers);

// 第三周：“也許我應(yīng)該更好地規(guī)劃一下……”</code>

Step 3: Define the operation

Now consider what actions (verbs) the user needs to perform on these resources:

<code>此API使電子商務(wù)平臺(tái)能夠?qū)崟r(shí)管理多個(gè)倉(cāng)庫(kù)的庫(kù)存，確保準(zhǔn)確的庫(kù)存水平并防止超賣。</code>

Step 4: Plan the data model

Define clear and consistent data structures:

<code>產(chǎn)品
  └── 庫(kù)存
       └── 倉(cāng)庫(kù)
            └── 庫(kù)存變動(dòng)</code>

Step 5: Plan for Authentication and Security

Think about security from the start:

• Authentication method
• Authorization Level
• Rate Limit
• Data Encryption
• Input verification

Step 6: Write API documentation

Create comprehensive documentation:

API Overview

• Purpose and Scope
• Getting Started Guide
• Authentication details

Endpoint documentation

• Resource Description
• Request/Response Format
• Example call
• Error handling

Use Cases

• Common Scenarios
• Integration example
• Best Practices

Conclusion

Both code-first and design-first approaches are valuable in API development. The key is to choose an approach that fits the project's needs, team size, and long-term goals. Ultimately, whether you choose a code-first or design-first approach, the goal is to create an API that developers love to use. Sometimes the journey is not as important as the destination, but having a good map can make the journey easier!

Looking ahead: CollabSphere case study

In our upcoming blog series, we will put these principles into practice by building CollabSphere, a real-time chat system. You'll see firsthand how I transform code-first projects into design-first masterpieces.

Preview of upcoming content:

• Design chat API from scratch
• Create comprehensive API documentation
• Real-time functionality
• Handling authentication and security

The above is the detailed content of A Guide to Planning Your API: Code-First VS Design-First Approach. For more information, please follow other related articles on the PHP Chinese website!