In the first part, we explored third-party integration with mature services. In this article, we’ll take a look at something a little more challenging — how to deal with services still under development.
Integration with services under development
There are a number of reasons why integrating with third-parties still under development is more challenging; you may, for example, need to help them on design and development, provide support with continuous integration and release, or even get involved with planning.
Design phase
Clarifying responsibilities
Setting clear responsibilities for the third party team should be the first priority to avoid problems down the line.
Integration solutions
To avoid rework and increase efficiency, it’s best to plan for integration during the design stage. There are three major aspects you need to consider: the communication trust mechanism, data exchange solutions and change management.
The communication trust mechanism between two systems includes authentication and authorization solutions between end users and the two systems. End users can use SSO to navigate from one system to the other. For exchanging data, you can choose a public-private key pair to bridge the two servers.
From the data view, which party holds the single source of truth for each resource should be made clear in the integration solution. Once resource ownership is clarified, you should verify the integrity of mandatory data on each integration point to make sure the design can be implemented.
In the design phase, managing changes is about agreeing on the principles and implementation of breaking changes. Breaking changes from third parties should be notified in advance while non-breaking changes should be handled painlessly in our system. More information about breaking changes can be found here.
The design phase might be long and painful, but it’s necessary to keep pushing forward and getting the necessary alignment with the third-party team since architecture will continually evolve. Without alignment we can easily go too far in the wrong direction. Retracing our steps could be time-consuming and costly.
Implementation Phase
You might still encounter problems during the implementation phase even if the design phase went perfectly. The expected functionality might not be ready as agreed and bugs might keep popping up.
If you do encounter issues, don’t panic! Here are some tips I learned from previous projects that might be helpful.
Timeline
At this point, you need to establish a timeline, and set up milestones for important functions. Even though we are Agile, embracing change doesn’t mean failing to plan.
Real-time communication
Having a real-time communication channel with the third-party team is essential to solving problems like data preparation, incomplete functions handling, and changing requirements. Cooperation is also paramount. Remaining flexible on minor issues will help make the integration work easier and more sustainable.
Advance planning
Advance planning is essential. For example, before go-live, it’s vital that we notify the third party team so they don’t make breaking changes and so they know it’s particularly important for them to keep their servers stable. On our side, advance regression to verify the functionality related to the third party system is also necessary, to avoid any nasty surprises.
Prepare for the unexpected
Planning for the unexpected should involve both our team and the third-party teams. But even when you think everything is ready, you might still encounter surprises; human error can never be totally avoided.
Once, on one particular project, the team found that third-party related functionalities that had been confirmed as working the previous day didn’t work on launch day. Fortunately, thanks to the log related services we’d implemented in the system, we were able to find and solve the problem quickly.
Besides helping us to identify the issues when they happen, more monitoring and alerting services help us before a big impact happens from unexpected situations.
Conclusion
With the explosion of third-party services, smooth integration is critical yet often challenging. It requires exceptional communication and coordination; we shouldn’t put it off out of a fear of complexity.
Disclaimer: The statements and opinions expressed in this article are those of the author(s) and do not necessarily reflect the positions of Thoughtworks.
