What Do Developers Need to Know About Microservices?

DZone 's Guide to

What Do Developers Need to Know About Microservices?

When getting started with microservices development, you should be sure to start with the twelve-factor application methodology.

· DevOps Zone ·
Free Resource

To gather insights on the state of microservices today, we spoke with 19 executives who are familiar with the current state of microservices architecture. We asked them, "What do developers need to keep in mind when working on microservices?" The answers were wide-ranging. Here's what they told us:

Twelve-Factor Application Methodology

  • This is a question that the twelve-factor application methodology answers succinctly. There are at least a dozen different things to keep in mind, and developers would do themselves a huge service to use the twelve factors as guidance in their implementation. The thirteenth factor most commonly overlooked is a full and rich set of sample data. This data should include ‘bad’ or erroneous data to the fullest possible extent, especially in services that consume data from external sources. Having a good stable of quality data enhances testing, helps developers find ‘gotcha’ issues in their code, and contributes greatly to the all-around stability of the service as a whole. 
  • Learn automation, logging, and tracing. Transaction IDs will thread through your logs. Have proper preambles, time stamps, execution context from microservice to microservice always in the thread of local context.


  • Define programming models with APIs and annotations.
  • APIs are critical. Think API first in a systematic way. Be able to take advantage of extensibility, scalability. When working with microservices, think about how to build security into the process.


  • Have security thinking in place. APIs use restful web services. Have a common contract language. Have API thinking in place. Have a cultural mindset to be more collaborative. Always have a process in place. Identify the right architecture for everything. Work together for the end customer.
  • A Strong strategy for identity and security layer. Get the core pieces right.

Keep It Micro

  • Keep it micro. Focus on how it manifests to the user. Think about security from the beginning. 
  • Keep the micro in microservices -- making sure their essence actually stays small and manageable.


  • Many junior developers see microservices as a magic bullet and talk as if it will solve all their problems. Well, it also introduces a fair amount of problems of integrating with persistent storage. The temptation in the tech industry is to treat technological improvements as a cure-all. I saw the same thing a decade ago when "cloud computing" was all the buzz only to find out that it usually swaps out intermittent failure problems with latency and noisy-neighbor headaches. There's always a tradeoff. Containers aren't the best design decision in every use-case.
  • Never stop learning. The velocity of change you see today is as slow as it will ever be. Test drive new languages, try new containerization technologies, and acquire a fluent understanding of the practical design challenges facing new architectural implementations today. Those challenge areas are where emergent solutions will appear, produced by industry or open source development. That’s the ball to keep your eye on. Whether it’s orchestration, secure containerization, remote configuration management, process mining, or something completely new, you must never look at a new concept and believe it to be off-limits to your ongoing education.
  • You shall use standard or self-explanatory names for message properties. You shall use known libraries. You shall do one thing and do it well. And, please, check for null values. Jump in using JSON and keep looking for opportunities to use.
  • Go beyond the boundaries of thinking of applications as a single system. Understand distributed computing. Let microservices dictate the data model – everything won’t be relational, there will be geospatial, unstructured, and classical translations. Understand the spectrum of data management. Domain-driven design. Eliminate the risks and pain points.
  • Know Kubernetes and the complexities. Pods, the relationship between pods and clusters.  Understand how to think outside the technology when building technology. This also makes it easier to learn new technologies. Learn new languages more quickly. Understand the business problem and how you can use technology to solve it. Be skeptical of something getting in the way – this is supposed to be easier. Do recognize the need to be a good citizen as you are part of a large, complex organization.
  • Without a solid underlying communications architecture, the distributed nature of the system is complex - more complex than a traditional monolithic architecture.
  • Don’t get locked into a single solution. Being too big can slow you down. Being too small can result in unnecessary interdependencies. Don’t get hung up on size. Be willing to split or combine. Be prepared to refactor as needed. Have a strategy for converting monolithic applications to microservices. Look at what others have done. There’s no need to create a completely new methodology.
  • When working on microservices, developers must be simple and discrete. A service should not be complicated. It should solve one singular problem. It should be as simple as: Give me seven data points and I will give you a score. Nothing more.
  • There are a lot of libraries out there for developers to reference. Use small single libraries. Retry connections. Own your own data. Data should reside where the business resides. Build in circuit breakers. Monitoring. Take a look at Go Standard, HTTP routing, and circuit breaker libraries right off the shelf.
  • Better understand CD and its components. Automated testing, collaborative development, continuous testing, lightweight interface design. Change the approach to databases and database design. Think about how to manage the synchronization of data.

What do you think developers need to know about microservices?

Here’s who we spoke to:

  • Thomas Butt, CTO, CardCash
  • Matt McLarty, Vice President, API Academy, CA Technologies
  • Brian Dawson, DevOps Evangelist, CloudBees
  • Lucas Vogel, Founder, Endpoint Systems
  • Ali Hodroj, V.P. Products and Strategy, GigaSpaces
  • Job van der Voort, VP Product, GitLab
  • Kevin Sutter, MicroProfile and Java EE Architect, IBM
  • Sandeep Singh Kohli, Director of Marketing, MuleSoft
  • Karl McGuinness, Senior Director of Identity, Okta
  • Ross Smith, Chief Architect, PITSS America
  • Mike LaFleur, Director of Solution Architecture, Provenir
  • Gianni Fiore, CTO, Rebrandly
  • Peter Yared, CTO, Sapho
  • Sha Ma, V.P. Software Engineering, SendGrid
  • Keshav Vasudevan, Product Marketing Manager, Swagger/SwaggerHub, SmartBear
  • Chris McFadden, V.P. Engineering and Operations, SparkPost
  • Christian Beedgen, Co-founder and CTO, Sumo Logic
  • Todd Millecam, CEO, SWYM Systems, Inc.
  • Tim Jarret, Senior Director of Product Marketing, Veracode
career development, devops, microservices

Opinions expressed by DZone contributors are their own.

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}