When a client decides to move from a monolith platform to microservice architecture, there’s both risk and reward. Microservices offer a range of possible benefits to our clients, but teams who have traditionally developed in monolith architecture may find the shift difficult—often knowing that there may be gaps in their approach, but not being entirely sure where those gaps are.
WillowTree supports our clients through the process of moving from monolith to microservices in a variety of ways — from fully designing and developing technical architecture to consulting on best practices that set a team up for growth and success.
Like any solution, microservices is not a silver bullet, so it’s important to look at your specific team, application, and business model in order to determine if implementing microservices is the right path.
Why use microservices?
- You can support many autonomous, small teams with strong module boundaries.
- Independent deployment reduces likelihood of system failures.
- You can enable multiple languages and development frameworks.
- You can increase the speed of maintenance and testing.
Why NOT use microservices?
- For each additional service you create, you also need: an additional backlog to refine and plan for, an additional release process, and more points of failure (you’ve now put a queue or HTTP in between two processes, thats an entire category of possible failures)
- It’s more difficult to share code (need to use a monorepo or have an artifact repository)
- By moving from a monolith team to multiple microservices teams, communication and requests for adding data has to flow between the teams, which could incur coordination costs
- Documentation will be necessary to avoid constant synchronous communication
You don’t know what you don’t know.
Our clients often come to us in the process of implementing microservices, sometimes with code already in production. For teams experienced in monolith architecture, developing in microservices requires a drastic shift of mindset and a willingness to adapt to suit the new system.
In other words, teams may have growing pains in the short term that yield benefits in the long term.
One striking way in which we’ve supported teams as they learned to manage the increased operational complexity of microservices is through both manual and automated testing. In partnership with one of our eCommerce clients, we’ve helped their QA team build an exhaustive list of end-to-end test scenarios, and transition testing from manual to automated.
Test for success
Robust testing plans are crucial to the success of microservices. As microservices provide frequently deployed independent services by different teams, interactions must be documented and verified via automated testing. At WillowTree, our Test Engineers work closely with the team who owns testing to develop testing plans and decide what kinds of tests to use whenever code is being designed or changed.
UI testing Automated end to end testing is an automation of manual “click-through” tests. While manual testing is incredibly useful for promoting learning during discovery and investigation of the system, repeatedly executed tests should be automated whenever possible to maximize efficiency.
Contract testing Teams will want to define contracts for their microservices that communicate agreements for what interactions and data will be exchanged with other services. Contract testing provides a means to allow these contracts to be tested to ensure that when changes are made that the contracts are upheld.
Service testing Integration/service tests can be one of the most useful, important types of tests a team creates. Although these tests take many forms, test harnesses may offer particular value by affording engineers a customized API that allows them to write succinct, deduplicated, and easy to read tests against a single microservice.
Unit testing Unit testing can help drive the design of each function and data structure as well as verify logic at a very granular level.
Microservices with macro results
When approached properly and with expertise, microservices offer clients the invaluable opportunity to modernize and scale to meet the demands of business. Implemented properly, microservices can:
- Create simplicity: Reduce overall complexity of managing, upgrading, and debugging a monolith application.
- Enable high performance: By building microservice architecture, each service can be scaled to meet any demand.
- Improve stability: Microservice architecture helps to improve stability due to the nature of focused, simplistic services that do one thing and do it well.
Let WillowTree help your team upgrade its operating system
Building a microservices based architecture is a team sport, and we’d much rather build with your team than for your team. Why?
- To build your team’s capacity. Digital is already core to every business, and we want to help build that capacity into the organizations we serve.
- To always be engaged and collaborating with your team. We know that by building together we’ll be able to build a better product.
- To equip your team to handle long term support for a microservice architecture.
Building microservices requires growth and change for a team—something much easier when you have a trusted expert able to offer feedback, coaching, and support. Our teams at WillowTree are built for these challenges and we’re equipped with people who understand how software teams learn, build, and grow. Get in touch today to take next steps!