Micro Frontends

Microservices  is an architectural style that structures an application as a collection of services that are

  • Highly maintainable and testable
  • Loosely coupled
  • Independently deployable
  • Organized around business capabilities
  • Owned by a small team

The microservice architecture enables the rapid, frequent and reliable delivery of large, complex applications.

It also enables an organization to evolve its technology stack.

Micro Frontends

Every software development team in the world relies majorly on web application development to develop, deploy, and market their products to many people. This makes good web development important for many teams.

Many software companies put more focus on web architecture and a recent trend  “Micro Frontends is gaining more attention.

In recent years, microservices allowed backend architectures to scale through loosely coupled codebases, each responsible for its own business logic.

Each microservice exposes an API, is independently deployable, and is owned and maintained by a different team.

This paradigm provides great advantages to help accelerate, scale, and make the development process more efficient. The idea of micro frontends is to bring the same advantages into the modern web development workflow.

It means breaking down large monolithic projects into smaller, more manageable pieces, which are independently developed and owned by different teams, with the power to independently build and ship products simultaneously.


Micro Frontend architecture

There are many advantages of micro front ends

  1. Decouple codebases, making each feature much easier to develop, test, maintain, and upgrade. We especially wanted to make it very easy to fix, replace, or add any feature or technology in our applications, so that we can constantly keep releasing new features to our customers.

  2. Independent teams that can autonomously build and release features to production, without having to wait or step on the toes of other teams, and without breaking stuff they shouldn’t break in a way that blocks the work of other teams. This means a decoupled release pipeline for each team, so that there’s no more fighting over master branch or waiting for versions releases while they bloat.

  3. Rapid, incremental upgrades so that each team can constantly deliver new features, upgrades, fixes and rollbacks to their products used throughout our applications, without breaking functionality or user-experience at all.

  4. Quick, safe integrations so that every team will expose its features and functionalities and make them available to other teams to easily discover and integrate into their existing applications without refactoring entire applications.

  5. Achieve 100% component reuse to speed development times, ensure design consistency, and improve the quality of our software applications. We wanted to make it easy for all developers to quickly share components with each other, while being able to efficiently regulate and standardize the process.

  6. Standardize development so that despite their independence, all teams will develop, build, test, and release components in a standardized way using the same development environments and through standard build pipelines.