If you take a large, complex process, break it into components, give separate components to different software team, and then recognize teams for their completion of individual components, you run a risk that when you stick all the pieces together that it won’t work. So, if you are in a component-centric delivery teams, what can you do to help have the best chance of producing a working solution for your users? I’d like to share three tips for giving your team the best chance to build a working solution.

First, make sure that folks are vigilant for the functionality of the whole system. You might opt to have a separate team be the watchdogs for the system, but ideally it is everybody on the individual teams, too. Building a complete system requires a mindset for thinking about the whole, even when working on just a part of it. Without a mindset for the whole, it will be impossible to do anything to retrofit the quality into the work product.

Second, once folks are vigilant for the system as a whole, the next simplest thing to do is to make sure that each team is engaging with the teams that are “upstream” and “downstream” from them. Individual component teams should make sure that the adjacent component, those that you consume or the team(s) that consume the results of you work, work together as intended. Engage those teams to identify the points of interaction and define the behavior that each side expects. It is important to have a conversation that goes deeper than just what the structure of the data is going to be. Be sure to agree on what the data is going to mean, and what the anticipated behavior is going to be based on the data. Once you agree on what the structure is, and the behavior that will be driven from it, you can “mock” the interfaces, creating a dummy interface to work against until the actual system to interface with is in place.

The third bit I would like to share is to move toward an end-to-end suite of automated tests. Consider defining the tests that need to pass before you build the system. Then, you automate the tests, and components are only “done” when the tests for the whole process pass. The test-first approach forces the conversation about what should happen in the system, versus trying to catch all the things that do happen. This type of change will not happen overnight. It takes time and technical skill to put it in place. But, you have to start somewhere, and work toward a robust framework for components to be plugged into.

So, in summary, here are three important elements to have a complete quality picture for your product

1. Build awareness and a mindset in team members
2. Get teams to coordinate with the teams who build components that need to be interacted with
3. Begin working toward test-first automated suites

Being good agilists, it is unrealistic to think that all the behavior will be implemented at once. Agree on the general plan for iterating toward the complete solution. Over time, you will build up a more robust, higher performing, system of people and technology.