Services are a thing for a long time in the backend. +20 years I would say. Microservices are much newer however they also started the backend. Micro Frontends is a very hot topic in frontend engineering right now. Frontend engineering evolved a lot in the last 5 years. Ui are becoming more and more complex and frontend teams are growing a lot. With complexity and growth, we stumble into classical backend problems such as Teams Organization and Scalability and the need for Isolation as a base for Independence and increase the number of deploys. Frontend technology evolves much faster than backend. With all that comes debit and believe me or not the difficult to find people to work on old tech like AngularJS.
Micro Frontends Benefits
One benefit from Micro Frontends is Developer Experience. IMHO That’s the weakest argument and DX should not be the main reason to do anything in tech. IMHO the real benefits are:
* Improve Teams Topologies — Reduce the comunication blast radius
* Reduce management Overhead (by reducing coordination)
* Faster Build times by smaller and focused components
* Technology Diversity (Being able to work with different frameworks)
The frontend is getting bigger and complex as time pass. We cannot ignore this issue. Technical debt is a big problem at the backend and is becoming a real issue in frontend as frameworks evolve faster and believe me or not is hard to find AngularJS engineers. Micro frontends address a real issue in a sense of scalability and the need to introduce better and newer technology as big companies have issues in refactoring huge code bases. However like any solution, there are drawbacks and issues, so let’s take a look into some micro-frontends issues.
Micro Frontends issues
There are lots of challenges and potential issues with micro frontends such as:
* Operational Complexity — Deploys are more complex
* Performance — Might affect the user experience (slower load time)
* UX/UI Consistency — Need to implement DS for all different frameworks
* Tooling / Framework support — IMHO it will be fixed but is a huge issue right now
The idea of Micro Frontends is to have independent teams. This can ship things faster, some teams might be faster than others, and in order to do that, you need a different code base and different deployment pipeline. Performance might be a problem since you might load different frameworks and different versions even I would say(you want to avoid this actually).
Design Systems often are implemented at the component level, so if you have components in one language like Angular and another team want to use React they might need to re-implement the components which might be a big no go for enterprises trying to adopt micro frontends.
If you can make the Design System implementation more CSS driven rather than framework driven you can minimize this impact, however is very hard to fix completely. A Design system requires the exact same behavior and duplicating to N technologies(Vue, Angular, React, JQueryy/VanillaJS) is expensive since you have fonts, pixels, error, and lots of small details. It’s possible but still hard.
Tooling is a big issue, there is no problem tooling around. There are some solutions with better tooling but often that means by double down into a specific framework. I believe the tooling problem will be fixed eventually. Zalando has an interesting solution called Mosaic. There is also OC. However, the stand way to go looks like to be around Web Components. It’s also possible to do something reasonable with AWS and Simple Infrastructure.
One big difference from the backend to the frontend and mobile is that in backend we can run the software on different servers so isolation is totally possible. Frontend/mobile has a common issue wihc would be the phone or the browser. It’s possible to use shell-like methods like iFrames, Web-Components, or rely on specific frameworks solutions but at the end of the day, the code runs into the same place, which is the browser. It’s possible to load different frameworks and solutions but there are performance and complexity penalties. Lots of companies have already frontends monoliths and one common approach people do is to use the monolith as a shell and they have links to the micro frontends apps.
It’s about granularity or Modularization?
IMHO we don’t want to make the components that micro. One hard lesson we learn at the backend is that things too micro also have lots of issues. IMHO what really matters is the ISOLATION and modularization. So you definitely want to have a modular JS application but not necessarily everything needs to be at the micro-level. Micro not always is the right level of abstraction and that is one of the things who killed microservices.
There is a huge difference in a Brownfield and Greenfield project and a shared old monolith application. IMHO React is the best web framework we have it right now, if you have a new project and create proper components I would say you dont need micro-frontends. However, looking to a more complex enterprise where you have all sorts of solutions I would say you definitely need to have some solution for modularization.
Having a micro frontend solution imply you to have some solution for the following concerns:
* SSR (Server Side Rendering) VS CSR (Client Side Rendering)
* Layout assembling or linking
It’s ideal to have the tooling and good solutions around those concerns. It’s possible to do Micro Fronentds without tooling for the concerns I mention however keep in mind it might be less productive, more complex, and much harder to test than good old monolith frontend apps. IMHO Micro frontends might be making the same mistakes as Microservices by focusing on the “micro”. What matters is some level of isolation(given the browser reality) and modularization.
Originally published at http://diego-pacheco.blogspot.com on September 13, 2020.