Rawpixel - Fotolia


A few fundamental microservices team structure strategies

A microservices architecture can be quite a culture shock to unprepared enterprises. Here's how you can prepare your team to make microservices part of development processes.

More enterprises are adopting a microservices architecture because of its agility, performance and scalability. However, microservices is not only about technology and architecture -- it's also about the structure of your development team.

Balancing the mood, morale and overall culture of the team is important for the success of microservices architecture. Changes that alter important work processes will alter team structure, as well. An organization must align its architectural style with its overall business structure.

Below are some ideal microservice team structures and best practices for building a team culture.

Three team structure tactics

1. Conway's Law

One organizational approach to follow is Conway's Law, which dictates that the structural design of an organization's software architecture should reflect that organization's development team structure. In theory, if a team is comprised of a front-end team, a back-end team and an ops team, it will struggle to manage deliverables since those teams are isolated.

For organizations dealing with microservices, the team structure should resemble the inverse. Create vertical teams where each team is adept at handling the UI, API, business logic and data access layers. As a note, the API layer will define contracts that facilitate communication between different vertical teams.

2. Build-and-run team

Organize your teams for single, independent responsibility from end to end. For example, the build-and-run team should be responsible for the entire lifecycle of their assigned piece of software from development to testing to deployment. These teams should be able to function as independently and effectively as the microservices-based application they're working on.

3. Decentralized structure

Additionally, consider a more decentralized team structure. In a monolithic delivery setup, software development teams often separate into silos with no overlap of team members between them. This results in frequent handoffs of work between team members, which can cause delays. Even more so, these types of processes are inefficient and don't follow strict Agile principles. Instead, replace these silos with microservices teams that follow a decentralized, yet un-siloed, approach.

Build a successful microservices team culture

To successfully run and manage microservices, organizations need to instill the proper team culture. There should be mutual trust between the members of a team and the organization they work for. Both business- and software-side leaders should work closely with development team staff and come up with a plan that empowers everyone. This will help make your team members feel motivated and trusted.

Organizations should also give those development teams the freedom to make technological recommendations. Then, the software architect or similarly positioned leader should make the final technology or tooling decision after diligently weighing the options provided by team members.

Companies like Netflix, eBay, Amazon, Twitter and PayPal have all benefited from microservices architecture and adjusted their teams to mirror that structure. To deliver value faster to their customers and hit the market early, organizations should work to establish a proper microservices engineering culture, as well as teams that are motivated and properly structured. By implementing a proper microservices team structure, leaders can organize teams in a way that helps the enterprise achieve its business and development goals with ease.

Dig Deeper on Application development and design

Software Quality
Cloud Computing