The life of a full stack developer would be worthy of a whole book by itself, so let's leave that topic for another day.

Instead, let's look at a user story from a full stack Java web application and see what is involved.

Let's use an example of developing a user management module for a typical Java web application. Let's assume that you would be writing unit test cases for all of the code, and so we won't look at it in detail here:

1. You would start by designing the architecture for the feature. You would decide on the plugins and frameworks to use, patterns to follow, and so on.
2. You will be modeling the domain model for the feature depending on the database technology used.
3. Then, you would create server-side code and database queries to persist and fetch data from the database.
4. Once the data is ready, you would implement server-side code for any business logic.
5. Then, you would implement an API that can be used to provide data for the presentation over an HTTP connection.
6. You would write integration tests for the API.
7. Since the backend is ready, you would start writing frontend code in JavaScript or similar technology.
8. You would write client-side services to fetch data from the backend API.
9. You would write client-side components to display the data on a web page.
10. You would build the page and style it as per the design provided.
11. You would write some automated end-to-end tests for the web page.
12. You are not done yet. Once you have tested whether everything works locally, you would create pull requests or check the code into the version control system used.

13. You would wait for the continuous integration process to verify everything and fix anything that is broken.
14. Once everything is green and the code is accepted, you would typically start the deployment of this feature to a staging or acceptance environment, either on-premises or to a cloud provider using technologies like Docker and Kubernetes. If you choose the latter, you would be expected to be familiar with the cloud technologies used as well. You would also be upgrading the database schema as necessary and writing migration scripts when required.
15. Once the feature is accepted, you might be responsible for deploying it into the production environment in a similar way, troubleshooting issues where necessary. In some teams, you might swap the steps with other team members so that you would be deploying a feature developed by your coworker while they deploy yours.
16. You might also be responsible, along with your coworkers, for making sure that the production environment is up and running, including the database, virtual machines, and so on.

As you can see, it is no easy task. The range of responsibilities spans from making stylesheet updates on the client-side to running database migration scripts on a virtual machine in the production cloud service. If you are not familiar enough with the setup, then this would be a herculean task, and you would soon be lost in the vast ocean of frameworks, technologies, and design patterns out there.

Full stack development is not for the faint-hearted. It takes a lot of time and effort to keep yourself up to date with the various technologies and patterns in multiple disciplines of software development. The following are some of the common problems you might face as a full stack Java developer:

• Client-side development is not just about writing plain HTML and JavaScript anymore. It is becoming as complex as server-side development, with build tools, transpilers, frameworks, and patterns.
• There is a new framework almost every week in the JavaScript world, and if you are coming from a Java background, it could be very overwhelming for you.
• Container technologies such as Docker revolutionized the software industry, but they also introduced a lot of new stuff to learn and keep track of, such as orchestration tools and container management tools.
• Cloud services are growing day by day. To stay on track, you would have to familiarize yourself with their APIs and related orchestration tools.

• Java server-side technologies have also undergone a major shift in recent times with the introduction of JVM languages, such as Scala, Groovy, and Kotlin, forcing you to keep yourself up to date with them. On the other side, server-side frameworks are becoming more feature-rich, and therefore more complex.

The most important thing of all is to make sure that all of these work well together when required. This task will need a lot of configuration, some glue code, and endless cups of coffee.

It's very easy to get lost here, and this is where technologies such as JHipster and Spring Boot step in to help. We will look at the details of these technologies in later chapters, but in short, they help by providing the wiring between moving parts so that you only need to concentrate on writing business code. JHipster also helps by providing the abstractions to deploy and manage the application to various cloud providers.

The full stack landscape is further complicated by the different web architecture patterns commonly used these days. The widely used web application architecture patterns today can be broadly classified into two patterns—monolithic architecture and microservice architecture, the latter of which has become mainstream (fashionable) in recent years.

A monolithic architecture is the most widely used pattern for web applications because of its simplicity to develop and deploy. Though the actual moving parts will differ from application to application, the general pattern remains the same. In general, a monolithic web application can do the following:

• It can support different clients, such as desktop/mobile browsers and native desktop/mobile applications.
• It can expose APIs for third-party consumption.
• It can integrate with other applications over REST/SOAP web services or message queues.
• It can handle HTTP requests, execute business logic, access databases, and exchange data with other systems.
• It can run on web application containers, such as Tomcat and JBoss.
• It can be scaled vertically by increasing the power of the machines it runs on or scaled horizontally by adding additional instances behind load balancers.

An example of a typical monolithic web application architecture would be as follows: Let's imagine an online hotel reservation system that takes online reservation orders from customers, verifies the room availability, verifies the payment option, makes the reservation, and notifies the hotel. The application consists of several layers and components, including a client-side app—which builds a nice, rich user interface—and several other backend components responsible for managing the reservations, verifying the payment, notifying customers/hotels, and so on.

The application will be deployed as a single monolithic web application archive (WAR) file that runs on a web application container such as Tomcat, and will be scaled horizontally by adding multiple instances behind an Apache web server acting as a load balancer. Take a look at the following diagram:

The advantages of a monolithic web application architecture are as follows:

• It is simpler to develop, as the technology stack is uniform throughout all layers.
• It is simpler to test, as the entire application is bundled in a single package, making it easier to run integration and end-to-end tests.
• It is simpler and faster to deploy, as you only have one package to worry about.
• It is simpler to scale, as you can multiply the number of instances behind a load balancer to scale it out.
• It requires a smaller team to maintain the application.
• The team members share more or less the same skill set.
• The technical stack is simpler and, most of the time, is easier to learn.
• Initial development is faster, thereby making the time to market shorter.
• It requires a simpler infrastructure. Even a simple application container or JVM will be sufficient to run the application.

The disadvantages of a monolithic web application architecture are as follows:

• Components are tightly coupled together, resulting in unwanted side effects, such as changes to one component causing a regression in another.
• It becomes complex and huge as time passes, resulting in slow development turnaround. New features will take more time to develop and refactoring existing features will be more difficult because of tight coupling.
• The entire application needs to be redeployed whenever any change is made.
• It is less reliable because of tightly coupled modules. A small issue with any service might break the entire application.
• Newer technology adoption is difficult as the entire application needs to be migrated. Incremental migration is not possible most of the time, which means that many monolithic applications end up having an outdated technology stack after some years.
• Critical services cannot be scaled individually, resulting in increased resource usage. As a result, the entire application will need to be scaled.
• Huge monolith applications will have a higher start up time and higher resource usage in terms of CPU and memory.
• Teams will be more interdependent and it will be challenging to scale the teams.

The microservice architecture has gained momentum in recent years and is gaining popularity in large-scale web application development because of its modularity and scalability. Microservice architecture can offer almost all the features of a monolith that we saw in the previous section. Additionally, it offers many more features and flexibility and so is often considered a superior choice for complex, large-scale applications. Unlike the monolithic architecture, it's quite difficult to generalize the microservice architecture as it could vary heavily depending on the use case and implementation. But they do (generally) share some common traits, which are as follows:

• Microservice components are loosely coupled. Components can be developed, tested, deployed, and scaled independently without disrupting other components.
• Components need not be developed using the same technology stack. This means that a single component can choose its own technology stack and programming language.
• They often utilize advanced features such as service discovery, circuit breaking, and load balancing.
• Microservice components are mostly lightweight and perform a specific functionality. For example, an authentication service will only care about authenticating a user into the system.
• It often has an extensive monitoring and troubleshooting setup.

An example of a microservice web application architecture would be as follows: Let's imagine a huge online e-commerce system where customers can go through categories of merchandise, list their favorites, add items to a shopping cart, make and track orders, and so on. The system has inventory management, customer management, multiple payment modes, order management, and so on. The application consists of several modules and components, including a UI gateway application, which builds a nice, rich user interface and also handles user authentication and load balancing, and several other backend applications responsible for managing the inventory, verifying the payment, and managing orders. It also has performance monitoring and automatic failover for services.

The application will be deployed as multiple executable WAR files in Docker containers hosted by a cloud provider. Take a look at the following diagram:

The advantages of a microservice web application architecture are as follows:

• Loosely coupled components resulting in better isolation, which means that they are easier to test and faster to start up.
• Faster development turnaround and better time to market for new features, and existing features can be easily refactored.
• Services can be deployed independently, making the application more reliable and making patching easier.
• Issues, such as a memory leak in one of the services, are isolated and will not bring down the entire application.
• Technology adoption is easier, as components can be independently upgraded with incremental migration, making it possible to have a different stack for each component.
• More complex and efficient scaling models can be established. Critical services can be scaled more effectively. Infrastructure is used more efficiently.
• Individual components will start up faster, making it possible to parallelize and improve overall startup for large systems.
• Teams will be less dependent on each other. This is best suited for agile teams.

The disadvantages of a microservice web application architecture are as follows:

• It is more complex in terms of the overall stack as different components might have different technology stacks, forcing the team to invest more time in keeping up with them.
• It is difficult to perform end-to-end tests and integration tests as there are more moving parts in the stack.
• The entire application is more complex to deploy as there are complexities with containers, orchestration, and virtualization involved.
• Scaling is more efficient, but it is also more complex, as it would require advanced features, such as service discovery and DNS routing.
• It requires a larger team to maintain the application, as there are more components and more technologies involved.
• Team members share varying skill sets based on the component they work on, making replacements and knowledge sharing harder.
• Applications with many microservices and different teams managing different services creates more organizational challenges.
• The technical stack is complex and, most of the time, it is harder to learn.
• Initial development time will be higher, making the time to market longer.
• It requires a complex infrastructure. Most often, it will require containers (Docker), orchestration (Kubernetes), and multiple JVM or app containers to run on.
• To effectively manage distributed systems, you need to set up monitoring, distributed tracing, service discovery, and so on. These are not easy to set up and require additional components to be run which will produce overhead and additional costs.

When starting a new project these days, it is always difficult to choose an architecture pattern. There are so many factors to take into account, and it is easy to get confused with all the hype surrounding different patterns and technologies (see the blog post on Hype Driven Development (HDD)) at https://blog.daftcode.pl/hype-driven-development-3469fc2e9b22). The following are some general guidelines on when to choose a monolithic web application architecture over a microservice architecture and vice versa.

The following list can be used as a general guide when choosing a monolithic architecture. This is not a definitive list, but it gives you an idea of when to go with a monolithic architecture over a microservice architecture:

• When the application scope is small and well defined, and you are sure that the application will not grow tremendously in terms of features—for example, a blog, a simple online shopping website, or a simple CRUD application
• When the team size is small, say fewer than eight people (this isn't a hard limit, but one that's based on the practicality of the team size)
• When the average skill set of the team is either novice or intermediate
• When the initial time to market is critical
• When you do not want to spend too much on infrastructure, monitoring, and so on
• When your user base is rather small and you do not expect it to grow—for example, an enterprise app targeting a specific set of users

In most practical use cases, a monolithic architecture would suffice. Read the next section to see when you should consider a microservice architecture over a monolithic architecture.

The following list can be used as a general guide to choosing a microservice architecture. This is not a definitive list, but gives you an idea of when to go with a microservice architecture over a monolithic architecture. Note that, unlike choosing a monolithic architecture, the decision here is more complex and may involve consideration of many of the following points:

• When the application scope is large and well defined and you are sure that the application will grow tremendously in terms of features—for example, an online e-commerce store, a social media service, a video streaming service with a large user base (yes, I'm thinking of Netflix), or an API provider
• When the team size is large and there are enough members to effectively develop individual components independently
• When the average skill set of the team is good and team members are confident about advanced microservice patterns
• When the initial time to market is not critical as the microservice architecture will take more time to get going initially
• When you are ready to spend more on infrastructure, monitoring, and so on, in order to improve the product quality
• When your user base is huge and you expect it to grow—for example, a social media application targeting users all over the world

Though a monolithic architecture would suffice in most cases, and you should choose it for simpler use cases, investing upfront in a microservice architecture will reap long-term benefits when the application scope is large and you know it will grow further. There is no silver bullet and there are always trade-offs.

So far, we've learned what full stack development is and compared two of the most prominent architecture patterns. We also learned about the advantages and disadvantages of monolithic and microservice architecture, which helps us to choose the right pattern for our use case.

In the next chapter, we will take a deep dive into the JHipster platform and look at all the options it provides. We will also learn how to install JHipster and set up our tools and development environment.