Microservices Consulting

A Microservices architecture addresses problems that modern enterprises often face. It has been used successfully in software that supports millions of users, like Netflix, Amazon, Twitter, Uber, and Paypal.

Experienced Implementers

Microservices experts with multiple projects in-flight.

Analysis & Roadmap

Analyzing your applications & creating a strategic path for Microservices migration.

DevOps Platform

Providing the necessary automation required for Microservices success.

Microservices Education

Helping you understand approaches, constructs, and potential pitfalls.

Learn About Microservices

The Microservices approach is a huge shift for the enterprise, essentially “breaking down” monolithic application into small, modular pieces that have the freedom to act independently. Compare the difference in the two following approaches:

Monolithic Application Architecture

All application functionality is placed in a single deployable unit or executable. You are unable to horizontally scale specific, individual components without scaling the entire application.

Microservices Application Architecture

Functionally decomposed into a suite of microservices that handle only a single responsibility. Each service is configured to run as a unique process and can be changed independently.

A Microservices approach addresses specific issues that are inherent in monolithic applications, like deployment, upgrading, failover, health checks/monitoring, discovery, and state management.

Example Microservices Implementations

The Microservices approach originally evolved from web companies that needed to be able to handle millions of users with significant variance in traffic, while being able to also maintain the agility to respond to market demands.

What those companies pioneered—technologies, design patterns, and operational platforms—have been shared with the open source community in an effort to help other organizations to adopt Microservices.

Established patterns and constructs need to be understood before embracing Microservices. Examples include the Service Registry, API Gateway, Edge Controller, Circuit Breaker, Fallback Method / Chain Of Responsibility Pattern, Command Pattern, Bounded Context Pattern, and Failure as a Use Case, among others.

Microservices can add complexity with more moving parts. The most important (and, arguably, most difficult) part of Microservices adoption is the automation required to move all of these numerous moving parts in and out of environments. DevOps automation is key.

The decoupled, discoverable, and isolated nature of the Microservices architecture style supports a continuous deployment environment that allows microservices to be deployed at will. However, just having the ability to obtain infrastructure in an on-demand manner is not enough.

An automated platform that supports the numerous moving parts of a Microservice architecture is required. This includes as much automation as possible, to include continuous deployment, integration, delivery, and monitoring.

There will be many more moving parts in a Microservices architecture. All services must be immutable — easily deployed, started, stopped, and discovered. This is why containerization is so important.

Containerization allows an application and the environment it runs in to be moved as a single immutable unit. These containers can be managed individually, scaled as needed, and deployed in the same fashion as compiled source code. Containers have been key to attaining agility, quality, scalability, and durability.

As an example, Docker is open source software that allows you to build, run, test, and deploy distributed software containers. A Docker image can contain everything that software needs to run: code, runtime, system tools, system libraries, etc. A Docker image enables you to quickly, reliably, and consistently deploy applications regardless of environment.

Microservices architecture breaks up application function into smaller independent units that are accessed and discovered at runtime, whether over HTTP or a IP/Socket protocol using RESTful APIs.

Services should have a small granularity and the protocols should be lightweight. This creates a smaller surface area of change, making it easier to add functions and features to the system at any time. As a result of this smaller surface area, instead of having to redeploy entire applications as you might have with a monolithic application, you might only need to deploy one or more distinct services.

Organizations can exploit on-premise or off-premise infrastructure-as-a-service (IaaS) solutions. Computing resources like servers, data sources, and storage to be acquired in an on-demand manner. Three excellent solutions include:

Kubernetes by Google, is an open source container management platform for managing containerized applications across multiple hosts. It provides basic mechanisms for deployment, maintenance, and scaling of applications. Additionally, it enables scheduling, upgrades on-the-fly, auto-scaling, and constant health monitoring.

OpenShift, by Redhat, is a Platform-as-a-Service container application platform that allows developers to quickly develop, host, and scale applications in a cloud environment. It natively integrates technologies, like Docker and Kubernetes, and combines them with an enterprise foundation in Red Hat Enterprise Linux.

Service Fabric, by Microsoft, is a distributed systems platform that makes it easy to package, deploy, and manage scalable and reliable microservices. In addition to containerization, you get the added benefit of having Microservices best practices built in. Service Fabric is not limited to Azure or Windows, as you can run Service Fabric on Linux, in your local data center, or on AWS.

Microservices Learning Tools

Adoption By Development Communities

Keyhole Software consultants have extensive experience in the transition to Microservices from both the Java and .NET perspective.


Open source Java Microservices support is rampant due to companies such as Netflix, Groupon, & PayPal that have pioneered design patterns and produced various support frameworks that help to manage and implement a Microservices architecture style.


The .NET community did not have the same kind of tooling and innovation as Java in the beginning. It took nearly three years after the release of Docker for Microsoft to get on the train. But since that time, it has been coming along very nicely, specifically in regards to Azure Service Fabric.

Recent Microservices Blogs

Microservices: Patterns for Enterprise Agility and Scalability

Introduction to the Microservices architecture style, concepts, recommended patterns, and suggested adoption.

Keyhole Can Help

We have helped clients of all sizes to leverage Microservices benefits. We work with clients in a number of capacities, from analysis and strategic planners, to implementers and educators.

Microservices Consulting

Modernization Consulting – Keyhole Consultants provided to help your team meet its goals with Microservices adoption, including the rewrite of applications to a Microservices style of architecture.

Microservices In Three Steps – A three-step approach to integrating Microservices in the enterprise.

Microservices Assessment – A package to assess your software systems and provide a strategic roadmap for adoption to help your team to avoid implementation pitfalls.

Technology Agnostic

We at Keyhole pride ourself on being technology agnostic, choosing the best tools for the application. We have extensive experience with OpenShift, Azure Service Fabric, Docker, Kubernetes, Spring Boot, and other tools and can help you determine the best options for your unique application requirements.

Recent Microservices Projects

Contact Keyhole Software

About Keyhole

Keyhole Software is a software development and consulting firm. We help clients of all sizes across the United States with teams located in Kansas City, St. Louis, and Lincoln, NE.

Quick Links