Entando will be at the virtual J4K conference on October 13-14 and our presentation will be on October 14 at 2PM ET. In this blog post we’ll introduce the central concepts for our talk and preview some of the technical capabilities that make Kubernetes and Java key to the future of micro frontends. Register for the J4K conference here!

Why do we still have a frontend monolith?

Many enterprises have tightly coupled application stacks organically grown over the course of years or decades and those monolithic applications hinder the kind of rapid development and responsiveness to customer needs required in a changing world. Teams have increasingly introduced microservices to partially address the issues caused by a monolith but then find themselves left with an architecture that inherits many of the same challenges - the frontend monolith. Implementing micro frontends and architectures that support them provides a solution to this problem. Our talk will introduce how Kubernetes is key to delivering on the modularity promise of a micro frontend architecture and how up and coming Java technologies are key to achieving that  promise. Java and Kubernetes together provide a unique set of capabilities for implementing micro frontends and finally ending the era of the monolith.

Kubernetes

Kubernetes allows a micro frontend architecture to achieve maximum flexibility and to take full advantage of the modularity and scalability of micro frontends and microservices. In particular, a micro frontend architecture can take great advantage of Kubernetes capabilities like:

• Ingress and routing for dynamic traffic management
• Service mesh to optimize communication and data access from the frontend
• Custom resources for discoverable and automated deployment of micro frontends and the microservices they need
• Automated scaling - only scale the services for micro frontends generating a lot of traffic

Our J4K presentation will cover how the Kubernetes features above take micro frontends to another level of value in delivering full stack functionality to the end user.

Java

New capabilities in the Java ecosystem also provide significant value to a micro frontend architecture. In particular, the GraalVM and frameworks like Quarkus enable micro frontends to consume backend functionality at significantly reduced cost, faster startup time, and lower resource footprints. In our presentation, we’ll introduce how the Java world brings capabilities like these to a micro frontend architecture:

• Serverless Java - deliver data and functionality to the front end from serverless apps
• Java’s huge open source world -- enable developers to deliver rich functionality to the frontend using tools they already know
• How JHipster and templating can accelerate development of Java applications for micro frontends
• Lightweight services using Quarkus enable modularity at low cost for both the frontend and the backend
• Easy containerization
• Fully CI/CD ready for quick testing and deployment 

Why Micro Frontends

Our presentation will also review why a micro frontend architecture should be adopted in general and the value that it provides using Java and Kubernetes.

A micro frontend architecture seeks to extend the value proposition of microservices to developing user facing applications. Micro frontends allow teams to create small, well defined, and isolated pieces of functionality that can be updated independently. Just like with microservices micro frontends communicate via a contract to allow for isolated testing and versioning. And micro frontends take advantage of well established technology and standards that ensure your teams don’t need to learn an entirely new stack.

In our J4K presentation we will review how micro frontends:

• Breakdown the frontend monolith
• Enable teams to deliver independently
• Give developers the freedom to choose and evolve their frontend frameworks
• Allow teams to build modular applications on both the frontend and backend
• Give enterprises the ability to deliver faster and get to market more quickly