Perficient was a sponsor of today’s Virtual Summit with CA Technologies: Modernizing Application Architectures with Microservices and APIs. With a lot of great sessions dealing with the importance of APIs and microservices and the trends that brought them to popularity, the focus was on tangible ways to get started or accelerate existing programs.
Mike Amundsen, head of API Architecture for CA’s API Academy, led a session titled, From APIs to Microservices: Design and Build. He laid out an immediately actionable, practical approach to API implementation. I’ve recapped it below.
Three-phase API Implementation
The goals of Mike’s three-phased approach to API design and implementation are to reduce the cost and potential risk of creating an API. API development can take a lot of time, money, and resources, so following best practices can help reduce those costs throughout the process. The main way to mitigate these costs is by uncovering mistakes early on in API development and to keep uncovering them along the way. Early mistakes are less expensive to fix when they aren’t set in code. The phased approach follows three steps: sketching, prototyping, and building.
The sketching phase gives you a chance to create disposable experiments for the needs of your API. These are not fully formed ideas; they lack details and specifications. However, it’s an opportunity to explore. Tools like the Apiary Editor enable you to sketch APIs with a running example of that API. Once you have a rough idea, share it and gather feedback from peers and stakeholders. Test your idea. And once it’s served this purpose, throw your sketch away.
Takeaway: Sketch APIs are made to be discarded.
The prototyping phase fleshes out your best sketch, giving you testable examples for your API. Tools like Swagger Editor or RAML Editor can help you build out your prototype. It’s key to leverage service virtualization in this phase in order to test all of the tiny components of your API prototype without going through production.
Takeaway: Prototyped APIs are made to be tested.
The build phase takes you into production implementation where you actually develop the functionality of your API. However, building in production means a few things:
You must work out ALL the kinks.
You must support all use cases identified in the earlier phases.
You are writing actual code – but you can sometimes leverage tools like CA’s API Gateway to repurpose existing functionality like a SOAP service.
The build phase also requires exhaustive testing, detailed access control, style guides, etc. This phase is labor intensive and detailed.
Takeaway: Production APIs are made to last.
Here is Mike Amundsen’s approach to putting APIs into action within your organization. Check out the other great sessions that were part of CA’s Virtual Summit on APIs and microservices by registering here.