Microservices has the potential of significantly impacting the way in which developers create applications. It’s possible to create applications using microservices faster and more efficiently than other technologies that are currently available. The problem is that many people are suspicious of microservices because of all the technology claims to do. In addition, anytime you start moving things around in an organization, it means changing the status quo and people dislike change. Even so, microservices present a way to create great applications quickly, but first you must overcome the politics that prevent people from using it.
Considering the Need for Microservices
A problem with current development techniques is that the developer needs to work with a large number of design patterns in order to produce a quality result. The application development environment continues to become more complex with each passing year. Even with good development practices and the employment of the appropriate design patterns, today’s applications can become inefficient and difficult to maintain due to the ball of mud problem, where one task ends up taking on most of the processing needs or it becomes so huge that it starts to work outside its originally designed areas of expertise. Microservices avoids these problems by using just a few patterns and keeping the size of each task small.
However, microservices do far more than simply keep the project manageable. By using microservices, you can avoid making as many application design decisions up front. It’s entirely possible to be tasked with an application development project one Monday and have a working model the following Monday. The working model may consist of just a login and a main screen, but you have something to show people—a sign of progress. Thereafter, each Monday will show another update in the application development process. Even using agile techniques, you can’t obtain this result. It’s essential to remember that development speed wins every time in the marketplace, so creating an environment in which it’s possible to work quickly (and with few errors) is important.
There is also the issue of rolling out updates. Using current techniques, you need to lock down the system, roll out the new version, and hope that it works properly in the production environment. When working with microservices, you can roll out an update a little at a time by transferring traffic gradually to the new version of the microservice. As the new version takes more of the load, you can watch for potential problems and fix them before the user even notices. Consequently, updates don’t occur at strict time frames and users are unlikely to even notice that they’ve taken place.
Defining Organizational Goals
The goals of using microservices are to make an organization more efficient and to allow updates in a timely fashion. In addition, using microservices allows better application designs where a single piece of code doesn’t end up doing everything. Companies such as Nike, Netflix, and Twitter are using microservices to create better applications in far less time than would normally be possible. In order to achieve these goals, an organization must:
- Incorporate new disciplines into the development process.
- Obtain new tools to use when creating the applications.
- Change the team dynamics in order to make microservices workable.
These sorts of changes don’t occur overnight, so it’s important to set realistic milestones when adding microservices to your development cycle. It may very well be that you’ll continue to use older techniques for existing applications and employ microservices with new development—at least, at the outset.
It’s fine to say that there are all sorts of good reasons to adopt microservices as a strategy. You can spend a great deal of time demonstrating their superiority and even point out the need for these solutions in order to progress with organizational goals. In a perfect world, pointing these things out would be enough to convince anyone of the purity of your insights and they’d likely go along with you to some extent. Unfortunately, this is the real world and the real world is ruled by managers jealously guarding their fiefdoms. Siloed applications present a real threat to your organization. In fact, I’ve discussed this issue before in Breaking Down the Walls of the Siloed Application. The problem with microservices is that they represent a new way of accomplishing tasks that will threaten people’s stranglehold on a piece of the pie, which makes microservices a very hard sell indeed.
The push for using microservices comes from ambitious vice presidents who have authority to fund large programming projects. These people see how long it takes to create applications using older approaches and know that waiting that long in today’s environment simply won’t work. Using microservices provides an effective and quick method for creating applications that actually do everything they promise. The payback for the vice president is the potential for advancement or other perks. Once a vice president is able to deliver applications more quickly and with fewer problems, the organization as a whole gets behind using microservices as the preferred approach. The problem is getting those early successes and overcoming the inertia of the siloed application environment.
It’s important to understand that microservices won’t become a major contributor to application development in any organization quickly. You need to start small and build on your successes to overcome the inertia of monolithic application development in most organizations. Even if the organization is ready to start development today, you need to build the required expertise to make microservices successful. In order to overcome objections from the various individuals in an organization who currently control development of one or more monolithic applications, begin by building a small application that starts out as a microservices project. The success you have will provide a reason for others to believe in the ability of microservices to deliver on its promises.
Creating Workable Solutions
When considering a microservice ramp-up for your organization, it’s important to remember that you already have a considerable code base defined around existing technologies. In addition, using microservices involves fundamentally changing how an organization performs development. You can see how Microservices affects your development team here. Here are some other things to consider in order to create a workable solution.
- Create a few course-grained microservices for new application features to start.
- Keep the development team that is responsible for microservices development separate from the team that currently maintains the monolithic application.
- As development progresses with the initial microservices and you can see where changes need to be made, create finer-grained microservices to produce better results.
- Provide enough time for existing teams to discover how to use microservices and begin incorporating them into existing applications.
- Develop microservices that provide self-contained business features at the outset so that you don’t have to worry about interactions as much.
- Obtain the tools required to perform granular monitoring, log aggregation, application metrics, automated deployment, and status dashboards for data such as system status and log reporting.
- Slowly cross-train individuals so that the sharp divisions between skill sets diminishes.
- Break down the silos between various groups.
- Standardize service templates so that it’s possible to create microservices with a minimum of chatter between groups.
- Slide development from the existing monolithic application to one designed around microservices. However, don’t make an existing monolithic application your first project—start with an application that uses microservices from the outset.
- Prune older microservices from the system as you replace them with finer-grained and more functional replacements.
What Do You Think?
While implementing microservices presents certain political and cultural problems in an organization, it also holds the chance to create new opportunities in teams that earnestly want to build better software faster than ever. Coworkers not only build more scalable software in the process of properly implementing microservices, but also build more efficient group dynamics at the same time.
What challenges are you facing in your journey with microservices? We’d like to hear your stories, your experiments, and your opinions on the matter.