Motivations, Benefits, and Issues for Adopting Micro-Frontends: A Multivocal Literature Review

[Context] Micro-Frontends are increasing in popularity, being adopted by several large companies, such as DAZN, Ikea, Starbucks and may others. Micro-Frontends enable splitting of monolithic frontends into independent and smaller micro applications. However, many companies are still hesitant to adopt Micro-Frontends, due to the lack of knowledge concerning their benefits. Additionally, provided online documentation is often times perplexed and contradictory. [Objective] The goal of this work is to map the existing knowledge on Micro-Frontends, by understanding the motivations of companies when adopting such applications as well as possible benefits and issues. [Method] We conducted a Multivocal Literature Review, analyzing 42 sources , and classifying motivations, benefits and issues. [Results] The results show that existing architectural options to build web applications are cumbersome if the application and development team grows, and if multiple teams need to develop the same frontend application. The application of the Micro-Frontend, confirmed the expected benefits, and Micro-Frontends resulted to provide the same benefits as microservices on the back end side, combining the development team into a fully cross-functional development team that can scale processes when needed. However, Micro-Frontends also showed some issues, such as the increased payload size of the application, increased code duplication and coupling between teams, and monitoring complexity. [Conclusions] Micro-Frontends allow companies to scale development according to business needs in the same way microservices do with the back end side. In addition, ...


Introduction
Developing the presentation layer of a modern web application has become a major and crucial task for industrial companies. Development teams are constantly looking for new ways to develop, deploy, and maintain applications in an effective manner so companies can quickly and effectively deliver value for their customers.
New front-end frameworks are continuously introduced into the market and developers have many valid options to build powerful feature-rich web applications such as single-page application (SPA), server-side rendering application (SSR), or static HTML files combined to a web page. However, most of them end up being monolith front-ends. Hence, the client-side of the application grows, and its development becomes hard to scale, especially if different teams need to edit the same front-end application simultaneously.
Micro-Frontends [1] [2][3] [4] were introduced in 2016 [1] to enable the decomposition of the front-end into individual and semi-independent frontends, separating the business logic from the frontend, and creating independent services that interact together [5]. Micro-Frontends are nowadays adopted by several large industries including DAZN, Ikea, New Relic, SAP, Springer, Starbucks, Zalando, and many others.
Micro-Frontends share the main principles, benefits, and issues of microservices [1]: both are modelled around business domains, hiding implementation details between them. Each team should own its microservice (back-end) and the related frontend, enabling to decentralize decisions and deploy independently. However, Micro-Frontends also introduce some drawbacks, such as the risk of communication overhead if the system is not well designed and revised with the business growth, potential performance issues when the vendors of a project are not carefully taken into account (for in-stance, we do for SPA), and broken user experience when the governance behind a design system is not well thought out.
Different software architects are pushing for this architectural style at practitioner forums. However, considering the costs some practitioners are still hesitant to adopt Micro-Frontends, because they are not fully aware of the pros and cons.
So, software developers often choose to adopt one architecture over another based on their experience in previous projects or based on the perceived benefits of the new architecture. Therefore, it is important to study why Micro-Frontends have been adopted, to understand the current motivations behind their adoption, and to investigate whether specific issues are believed to require more improvement than others. To elicit these motivations, we conducted an empirical study in the form of a Multivocal Literature Review (MLR) [6].
Therefore, the contribution of this work, is aimed to identify: • the motivations that led practitioners to adopt Micro-Frontends • the benefits achieved by the companies that adopted Micro-Frontends • the issues that practitioners experienced To the best of our knowledge, only a limited number of studies have investigated Micro-Frontends [7] [8]. This work will help companies to understand how Micro-Frontends can be beneficial for their needs, and if motivations, issues and benefits that other companies experienced match their expectancy. Moreover, this work can help researchers to understand the new trend, while at the same time opening up new avenues for future research on web front-ends.
The remainder of this paper is structured as follows. Section 2 presents the background of this work, introducing Micro-Frontends, and comparing them with Microservices. Section 3 discusses the related works on Micro-Frontends. Section 4 describes the Research Questions we proposed while Section 5 provides detailed information on the MLR process we adopted. Section 6 reports the results to our RQs and discusses them. Section 7 highlights the threats to validity while finally, Section 8 draws the conclusions.

Background
In this section, this work provides a brief overview of the technical domain of this Multivocal Literature Review on Micro-Frontends architecture.
First, this work explains the overview of Micro-Frontends and after that, how Micro-Frontends are related to Microservices.

Micro-Frontends
No silver bullet for designing a software architecture has been made and there will be no such thing coming in the future. Nonetheless, software development practitioners and researchers are constantly searching and developing new ways to create software applications which are fast to develop and deploy as well as easy to maintain. Also, companies have to adopt new agile methodologies into their organizational structures to respond to customer needs at unprecedented speeds [9].
Working on the front-end side of the application developers and software architects have a few architectural options to choose from e.g., single-page applications, SPAs, in short, server-side rendering applications, or application composed by static HTML files. Over time these architectures might lead the project to become monoliths. This increases the complexity of the front-end application and making changes on part of the system may have unnecessary or unwanted effects on other parts. Code bases become huge, the application has a lot of dependencies and becomes tightly coupled, coordination between development teams becomes harder and slower, which leads to the law of diminishing returns. Increasing the number of developers on front-end teams will not affect the production rate, since the chosen architecture has set boundaries for developers.
Micro-Frontends extends the concepts of Microservices to the front-end side of the application. It transforms monolithic web applications from a single code based application architecture to an application that combines multiple small front-end applications into one whole. Each of these independent applications can run, and be developed and deployed independently. The capability of independent development and deployment allows development teams to build isolated and loosely coupled services. The idea behind Micro-Frontends is to handle a web application as a combination of features or business sub-domains. Each team should have only one domain to handle.
Front-end monoliths introduce horizontal layers to the front-end side of the application, but Micro-Frontends aim to divide the application vertically as shown in Figure 1. Each of these vertical slices serves a specific business domain or feature and is built completely from the bottom to the top. With Micro-Frontends, each development team can be technologically agnostic and decide what kind of technology stack to use. Teams can update or even switch the stack without cooperating with other teams.

Micro-Frontends Composition
For architecting a Micro-Frontends application there are a few different options to choose from. With Micro-Frontends architecture some architectural decisions have to be made upfront because these decisions will shape the future decisions which are done alongside the project.
To define Micro-Frontends, the key decision to make is a need to identify how to consider a Micro-Frontend from the technical point-of-view. For this there are two options: • Horizontal split: multiple Micro-Frontends per page • Vertical split: one Micro-Frontend per time In a horizontal split, multiple smaller applications are loaded to the same page and this requires that multiple teams need to coordinate their efforts since each team is responsible for a part of the view.
With the vertical split scenario, each team is responsible for a business domain e.g. authentication or payment experience. With the vertical split, Domain-Driven Design (DDD) will apply.
Three different approaches can be used for composing Micro-Frontend applications( Figure 2): • Client-side composition • Edge-side composition • Server-side composition

Client-Side Composition
On the client-side composition, an application shell loads Micro-Frontends inside itself. Micro-Frontends should have as an entry point a JavaScript or HTML file so that the application shell can dynamically append the DOM nodes in the case of an HTML file or initialize the JavaScript application when the entry point is a JavaScript file.
Another possible approach is to use a combination of iframes for loading different Micro-Frontends otherwise transclusion mechanism, which could be used on the client-side via a technique called client-side include. This is where the application shell is lazy loading components inside a container using a placeholder tag, and parses all the placeholders by replacing them with the corresponding component. This approach brings many options to the table. However, using client-side includes has a different effect than using iframes.

Edge-Side Composition
With edge-side composition, the web page is assembled at the CDN level. Many CDN providers give us the option of using an XML-based markup language called Edge Side Include (ESI). ESI is not a new language; it was proposed as a standard by Akamai and Oracle, among others, in 2001. The reason behind ESI was the possibility of scaling a web infrastructure to exploit the large number of points of presence around the world provided by a CDN network, compared to the limited amount of data centre capacity on which most software is normally hosted. One of the drawbacks of this implementation is that ESI is not implemented in the same way by each CDN provider; therefore, a multi-CDN strategy, as well as porting application code from one provider to another, could result in a lot of refactors and potentially new logic to implement.

Server-Side Composition
On the server-side composition, which could happen at runtime or at compile time. In this case, the origin server is composing the view by retrieving all the different Micro-Frontends and assembling the final page. If the page is highly cacheable, it will then be served by the CDN with a long time-to-live policy; instead, if the page is personalized per user, it will require serious consideration regarding the scalability of the eventual solution, when there are many requests coming from different clients. When the server-side composition is decided to use, use cases in the application need to be analysed deeply. If runtime composition is used, the project must have a clear scalability strategy for servers in order to avoid downtime for our users. After understanding all the possibilities, the decision needs to be made, which technique is more suitable for the project and the structure of the development team. Also, a mix of approaches can be used.

Microservices vs. Micro-Frontends
In recent years Microservices have received great attention in the academic field, and have become one of the key research objects in the field of information science, but also in industrial fields where more and more companies are changing their monolithic singe-application back-end implementations to Microservice architectures. As mentioned in section 2.1 Micro-Frontends is a fairly new topic in the field of information science, but it has gained significant popularity amongst practitioners in this field.
By tradition single application, the system based on a single architectural style contains a large number of modules and dependencies between components, and overtime boundaries between modules become unclear. With tightly coupled modules, modifying one part of the application forces the project to be redeployed entirely. This full redeployment process takes a long time and has a large impact range. As a tightly coupled application, a single application cannot be targeted for the characteristics of different business modules, and can only be expanded as a whole, resulting in a waste of resources. Microservices are a variant of the service-oriented architecture architectural style that builds applications as a collection of loosely coupled services. It merges complex broad applications in a modular way based on small functional components that communicate through a collection of language-independent APIs, as shown in figure 4. Each functional block or service focuses on a single responsibility and function, and can be developed, tested, and deployed independently [10]. This enables development teams to develop applications in parallel. It also enables continuous delivery and deployment. On the back-end side, the Microservice architecture has relatively mature implementation solutions and its benefits are definite, but the front-end side of the application remains monolithic under current development trend. As mentioned, Micro-Frontends extends the Microservice architecture idea and many principles from Microservices apply to Micro-Frontends: • Modeled Around Business Domains: Following the Domain-Driven Design principles (DDD), each piece of the software should align business and technical concerns through analysis of the business domain, modelling of the problem domain [11], and leveraging ubiquitous languages shared across the business.
• Culture of Automation: A strong automation culture allows us to move faster and in a more reliable way. Considering that every Microservice and Micro-Frontends project contains tens if not hundreds of different parts, we need to make sure our continuous integration and continuous deployment pipelines are solid and with a fast feedback loop for embracing this architecture. Investing time to get our automation right will result in the smooth adoption of Microservices but also of Micro-Frontends.
• Hide Implementation Details: Hiding implementation details and programming with contracts are two essential assumptions, especially when parts of the application need to communicate with each other. Its very important to define a contract upfront between teams and for all parties to respect that during the entire development process. In this way, each team will be able to change the implementation details without impacting other teams, unless there is an API contract change. These practices allow a team to focus on the internal implementation details without disrupting the work of other teams. Because each team can then work at its own pace and without external dependencies, this will result in a more effective integration.
• Decision Decentralization Decentralizing the governance empowers developers to take the right decision at the right stage to solve a problem. Often with a monolith architecture, many key decisions are made by the most experienced people in the organization. These decisions, however, often lead to trade-offs alongside the software lifecycle. Decentralizing these decisions could have a positive impact on the entire system by allowing a team to take a technical direction based on the problem(s) they are facing, instead of creating compromises for the entire system. However, it is important that the tech leadership (architects, principal engineers, CTOs) should provide high-level directions where the team can operate without needing to wait for central decisions.
• Independent Deployment: One of the benefits of Microservices and Micro-Frontends is the possibility to deploy artefacts independently.
Teams can deploy at their own speeds without waiting for external dependencies to be resolved before deploying in production. Considering this with Micro-Frontends and Microservices, it is obvious that a team could own a vertical business domain end to end deciding the best infrastructure, the best front-end and back-end technology suitable for a business domain.
• Failure Isolation: Considering that, splitting a monolith application into tens, if not, hundreds of services, if one or more Microservices becomes unreachable due to network issues or service failures, the rest of the system ought to be available for users. There are several patterns for providing graceful failures with Microservices and the fact that they are autonomous and independent are just reinforcing the concept of isolated failure. Micro-Frontends require a part of the application to be lazy-loaded or compose a specific view at run-time with the risk to end up with errors due to network failures or 404 not found error. Therefore, the application needs to find a way to avoid impacting the user experience by providing alternative content or just hiding a specific part of the application.

Related Work
As mentioned earlier, Micro-Frontends architecture is a state of the art topic in the field of information technology research, which has not been extensively researched. Although, during the data search of this study, a few researchers investigated the topic.
Yang et al. [7] created a content management system (CMS) with Micro-Frontend architecture using Mooa Framework [12]. In their research Caifang et al. stated that "mooa framework system can not implement a variety of different technology stack development" as mooa supports only angular based Micro-applications. This decreases the technology-agnostic characteristic of Micro-Frontends on their implementation. They also state that "integration of multiple sub-projects becomes complicated". They conclude that Micro-Frontends architecture is still in the adopt stage and is not mature enough. This paper was also included in this works MLR and will be discussed more later on. For Micro Frontends search string Scholar gave 18700 results but search contained no additional sources to those which were explained above.
Mena et al. [8] created a progressive web application by using Microservices and Micro-Frontends architecture. The main focus on this study did not apply specifically on Micro-Frontends but Mena et al. concluded that "The micro frontend approach made it possible to build the user interface dynamically and develop visual components independently, finding different ways to show the user data." At the best of our knowledge, no other peer-review works have been published.

Research Questions
The goal of this work is to systematically map, review, and synthesize state-of-art and -practices in the area of web front-end architectures, so to understand the reasons why this architectural style is getting attention amongst practitioners and industrial companies, also highlighting Micro-Frontends benefits and issues. Moreover, This work also tries to identify opportunities for future research, especially from the point of view of practitioners and industrial companies.
The novelty of the Micro-Frontend architecture allows approaching this subject from many different research directions since not much scientific research has been made yet. For this reason, research questions were defined to cover the most basic topics to get a comprehensive view of this subject but not to go too deep into details.
Based on the aforementioned goal, we formulated three Research Questions (RQs): RQ1 Why practitioners are adopting Micro-Frontends?
In this RQ, we aim at understanding the motivations that lead companies to adopt Micro-Frontends for developing web applications.
RQ2 What benefits are achieved by using Micro-Frontends? Different software architectures aim to solve different problems that other architectures fail to do or enhance parts of the development process which will eventually affect the life-cycle of the application.
In this RQ, we want to understand the benefits provided by Micro-Frontends, and which type of problems Micro-Frontends are aimed to solve.
RQ3 Do Micro-Frontends introduce any issues? Every technology has benefits and issues. In this RQ we want to understand what issues might occur when using Micro-Frontends and what trade-offs are being made to overcome these issues.

Study Design
In this Section, we provide an overview of the study process adopted in this work. Because of the novelty of the topic, and of the large presence of user-generated content on the web, we adopted a Multivocal Literature Review (MLR) process [6]. In the remainder of this Section, we provide an overview of the overall process, the strategy adopted for the search process, the selection, data extraction, and synthesis processes.

The MLR Process
Systematic Multivocal Literature Review (MLR) proved to be the best choice for the research method due to the lack of maturity of the subject. In a normal case, the MLR process is divided so, that it includes both academic and grey literature and the differences between practitioners and academic researchers can be synthesized from the results. The key motivation for the inclusion of grey literature is the strong interest of practitioners on the subject and grey literature content creates a foundation for future research. We classified peer-reviewed papers as academic literature, and other content (blog post, white-papers, Podcasts, ...) as grey literature.
The MLR process adopted was based on five steps ( Figure 5): • Selection of keywords and search approach • Initial search and creation of initial pool of sources • Reading through material • Application of inclusion / exclusion criteria • Creation of the final pool of sources

Search approach
In this section, we first present the search process adopted for the academic literature, the adaptations we made for the web search, and the snowballing process we adopted.

Academic Literature Search
As recommended by Garousi et al [6], we adopted the traditional Systematic Literature Review process for searching academic literature.
Initially, we selected the relevant bibliographic sources. As including papers from one single publisher may be a bias for an SLR, we considered the papers indexed by several bibliographic sources, namely: • ACM digital Library [13] • IEEEXplore Digital Library [14] • Science Direct [15] • Scopus [16] • Google Scholar [17] • Citeseer library [18] • Inspec [19] • Springer link [20] We adopted the search strings "Micro-Frontend*", "Micro Frontend*". Search strings were applied to all the fields (title, abstract, keywords, body, references), so as to include as many academic works of literature as possible.
The search was conducted in April 2020, and all the raw data are presented in the raw data [21].

Grey Literature search
We adopted the same search strings for retrieving grey literature from Google. We applied the Search strings to four Search results consisted of books, blog posts, forums, websites, videos, white-paper, frameworks, and podcasts. Search results from every result page were copied to a Spreadsheet. This search was performed between 16.02.2020 and 17.02.2020. The spreadsheet is available in the replication package [21].

Snowballing
We applied a backwards snowballing to the academic literature, to identify relevant papers from the references of the selected sources. Moreover, we applied backward snowballing for the grey literature following outgoing links of each selected source.

Application of inclusion / exclusion criteria
Based on SLR guidelines [24], we defined our inclusion criteria, considering academic literature describing the motivation for the adoption of Micro-Frontends, their benefits or issues.
Moreover, we defined our exclusion criteria as: • Exclusion criterion 1: Adoption of the term Micro-Frontend for different purposes or different domains (e.g. in mechanics) • Exclusion criterion 2: Non-English results

Data Extraction and Synthesis
Based on our RQs, we extracted the information on a structured review spreadsheet.
To identify motivations, benefits, and issues we extracted the information from the selected sources via open and selective coding [25]. The qualitative data analysis has been conducted first by the first author, and then by the last two authors individually. In a few cases, some motivations, benefits or issues were interpreted differently by some authors. Therefore, we measured pairwise inter-rater reliability across the three sets of decisions and we clarified possible discrepancies and different classifications together, so as to have a 100% agreement among all the authors.

Creation of final pool of sources
From the initial pool of 171 sources, 129 sources were excluded. This finalized the pool with 42 sources, from which only 1 (2,38 %) was a peerreviewed-conference paper and the other 41 were sourced in the grey literature (e.g., articles, blog posts, videos, books, and podcasts).

Study Results and Discussion
In this section, we present the results of our work, following the research questions presented earlier in Section 4. The results are based on data extracted from 42 selected sources including 1 peer-reviewed academic paper and 41 Grey Literature sources. As we can see from Figure 6, the number of publications on Micro-Frontends is constantly growing from 2015. Results from 2020 are lower since the search has been conducted from February to April 2020. Description. Large companies such as Zalando [S40], Ikea [26], Spotify [27], and many others are adopting Micro-Frontends. However, the reasons for the adoption are not yet clear to the community. Here we describe and compare the motivations reported by the selected sources.

Results.
The increased complexity of the legacy monolithic frontend and the need to scale the development teams are the main reasons for the adoption of Micro-Frontends. Selected sources often mention the problem of delegating responsibilities to independent teams, and the need to ease the support for DevOps. One interesting observation is that several practitioners reported adopting microservices-based architectures and Micro-Frontends because a lot of other companies are adopting them.
In order to quantitatively evaluate the importance of each motivation, in Table 1, we report the aforementioned motivations, together with the number of source mentioning them. Motivation column summarizes the overall motivation to adopt Micro-Frontends architecture in development processes. Represented motivation is defined after the table. Sources column summarizes how many of the result sources mentioned motivation in question and percentage representation out of total sources. As frontends growth, they become harder and harder to maintain. The growth leads to three motivations for the adoption of Micro-Frontends: -M1.1: Large codebase As the backend side of the application has moved to use Microservices, frontend side remains monolithic. Over time front-end grows so big that no team, let alone developer, can understand how the entire application works [S6] [S2]. Therefore, the monolith frontend becomes hard to scale from the development point of view, and cannot be evolved with current market demands [S14], [S2]. Large applications that are built by using monolith architectures have a lot of dependencies, coordination then becomes harder and more time-consuming which leads to the law of diminishing return [S32].
The code of each Micro-Frontend will be by definition much smaller than the source code of a single of the monolithic frontend. These smaller codebases tend to be simpler and easier for developers to work with [S12]. While the application grows, there needs to be more developers working with this application. As companies have more developers working on the same team, product managers want to deliver more features, this means that the code base is growing fast which imposes a risk [S38].
-M1.2: Increased complexity The front-end will eventually become more and more bloated and front-end projects will become more and more difficult to maintain and the application becomes unwieldy [S42] [S36]. Every functionality in the application is dependent on each other. This means if one function stops working, the whole application goes down [S4]. Monolith approach does not allow improvement of software architecture in the long run, software code becomes more abstracted than it should be by increasing code complexity and decreasing its comprehensibility [S1] When the project has a medium-large team of developers, all the rules applied to the code base are often decided once at the beginning of the project, and the teams stick with them for months or even years because changing a single decision would require a lot of effort across the entire code base and be a large investment for the organization.
[S1] As a result, its development complexity rises exponentially with the number of teams modifying it [S2][S9] Also, the current production application might be done by last year's tech stack or by code written under a delivery pressure, and it's getting to the point where a total rewrite is tempting [S12].
-M1.3: Organizational problems Most of the development teams are working in an agile managed project delivery process that advocates cross-functional over a cross-technical team (Angular/React team, Java team, DB team, etc.). Micro-Frontend provides the flexibility to have a cross-functional team over a cross-technical team that focuses on end-to-end delivery [S21]. In this common example, naturally, product owners will start to define the stories as frontend and backend tasks and the cross-functional team will never be a real cross-functional unit. It will be a shallow bubble which looks like an agile team but it will be separated deep inside [S20]. Chris Coyier says "Anywhere Ive worked, these things are a big deal and it seems like the industry at large has had endless front-end problems with shipping designs that start and stay consistent and cohesive without repeating itself with shovelfuls of technical debt." [S5].
Overall 23 sources (54,76%) mentioned this as a motivation to use Micro-Frontends architecture in future applications.

• M2: Scalability
This work identifies three scalability motivations under comprehensive scalability: -M2.1: Scale Development teams Software development processes are complex and often the life cycle of the software can expand from months to even decades. As the life cycle of the application expands the more the application grows over time, the amount of features teams need to support grows also. While multiple teams are contributing to a monolithic application, the more tedious the development and release coordination becomes [S41] [S33] [S27] [S12] [S42]. Single-page applications, server-side rendering applications or a static HTML page with monolith architecture does not scale well according to business needs because there are not many options to choose from [S1], this results in the collapse of agile methodologies inside development teams [S18].
-M2.2: Independent deployments While updating a monolithic Website or Web application, you need to update it completely. You cant update just one functionality while keeping the rest of the functionalities old because doing so will cause problems in the website [S4] [S41]. This increases the change of breaking the application in production, introducing new bugs and mistakes especially when the code base is not tested extensively [S1] [S17].
With front-end separation to multiple smaller pieces, development teams achieve flexibility in development and operations [S40].

-M2.3: Fast delivery
The software industry is moving fast forward and companies are dependent on applications and new features on them. These features need to be deployed fast and in a reliable way. With multiple teams working on the same code base this target is hard to achieve [S38].
• M3: Code-base rules evolution When we have a medium-large team of developers, all the rules applied to the code-base are often decided once, and teams stick with them for months or even years because changing a single decision would require a lot of effort across the entire code-base and be a large investment for the organization. [S1] • M4: Slow on-boarding The large code base is confusing and initiation of a new developer is time-consuming because the application has grown too large and has too many edges to explore [S32]. Elisabeth Engel describes 'As new developers came to the project and learning it, most of them said that monolith application should be migrated to use more manageable option because understanding the architecture took too long' [S39].

• M5: Killing innovation
Using a monolithic code base forces developers to introduce new techniques and apply to the entire project for maintaining a code base consistency [S32][S17]. Due to the nature of Micro-Frontends development team can evolve part of the application without affecting the entire system. In this way, testing a new version of a library or even a completely new UI framework won't provide any harm to the application stability [S39].

• M6: Avoid Hasty Abstractions
Application has more abstraction layers and top of that is another layer which makes the whole architecture complex and more messy [S39]. A lot of code is duplicated and the same thing is done many times over and over again with monolith architectures [S37].
Abstractions are always hard to maintain, code duplication, despite it's less elegant, provides greater flexibility and options when we want to refactor. There are a school of thoughts where a wrong abstraction is way more expensive than code duplicated. Often developers are abstracting code in components or libraries for using it a couple of times. The problems are not the first iteration where the requirements are clear but the following ones. In the long run, abstractions may become very hard to maintain and to understand and often not useful at all. A good technique for implementing the right level of abstraction inside a project is starting with code duplication and when we see duplicated code in more than 3 parts of the applications, try to abstract it. In this way we keep the flexibility to evolve the code independently, reducing the complexity of abstraction and we are in a position to abstract the code way faster than doing it the other way around 1 .

Discussion
As can be seen from results answering RQ1, most of the motivations for the adoption of Micro-Frontends are similar to those for adopting microservices [28]. The increased complexity of the frontends often does not allow companies to scale its development processes, assigning different crossfunctional features to different teams.

What benefits are achieved by using Micro-Frontend architecutre (RQ 2)
Description This section provides results on the benefits that practitioners are receiving by using Micro-Frontend architectures. Many benefits of Micro-Frontends are similar to Microservices. Results are shown in table 2 Results  [S4]. As Micro-Frontend architecture combines multiple smaller applications into one, the stack and the techniques used will not affect other applications [S6][S18].
As applications can be implemented in different technologies [S25] in the world of the rapid evolution of front-end technologies, it is impossible to choose an ideal JavaScript framework, which would not be considered as a legacy in the upcoming years. It is a great benefit that a new framework can be chosen without having to rewrite the existing system. Technologies can be selected by the development team, based on their needs and their skills [S3].
• B2: Autonomous cross-functional teams Micro-Frontends bring the concept and benefits of Microservices to front-end applications. Each Micro-Frontend is self-contained, which allows delivery of fast as multiple teams can work on different parts of the application without affecting each other [S11]. Development teams are being able to concentrate on their work without needing permission from the rest of the organization. Teams can create innovative architectural decisions inside their applications because the blast radius of those decisions is much smaller [S29][S19].
Each team have a distinct area of business that it specializes in [S25]. A team can be cross-functional and develops end-to-end features for large web applications, from the user interface to the back-end and database [S14][S34] [S15]. With cross-functional teams, teams have full ownership of everything, from ideation through to production and beyond, they need to deliver value to customers, which enables them to move quickly and effectively. [S12] • B3: Independent development, deployment and managing and running Each Micro-Frontend application is independent. Changing one application will not affect the other parts and it is also more maintainable [S39][S17] [S23]. On a large application, many teams can work parallel and produce features fast without the need to coordinate with other teams [S37]. Therefore, Micro-Frontends enable teams to develop independently, quickly deploy and test individually, helping with continuous integration, continuous deployment, and continuous delivery [S42][S18][S19] [S3][S11] [S6]. Since all the front-end modules of the Website or web application are independent of each other, you can develop, test, and deploy them in parallel. This reduces the development time and results in faster deployment. [S4] By creating small independent applications or modules, resources and teams can proficiently work in separate technologies in their isolated Microservices reducing the risk of conflicts, bugs, and deployment delays [S14].
Also, the source code for each Micro-Frontend will by definition be much smaller than the source code of a single monolithic frontend. These smaller codebases tend to be simpler and easier for developers to work [S16]. Independent deployment reduces the scope of deployment, which in turn reduces the associated risk [S12].
Known ownership of verticals enables better DevOps and faster incident response [S2] Developers can focus on their work and deliver business value; with less technical synchronization with other teams is needed.
• B4: Better testability Testing becomes simple as well as for every small change, you dont have to go and touch the entire application [S41][S19].
With Micro-Frontends, testing becomes easier because the developer does not have to run the whole test suite every time [S39].
Changing a part in a monolithic application can have multiple sideeffects which lead to changing something else in the application. While the application is specified only to one domain, testing becomes much easier and will not affect the whole application [S24].
• B5: Improved fault isolation, resiliation Using Micro-Frontends built with micro-application, one of the biggest benefits of Micro-Frontend over the traditional monolith structure is that in case any issue occurs, theres no need to shut down the entire frontend application to fix it. If some application fails in run-time the app-shell can detect this and inform the user about the issue [S39] [S2] This is one of the biggest benefits of Micro-Frontend over the traditional monolith structure. In case any issue occurs, theres no need to shut down the entire frontend to fix it. Instead, you can fix the module which is having issues while the rest of the app keeps working. [S4] • B6: Highly Scalable A loosely coupled architecture with established global standards makes it easier to add new features or spin up teams when needed [S41] Divide and distribute the development of end-to-end features to an arbitrary number of teams, who can then independently and rapidly develop, deploy, maintain and operate their solutions [S30].
No coupling between the frontends means the complexity of the overall system doesn't go up with the amount of them you have and your organization can scale to infinity without increasing coordination [S29].
Also, it is easy to spin-off new development teams if needed [S32].
Since Micro-Frontend has a modular structure, you can easily upgrade it according to your business needs or market trends. You dont need to upgrade the entire front-end. Instead, you can just upgrade the module thats needed to be up-scaled now and continue updating as your business needs change [S4].

• B7: Faster Onboarding
Enabling teams to on board and deliver quickly [S41] [S32]. Each time a developer joined the development team, they almost immediately understood the system with confidence [S39] • B8: Fast initial load Application shell loads micro applications based on the route when the user comes to the web application [S37].
• B9: Improved performance Since each app is fragmented into its own Micro-Frontend, if a single feature (one micro frontend) on an enterprise app isnt loading fast, it wont affect the performance of the entire application. It also makes it possible for certain parts of a webpage to load faster, allowing users to interact with the page before all features are loaded or needed [S41] Resulting in faster responses, less code shipped to the browser, and better total load times. [S26] • B10: Future proof If something new is coming e.g., new framework it can be easily tested and integrated into Micro-Frontends architecture, it can easily be abandoned also [S39]. As teams are now free to choose their technology of choice, this makes the application future proof. Teams do not have to invest in only one framework. [S27] Discussion As can be seen from results answering RQ2, several of the benefits reflect the motivations for the adoption. As an example, the problem of scaling the development team can be easily tackled with Micro-Frontends. However, based on our experience while developing Micro-Frontend based systems, performances and initial load time depends on how the system is developed, and in particular, on the composition approach adopted (Section 2.2). In general Micro-Frontends are not the fastest implementation. As an example, the JAM stack 2 is much faster, because HTML pages contain all the content, and do not need to load dynamically other components. However, a Single Page Application might be faster. If developed with the separation of the bundle (e.g. in webpack you can split the JS bundle, so as you download only the beginning of the SPA) and then you load the remaining one (aka code splitting). Server-side/CDN rendering might also be a fast option, but you need to access to several APIs to compose the page, as pages are not static. As for the Fast Initial load, the adoption of Micro-Frontends might improve the overall performance, because you only need to load a smaller footprint. The idea of Micro-Frontends is that you load only what you need, not the whole application. As an example, a payment method is usually based on the SDK provided by the payment provider. In a SPA you load the SDK and you download it every time. In Microfrontends, you only download it when you are logged, reducing some KB of memory for non-logged users.

Do Micro-Frontends introduce any issues (RQ 3)
Description While considering issues that practitioners reported while describing Micro-Frontends in the selected works, we highlighted technologyrelated issues and people-related issues. Quantitative results are reported in Table 3. Results Technology-related issues • I1: Increased payload size Shipping multiple technology stacks in micro-frameworks has the potential to negatively impact the end-users.
As a result, if applications are using more than one JS frameworks (for example, 2 applications use Angular and 1 uses React) then the web browser has to fetch a lot of data, with the results of slowing the loading time of the application [S3][S15] [S22][S6] [S16].

• I2: Code Duplication
Independently-built JavaScript bundles can cause duplication of common dependencies, increasing the number of bytes applications have to send over the network to end users. For example, if every Micro-Frontend includes its own copy of React, then we're forcing our end users to download React n times. There is a direct relationship between page performance and user engagement/conversion, and much of the world runs on internet infrastructure much slower than those in highly-developed cities are used to, so teams have many reasons to care about download sizes [S12][S10].
• I3: Shared Dependencies The dependency redundancy between sub-projects after integration increases the complexity of management [S42][S39] [S2]. At the end of the day, Micro-Frontends will have shared dependencies and shared code [S23]. This is hard to nail and requires more testing [S38] When Micro-Frontends are composed in the browser (client-side rendering) there is no singular build process that can optimize and reduplicate shared dependencies. [S7][S18].
• I4: UX consistency The user experience may become a challenge if the autonomous individual teams go with their own direction hence there should be some common medium to ensure UX is not compromised [S20] [S23]. As new web development frameworks and libraries are being released at a brisk pace, the ability to create interoperable. UX consistency and rich UIs are harder to achieve [S2] and allowing multiple technologies and isolation increases the risk of lack of consistency. [S14] UI components between frameworks requires building reusable foundational elements which is time-consuming as well. [S41] A possible way to increase UX consistency is to use a shared CSS stylesheet, but it means that all applications would depend on one common resource. Is there a better approach? The answer is yes and no. There is no perfect solution, but we would recommend using a separate style sheet for each application. Redundancy causes the user to fetch more data, thus impacting application load-time. Additionally, components would have to be implemented at least once, which impacts development cost and consistency. The benefit of this approach is independence. This way, we can avoid teams synchronization problems during development and deployment. Having a common style guide, designed for example in Zeplin, helps to keep the look and feel consistent (but not identical) across the whole system. Alternatively, we could use a common component library included by each application. The disadvantage of this solution is that whenever someone changes the library, they have to ensure that they do not break dependent applications. It would introduce huge inertia. Moreover, a library in most cases can only be used by a single framework. There is no easy way to implement a UI components library, that could be used by the Angular and React app. [S3] One of the critical problems is standardizing UX principles. A universal solution is to use a style guide, e.g., Bootstrap, Material Design, among others. Communication is the key to ensure everything is running smooth, so creating some rules and standards can help minimize conflicts with the diversity of teams working on a product [S14] [S22].
• I5: Monitoring Tracking and debugging problems across the entire system is complex [S10] • I6: Increased level of complexity Micro-frontends are not applicable for every application because of their nature and the potential complexity they add at the technical and organizational levels [S1] This approach can get quite complex if you need to support a large number of significantly different clients implemented with different technologies (e.g. web, native mobile clients, desktop etc.) [S2] [S3].
This type of architecture requires more initial analysis to understand how everything will work in integration, and how the application can be broken into smaller modules. Building microservices, and Micro-Frontends introduces significant architectural complexity which will require deeper analysis and quicker interactions. [S14][S15] [S6]. [S10].
• I7: Governance The dependency needs to be managed properly. The collaboration becomes a challenge at a time. The multiple teams working on one product should be aligned and have a common understanding, though when there is a change in multiple directions in terms of organizational and technology strategy [S41].
• I8: Islands of knowledge Many cross-functional teams working on the same product, each one working on a different code base and not exposing what they are really doing to other teams. The same implementation will happen over and over again. This is very costly, time-consuming and unnecessary for the companies. [S38] We recommend using a community of practices, town hall, internal meetups, and a scrum of scrums sessions to overcome this issue.
• I9: Environment differences There are risks associated with developing in an environment that is quite different from production. If applications development-time container behaves differently than the production one, then the team might find that their Micro-Frontend application is broken, or behaves differently when they deploy it to production [S12].
However, there is a way to mitigate this problem following the testing in production mindset where we deploy our new micro-frontends in production with 0 live traffic and the UAT department can test the new module alongside the existing the rest of the application. When the tests are satisfying, we can shape traffic to the new micro-frontends either with a small percentage (canary release) or switching the entire traffic (blue-green deployment) • I10: Higher risk when releasing updates Just as teams are able to distribute new changes instantly across many services, They are also able to distribute bugs and errors. These errors also surface at application run-time rather than at build time or in continuous integration pipelines. [S7] Feature flag and canary releases can help to avoid this problem. If they are totally independent you can only break the single Micro-Frontend.
• I11: Accessibility challenges Some of the implementations of Micro-Frontends, particularly looking at embedding iFrames, can cause huge accessibility challenges [S10].
Our recommendation, if the application has accessibility requirements it is simply to avoid using iFrames.

Threats to Validity
In this section, we discuss threats to validity and the strategies we adopted to mitigate them.
Our paper might suffer from threats related to the adopted selection strategy, the data extraction process, internal and external validity.

Selection strategy threats
One of the biggest threats of this work is the representation of the selected works. We adopted an MLR process, including first the academic literature and then the grey literature from different sources. We query the academic literature from eight bibliographic sources, while we included the grey literature from Google, Medium Search, Twitter Search and Reddit Search. Additionally, we applied a snowballing process to include all the possible sources.

Data Extraction
Data extraction is a manual process, that might bias the results of this work. To reduce this threat, we adopted the MLR and SLR guidelines. Moreover, the data extraction has been conducted by the first author and then validated by all the remaining authors.

Replicability
To enable the replication of this work, we published the complete replication package with the results of all the queries and the data extracted from the data extraction schema

External Validity
In our study we map the literature on Micro-Frontends, considering both the academic and the grey literature. However, we cannot claim to have screened all the possible literature, since some documents might have not been properly indexed, or possibly copyrighted or, even not freely available.

Conclusion
This work presents the results of the first systematic survey on Micro-Frontends, investigating the motivations that led companies to adopt them, the benefits and issues they experienced. We conducted a Multivocal Literature Review (MLR) [6], considering 42 sources (1 academic (1) and 41 grey) literature, as presented in section 5.6. The main findings of this study confirm that companies and practitioners are seeking alternative architectures for web-frontend development in order to scale development processes and enhance innovation in a rapidly changing business field and allow development teams to be independent and technologically agnostic.
The most common motivation to adopt Micro-Frontends is the growth of the monolithic frontends (61.90%) and the consequent increase in code complexity and the need to scale development processes to multiple teams (30.95%).
Micro-Frontends architecture provides the same benefits to the frontend side as microservices did to the back-end side of the application. The most mentioned benefits are support for different technologies (50.00%), Autonomous cross-functional teams (42.86%) and independent development, deployment, and managing and running (36.71%).
However, Micro-Frontends are not a silver bullet for designing frontend applications as they increase the overall complexity of the systems (28.57%) increases payload size (11.90%), and in general increase development and cloud-related costs.
Finally, as this study focused on comprehensive motivation, benefits, and issues with Micro-frontends architecture future examination is required to broaden the scope with the implementation details to find out the advantages and disadvantages of Micro-Frontends composition patterns and overall affection to the development processes.
We are planning to conduct a survey among practitioners to confirm the results obtained in this work and to understand how to properly architect a system based on microservices, Serverless Functions, and Micro-Frontends. Future works also include the investigation of benefits and issues of the different Micro-Frontend composition approaches (See Section 2.2) and other composition and architectural approaches to enable multiple teams to work on the same front-end.