My dear reader, how are you? السلام عليكم

We keep moving forward, opening new doors, and doing new things, because we’re curious and curiosity keeps leading us down new paths – Walt Disney

We are inching close to the end of our basic understanding of software architectural patterns. This is part two for software architectural patterns. In the first one, we discussed N-tier and microservices architectural patterns in detail. Here we will continue the discussion with microkernels architectural patterns.

Just started exploring? Want to start from the very beginning? Follow the tutorial series in the following sequence:

  1. How a Web Application Works: From Beginning to Boundaries (DirectMe)
  2. Web Services: A dive into yesterday and shaping today (DirectMe)
  3. Software Architecture: An Abstract Introduction (DirectMe)
  4. Software Architectural Patterns: N-Tier Layered and Microservices (DirectMe)

Kernel means the nucleus or the core part of a system. In computer science, a term kernel first appeared in the context of an operating system. There are two major categories of kernels, 1) microkernel and 2) monolithic kernel.  A microkernel (often abbreviated as μ-kernel) is the near-minimum amount of software that can provide the mechanisms needed to implement an operating system (OS) [1]. In a microkernel, the core is small and more efficient and the kernel is kept to a minimum. In a monolithic kernel, the core of the OS is bigger in size and hence less flexible. In a microkernel, we have the flexibility to choose which services to choose/add in a system and which should not be included. This approach has been extended from the context of operating systems and became a popular architectural pattern that can be used to build software applications. The main advantage of this microkernel architectural pattern is to be able to add custom services and functionalities without affecting the core system. This also helps to avoid an issue in a monolithic architecture, which is that when a particular service fails the whole system crashes.

The Microkernel architectural pattern applies to software systems that must be able to adapt to changing system requirements. It separates a minimal functional core from extended functionality and customer-specific parts. The microkernel also serves as a socket for plugging in these extensions and coordinating their collaboration. In other words, “the microkernel architecture pattern (sometimes referred to as the plug-in architecture pattern) is a natural pattern for implementing product-based applications. A product-based application is one that is packaged and made available for download in versions as a typical third-party product” [2].

The simple anatomy of this architectural pattern is given below in Figure 1.

Image result for microkernel architecture pattern

Fig 1: Simple Anatomy of the Microkernel Pattern.

If we go a little deeper, then we can divide this architectural pattern into five major components, 1) Core/microkernel, 2) internal servers, 3) external servers, 4) clients and 5) adapters. They are shown in Figure 2.

Image result for microkernel architecture pattern components

Fig 2: Breakdown of microkernel architectural pattern into components

I direct you from here to a video for deeper understandings of these components DirectMe.

This architectural pattern is preferred in systems in which software must match up with continuous evolution, and must exist for a long period with a need to accept standards and integrate within the existing systems. And in a software product line, where you have a number of variants of a software product sharing a common nucleus. If we analyze this pattern in terms of agility, scalability and so, it would go as follows [2]:

Agility – Rating: High Over All

Agility is the ability to respond quickly to a constantly changing environment. Changes can largely be isolated and implemented quickly through loosely coupled plug-in modules.
Ease of deployment – Rating: High
Based on the architecture, the plug-in modules can be added on the go.
Testability – Rating: High
Plug-in modules can be tested in individual sandboxes.
Performance – Rating: High
You can customize and streamline applications to only include those features you need.
Scalability – Rating: Low
Because most microkernel architecture implementations are product based and are generally smaller in size, they are implemented as single units and hence not highly scalable. Individual plug-ins can be scaled up depending on the architecture.
Ease of development – Rating: Low
Requires thoughtful design and contract governance, making it rather complex to implement.
Portability – Rating: High
Want to go further from here and learn the architectural patterns for software? I suggest the following book to clear the concepts DirectMe. Happy Learning!


[1] Microkernel. Source: accessed on March 24, 2019.

[2] Microkernel Architecture. Source:


Please enter your comment!
Please enter your name here