Hello everyone and welcome back to the Cognixia podcast. Thanks to all our listeners, our Cognixia podcast community is growing steadily and it gives us great joy every week to present to you a fresh new episode of our podcast. So, a big thank you for listening to us, sharing your thoughts and feedback with us, and being a part of this amazing community.
In today’s episode, we talk about some common mistakes that a developer or an IT professional can and must avoid when working with RESTful web API design. A poorly designed API can cause many problems for the users and lead to a very bad user experience. Well-designed APIs, instead, make it very easy for consumer developers to find, explore, access, and utilize the APIs. A poorly designed API can be a result of some common mistakes that one can easily avoid and that is exactly what we are going to discuss in today’s episode.
One can improve the API design using some methods, one of the most common ones being following RESTful practices. Despite using the best practices, one can end up coding some small pitfalls and inconveniences into the API, and in this episode, we are going to tell you some ways in which you can avoid this.
One of the first ways to do this is to think from a different perspective. What we mean by this is that we recommend thinking inside out and not just the usual outside in. An inside-out approach for APIs means the APIs are designed around the internal systems or services that are being exposed to the API. An outside-in approach for APIs would mean designing APIs around the customer experiences that one desires to create. Now, we can all agree that one major purpose that an API serves is that it makes the user developer’s work easier and helps improve their productivity. User developers will always look for and choose an API that makes their work easier and is helpful for them. To make your API their chosen one, you would need to understand what exactly your user developers need to make their work easier, understand their struggles and issues, and challenges, and then offer them solutions that help them with those problems.
To accomplish this, one would need to build a thorough understanding of the customer’s – both internal and external requirements and their use cases. Talk to these customers and learn more about what applications they are building, what are the challenges they are facing, and discuss how you can help make their work easy or simplified, or streamlined. This will help you frame the structure and define a purpose that you want your API to serve. It also gives a better insight into where the payloads overlap, helping you build a better, more useful API.
If direct contact with customers is not a possible option, then at least try to think the way a customer would. Step into their shoes and trace their journey from their perspective to the deepest extent possible. Look at the big picture and be creative in your approach.
The second important thing to do, or rather not to do, is to make your API too complex for the users. The whole point of using an API is so that the users don’t have to deal with complex programming challenges. So, if your API requires learning a whole new system or language or software just to be able to use it in the application that the customer is building, they will look for better, easier alternatives. Instead, offer a strong and smart API that solves the problems your customers face, they will be loyal customers for it. Always keep in mind a complete picture of what your customers will be trying to build and where your API fits into that picture. The more problems you solve for your customer, the more liked and preferred your API will be.
The third important thing not to do is to create APIs that are way too chatty and involve too many calls. Multiple network calls will slow down the whole process and create higher connection overheads. This translates to significantly higher operational costs, which is not something anybody wants. So, the key here is to simplify things as much as possible.
One useful tip we can offer here is that as far as possible, try not to make your customers choose between data-driven microservices and streamlining API usage. We say this because when you offer these together, you deliver two APIs a fine-grained API fine-tuned to work with specific data types and a more experiential API that powers excellent user experiences. The latter would be capable of composing multiple smaller domains into a single endpoint, which would in turn make it easier for customers who are building the user interfaces to design the user experience for the end customers, they can easily and quickly render their screens.
The fourth mistake to avoid, and this one’s extremely important – leaving no scope for flexibility. No matter how hard you worked to include solutions for as many use cases you encountered, chances are, there will also be some edge cases that you will not be able to help. Situations change, new scenarios arise, and then there are always so many possibilities. What do you do then? You can’t write a whole separate API for the edge cases or for every new case that arises after all! So, you leave room for flexibility. Your API cannot be a one-size-fits-all solution, instead, it should focus on the large majority of use cases and then leave the endpoints more flexible so that even if there is a user can still use it for their specific use case.
The last and fifth very important mistake to avoid is making a design that is unreadable to humans. Always believe in keeping things simple, not just for machines and code, but also for humans. Of course, we do know that APIs are intended for computer-to-computer interaction only, but it is still humans who are using them to build their applications. Developers who are considering using your API will go through your design and payloads before they decide to use the API. If your payloads are going to be extremely complex and the developers and decision-makers cannot understand it, they will lean towards choosing an API that is simpler and easier to understand for everyone. This could cost you some extra bytes in the API size, but it will make things so much easier and less confusing for the most important stakeholders – your customers.
We strongly recommend avoiding these top five mistakes when designing RESTful APIs. RESTful APIs, needless to say, are immensely useful and quite a revolution in themselves. There are many comprehensive guides you will find that will tell you more about what to do and what not to do when building RESTful APIs. But here’s one very simple thumb rule that will sum up everything, even this entire podcast episode – always think backward, get into the shoes of your customers and look at things from their side of the table, not just yours, and then offer them exactly or something as close to as possible to what they would be looking for. So far as you keep doing that with your APIs, they will always be in demand. Make a customer’s life difficult or challenging, and they will swiftly find another API to help them instead.
We hope this helps you understand what we are trying to say about what you must and must not do when designing RESTful APIs.
With that, we come to the end of this week’s episode. If you would like to learn more about RESTful APIs, while sharpening and validating your skills, we would recommend signing up for our live online instructor-led DevOps Plus training and certification course. You can check out our website – www.cognixia.com to see our entire list of course offerings. Also, do reach out to us to get more information not just about our courses but also for know about the amazing promotions and discounts we run from time to time on our courses.
We promise to come back next week with another super interesting and insightful episode of the Cognixia podcast. Thank you for listening to us. Until next week then.