The Building Blocks of a Good API

We are experts on API design and API development solutions. Our API solutions deliver optimal business value regardless of the size of your enterprise. From using the right HTTP codes to API versioning, authentication, and caching, AVIO is the experienced partner you need.

Whether you need custom APIs or third-party interface integrations, we have highly skilled professionals to help you, so that you can focus your attention on your business strategy for improved customer outcomes.

Start Your Evolution

Companies who trust AVIO

Conagra Brands

How to Recognize a Good API Design

A well-designed API should be easy to read and work with. It should be relatively easy for developers to memorize the associated operations and resources. Good API design should also be hard to misuse, reducing the likelihood of writing incorrect code. What’s more, you will know an API design is complete if it allows developers to create full-fledged applications against exposed data.

It is a good practice for API design to ensure system design visibility. This visibility ensures that the system informs developers of what is going on, improving the development experience.
Good API design should use conventions, patterns, and language that match the developer’s world. The programming language and the tools available for coding should be based on concepts that the developer understands.

If the typical developer that uses the API finds themselves wondering what certain words, actions, and situations mean, then that API design is not good enough. This calls for design consistency using initially established standards.

Failure to do this leads to more code as developers write new code to handle the inconsistencies. Good API design should not the conventions established elsewhere in the design.

While it is good for the developer to be notified when an error occurs, it is even better if the API is designed to prevent the problems from materializing in the first place. In API design, errors occur either during client development or after the client is fully developed and published.

The errors during client development might include misunderstood meanings, syntax, and typos. The errors visible after the client is published might include unexpected data as well as changes that make the application unusable.

HTTP status codes give failure or success responses to a client. The codes are classified as:

  • 2xx Success codes (e.g. 200 OK and 201 Created)
  • 3xx Redirection codes (e.g. 304 Not Modified)
  • 4xx Client Errors (e.g. 400 Bad Request and 403 Unauthorized)
  • 5xx Server Errors (e.g. 502 Bad Gateway).

For efficiency and flexibility, an API should have an easy-to-use interface for novice developers, with additional optional controls designed to improve efficiency. The expert developer should have the option to use these accelerators, which may be invisible to beginners, to improve system interactions.

Error messages in an API should be expressed in the simplest possible language. They should include no code, precisely explain what the problem is, and effectively suggest possible solutions. That said, for runtime-machine-based users, it is within reason to include some easily parseable error codes in client programs that need to make decisions based on runtime conditions.

It is good practice in API design to include documentation, even in scenarios where it is possible to use the system without that information. It should also be easy for users to use certain query parameters to search for this information.

The help and documentation should focus on the task that the developer is trying to complete. The help and documentation should not be too large and should list the steps that the developer needs to carry out.

Building a Successful API

In most scenarios, API designs change over time with shifts in business requirements. At some point, it may become necessary to add new collections of resources, amend the data structure in the resources, and review the changing relationships between the resources.

Free and open-source tools like Swagger editor can help to better design and document APIs as these changes take place. For successful API development, consider following this API development lifecycle:

Designing the API

Before you can develop your business logic and technological artifacts, you have to design your API. Your API design is the forcing function that puts your persona targeting and API objectives into a machine and human-readable document for your technical teams and business executives to consume

HTTP methods are said to be safe if they return the same resource information/representation regardless of the number of times the client makes the requests. Similar to how a web page is rendered, APIs use HTTP requests to gather information from a web server or application.

Typically, APIs are classified into two: SOAP APIs and REST APIs. SOAP uses XML to offer messaging solutions while REST takes a more lightweight approach often using URLs to send or receive information. OpenAPI Specification (OAS) is the industry standard for API interface design within the REST ecosystem.

REST APIs use uniform interfaces that help decouple service and client implementations. For a REST API built on HTTP, a typical interface would include standard HTTP verbs that developers can use to perform various operations on resources. HTTP clients use the Accept header to inform the server about the content types they can accept.

Virtualizing API Dependencies

APIs are built for interoperability. As components and dependencies grow, applications become increasingly complex. As a result, navigating these dependencies becomes a challenge. This makes it necessary to employ API virtualization.

Virtualization involves the creation of virtual copies of dependencies. It mirrors the specifications of the API being developed. Through API virtualization:

  • Backend and frontend teams can work on the API in parallel

  • You can use dummy data to create a mock API. Such a mock API comes in handy when you need early feedback to refine your development process.

Testing the API

It is during this phase that you test your API to find any inconsistencies, deviations, and bugs that make it not perform as intended. Some of the tests you could carry out include reliability testing, functional testing, security testing, and load testing. You can prioritize the tests based on the API’s target audience and objectives.

Functions of APIs

  • POST methods in REST APIs are used to create a resource and add it to the collection of resources.

  • PUT APIs update existing resources

  • GET requests are used to retrieve resource information or representation without modifying it.

  • Developers use the DELETE operation to delete resources.

  • PATCH requests modify resources for more clarity.

POST, PUT, GET, DELETE, and PATCH are the most common operations. They take JSON as the request body returning JSON as the response. For web APIs, JSON is, perhaps, the most popular data format.

When designing REST APIs, ensure REST API apps respond with JSON and that clients interpret it accordingly. You do this by setting Content-Type to application/JSON in the response header after a request is made. The majority of server-side app frameworks do this automatically.

Building Business Logic for the API

In this stage, you take the layer of your human and machine-readable API design and convert it into business logic and actual code. To do this, it is important to carefully choose the correct technology framework.

Because the Open API design layer is language- agnostic, it allows the different developers working on the API to create the business logic in different programming languages.

You can use a tool like Swagger Codegen to prototype your API faster using the programming language that you’re most comfortable in. The tool uses your API design to auto-generate boilerplate code. With the code generator taking care of the scaffolding in your API code, your developer team will have the time to focus on creating the business logic.

Creating API Documentation

The API documentation allows developers to make the most of your API. It should be concise, yet detailed enough to include all the necessary information for a developer to effectively work with the API. The documentation should include examples and step-by-step tutorials.

Today, there are several API documentation tools available that you can use to auto-generate documentation from your OpenAPI definition layer. When preparing this, you should keep in mind that the documentation will have a direct impact on the growth and adoption of your API.

About AVIO

We are fanatically dedicated to knowing you, because the more deeply we understand you, the more concrete and the more accurate our common goal of your digital success becomes. Once we both clearly see where you're going, we work together to settle you into your digital niche and identify strategies for adapting you to it most advantageously. And for seamless continuity from strategy to execution, our strategic helping hand becomes a technical helping hand.

Learn More


Accelerate Your Digital Evolution

AVIO’s award-winning team of certified professionals provides the expert consultation required to ensure your implementation accelerates your evolution.