Micro Frontends is a software architecture that reduces program complexity and allows frontend users a friendlier interface by dividing a vertical program monolith and large teams into smaller teams that individually manage only one horizontal section of the entire program.
In the beginning, as the popularity of computers grew, consumer demands on computers also grew. Consumers asked computers to do more and more once they realized how much these marvelous machines could simplify their lives. Soon, the programs required to meet consumers’ needs grew to such proportions that they became unmanageable. Micro Frontends is the solution to the problem of that unmanageability.
Modern software engineers might not realize it, but Micro Frontends is a fantastic solution conceptualized twenty-two centuries ago, long before John Blankenbaker was even a gleam in his daddy’s eyes. Gaul was to Julius Cesar, then, what monolithic programs are to software engineers, now. The answer then, and the answer now, is divide et impera (Latin for “divide and conquer).
Think of a software program in the same way you think about the simple organization of a retail business. The consumer walks into a store, and they see the front end. It looks like it’s where all the business is happening. Of course, that isn’t everything to the store. There is a back end to the business, and the activity there makes the front end possible.
The frontend of a software program is where users interface with the program. For example, they type a word they need to define on a screen with a keyboard, hit “enter,” and read the definition that appears on the screen. The program’s backend is where everything happens after the “enter” key. The request is translated into binary language. Databases are searched. The requested information is discovered, translated from binary, and displayed.
There’s no rocket science here. Micro is a recombining form which means to make smaller. So, we have a processor and a frontend, and then we have smaller versions, the microprocessor and the micro frontend.
Frontends used to go on forever and ever when the Information Age was young. Sometimes the length, complexity, and rigidity of a program counterbalanced the speed of using a computer to achieve program goals if you were a user. The number of moving parts could be so immense that most developers threw their hands up in surrender when problems occurred.
Deployments were not always the welcome updates we see today. A small change here or there would force other changes in other parts of the program, which were unwanted and unexpected, often forcing the rollback of deployments to earlier versions.
The size of the team required to maintain such monoliths was equally monolithic. The “two pizza rule” was nothing more than a laughable idea back then.
Remember our retail store. Make it big. Big, like Walmart on steroids. Imagine 100 supervisors, and each individual is responsible for knowing and managing everything. They will step on each other’s toes and go home hating each other at the end of the day. That is what happens with a software monolith. It is one big headache.
Micro Frontends divide and conquer. They break the monolith up into parts, like the Bakery, Deli, Meat, Produce, Frozen Foods, Dairy, and Canned Goods sections in a store. The butcher, the baker, and the candlestick maker are entirely separate entities.
These parts can get bigger, reduce their size, alter policies, even change their hours without changing anything for the other sections. Also, the teams that maintain them are smaller. Twenty teams of five end up doing more work in a shorter time due to better efficiency and increased communication.
You have tabs or buttons that take you where you want to go in the program on the computer. Instead of an incessant search for what you need, you go to the labels, tabs, or buttons that represent what you need, similar to visiting departments in a store.
User interface and navigation is not the only facet improved with Micro Frontends. Development is enhanced. All the parts of a program that existed in a vertical structure are broken up and implemented in a horizontal layout. Each piece can interact with other components, but it is also independent.
The horizontal system is not bound by any rules that define other horizontal parts in the program. Each frame can use a different program language or have its own security settings. The team works together on the program. Smaller teams working with their piece of the pie are a Micro Frontend’s significant asset. There are no more sore toes, banged-up elbows, and hurt feelings.
Each team can fix problems and develop better functionalities quickly and easily by working in their smaller area. There is no more worry about how fixes or refactoring the frontend section will affect other teams or the program as a whole. They can focus on the task at hand.
Micro Frontends solve the problem of vertical structure complexity and unmanageability by dividing the vertical structure into smaller pieces and arraying them in a horizontal structure with a central access, providing an increased user-friendly interface and potential for development and growth.