Lesson finished
Up next: Two-Tier, Three-Tier, SOA, Event-Driven and Microservices Compared
Unlock all 48 lessons of Microservices using Java, Spring & DockerFull course ₹40,000 · paid
Course Outline and Monolithic Application Architecture Basics
A free lesson from Skill-Lync's Microservices using Java, Spring & Docker course, on Grow by Skill-Lync · Last updated 16 Nov 2026 · Session: “Week 1 Session 1 Part 1”
What will you learn in this free Microservices using Java, Spring & Docker lesson?
The instructor outlines the course, its prerequisites (Java, Eclipse IDE, REST concepts) and the bank microservice project. The lesson then explains tightly, loosely and decoupled architectures, the UI, API and database layers using IRCTC, and the monolith with its cross-cutting concerns.
- Course topics and prerequisites
- Tightly versus loosely coupled versus decoupled
- UI, API and database layers of an application
- Monolithic architecture and cross-cutting concerns
What comes after lesson 1?
The next free lesson is lesson 2, “Two-Tier, Three-Tier, SOA, Event-Driven and Microservices Compared” (13 min). Later in Skill-Lync's Microservices using Java, Spring & Docker course (paid): lesson 4, Week 1 Session 3; lesson 5, Week 1 Session 4; lesson 6, Week 2 Session 1. The full course has 48 lessons (18 h 7 min of video); see the course overview or its price and syllabus.
Lesson transcript
Machine transcript of the lesson audio (lightly cleaned). Technical terms may contain errors; the video is the reference.
Welcome all of you to this course on becoming a microservices developer using Java. This course will be spanned across 12 weeks and this is the first week of this course. In this week, we will be covering the following topics. First, the introduction to this course. Second, the prerequisites before taking this course. Third, what are the types of application architectures? Fourth, the comparison between various architectures. Fifth, the introduction to microservices. Sixth, the Java ecosystem for creating microservices application. And finally, we will be creating a simple microservice as well. So in this week, the logic objectives would be. First, we will try to understand what are the various common application architectures that are used in the industry along with their advantages and challenges. Next, we will understand what is microservices architecture and how we can implement microservices using Java and Spring framework. And finally, we will implement a simple microservices.
So first, let's introduce our course. So this course is going to be a crisp yet detailed introduction to microservice architecture, starting with the fundamentals and gradually moving on to advanced concepts. We will cover real world examples and tips would be provided to bring you on par with experienced developers quickly. Also, we will have hands-on coding and real world projects to help you get a flavor of microservices development while you're learning. So the fundamental focus. So the fundamental focus of this course would be to ensure that you understand what is microservice architecture. You really get the feel and the experience of understanding and developing a microservice application.
We would also understand what is the role of the Spring Cloud and the cloud native application and how the microservices and cloud native applications are interconnected. Then we will also understand the other technologies like what is Docker, what is Kubernetes, what is container orchestration and other such technologies. And also we will be moving on to some advanced topics like config server and distributed tracing, log aggregation, monitoring, routing, cross-cutting concerns and so on. So next, let's try to understand what is the prerequisites for this course. So in order to take this course, it is expected that you should have at least basic or working knowledge of Java, Eclipse IDE and REST API concepts.
However, we would cover the essential parts of Java and its other aspects throughout our discussion growing forward. Now let's see how can we learn this course better. Pay attention to the topics which are being taught in the class and also ensure to understand the coding exercises provided at end of each class. Try to make your own mini projects based on the knowledge gained through this course. The mini projects could be based on any real world scenario such as e-commerce app, cap booking, food delivery app, etc.
So the core concept is like, you know, you should first understand what is being taught in the each week after that complete the assignments which are provided to you. And once you have completed the course, ensure that you also building some mini projects on your own based on any of the real world scenarios which you can take. So this will ensure that you know you the whatever concepts you have learned in the class really stays with you for a long time. OK, so before we go any further, it's first important that we start our discussion with the types of application architecture.
So before we go any further, let's try to understand conceptually what is an architecture, right? So before we build any application even in like, you know, in your industry or even if you do it for your own personal project. It is important to understand like, you know, what is our application is going to do and how we are going to build it, right? Even before like, you know, you start to write your code. So it is important that, you know, we determine what is the pattern and technique with which it's going to be our application is going to be decide which will kind of act as an architectural blueprint before you build your application.
So this is similar to the architectural blueprint which you create before building your house. So an architecture helps you to kind of visualize on how various parts of your application are going to be set up and interact with one another. Okay, so as you kind of like, you know, grow in your career and become a senior developer architect and so on. Ultimately, you would be given this task of also to design the application architecture down the line. So it is a very important skill once you kind of mature in your project and you know, you kind of grow in your role. So it's important that, you know, you also understand what role does architecture play and what are the various types of architecture which is used to build any application.
So there are many tested architectural patterns which are available for creating an application. So it's not like, you know, you have to invent your own architecture every time before you create an application. There are many industry validated architectural patterns which are available for you and each architecture has its own advantages and challenges. So it is important for us to understand several architectural patterns and their differences before choosing one. So on a high level, we can kind of segregate the various architecture patterns into the following three types.
So I would call them like, you know, you can call them call them either strongly coupled loosely coupled or decoupled and an example for strongly coupled architecture would be something like a monolith architecture or a NTR architecture for loosely coupled architecture. The example could be even driven or so and for decoupled architecture. The example could be microservices. So don't worry if you don't understand what are these various terms like what is a monolith, what's a NTR and so on. We would be getting into them slowly in the demo part once I show you show all these concepts to you on the whiteboard. So for now, all you need to remember is if you want to kind of segregate various application architecture, you can do that in the following three ways, right?
You can either say they are strongly coupled. They are either loosely coupled or they are decoupled. So before going further, let's try to just understand what does all this terms means like what is strongly coupled? What is loosely coupled? What is decoupled? So strongly coupled architecture means if there are various part of your application, which kind of like no speaks to each other making change to one of one part of your application will also affect the other part of application, right? Loosely coupled means your application parts or the various parts of your application are not tightly bound or like, you know, do not strictly depend upon each other in a very like, you know, strict sense of fashion.
So say for example, you may have two parts that changing one part may or may not affect the other part, but there would still would be some dependencies, but the like, you know, the kind of dependence would not be too high. And decoupled means that you know each parts of the application are kind of independent of each other. And even if you make change to one part of your application, the other part of the application will not be affected in any case. OK, so let's try to understand all these concepts on the whiteboard.
OK, so before we proceed any further, let's try to summarize what we have learned. So we learned that architecture can be defined or classified on three high level parameters, right? One is tightly coupled, one is loosely coupled, and the third is decoupled. So for the tightly coupled, what we said is, so assume that, you know, this is your application and it has say like, you know, two, three parts. So maybe just imagine that, you know, this is the UI or the front end part of the application, which the user will be seeing and interacting.
This will be the API part of the services layer where you'll be writing all your business layer. And this is the database part, which is kind of like, you know, going to store all your databases, all your data in your application. So what does a tightly coupled means is all these three are sorts strictly bound to each other or strictly coupled with each other that even if you make a small change in the API layer, it is going to affect your DB and the UI. Similarly, if you make a small change in the UI, it will affect your API and DB. And similarly, if you make any changes to your database, it will be in turn affecting the API in the UI.
So this is what is called as a tightly coupled. So as a name implies, they are tightly coupled or tightly joined with each other. Okay. So this you can just imagine like, you know, to be the bricks of your wall. So just assume that, you know, you have a few bricks and you just stack them one above the other. So if you try to remove one of these below layers, right, the entire wall will collapse. So this is something like that, like, you know, wherein changing just one of these blocks will be affecting the entire structure.
And an example of this tightly coupled architecture is monolithic architecture or an entire architecture. Okay. So what is a monolithic or entire architecture? So it is just same as what we have learned for tightly coupled. So in a monolithic architecture, what happens is so just assume that, you know, this is our application. So maybe for namesake, just assume that, you know, this is an IRCTC booking application. Okay. So just assume that, you know, we're going to build IRCTC on as a monolithic application. So when you build IRCTC as a monolithic application, what happens is all the code for the front end facing website or the mobile application, you'll be dumping it in one module and keeping it over here.
All the code which deals with the actual ticket booking, checking whether the seats are available and all that, you'll be writing the code for that and keeping it in one module. And all the data that you'll be storing, you'd be kind of keeping it in the database layer. And this entire stuff would be deployed to a server as a single block or as a single cohesive application. So this concept is called as monolithic application where everything of your application is kind of sitting in one server. Okay.
So what I mean by that is, so the front facing UI, UI is nothing but user interface or the actual website, right? So when you open IRCTC.co.10, the website that you see is nothing but the UI code. Okay. So the, and the API code, API is nothing but application programming interface. This is nothing but in order for you to kind of like, you know, fetch the data and show it to the user, you need to do some transformations on it. So that is done by this API. So if you guys are already familiar with the basics or Java, so I am sure that you will be able to recognize these terms for people who are kind of not comfortable with these terms.
Let's just quickly revise or summarize. What are these things? So essentially. Let's continue. We'll be right back. So when you develop any application, there are three fundamental parts to it, right? So one is the UI part, one is the API part, and one is the database part, okay? So all these three put together is what will be making your application, and this is common for any application. Whether you take Google, whether you take IRCTC, whether you take Uber, Rola, Swiggy, Zomato, like, you know, any of the day-to-day application that you use.
So what are all these terms? So user interface means, like, whenever you open any website or your mobile application, the data or the stuff that you see on your screen, right? So that is nothing but the user interface or the UI. So the code that you write to make the screen or make the user interface part is called your UI code, okay? And similarly, when you write this UI code, you, most of you would be performing some action, right? Say, for example, if you're opening IRCTC website, so what do you open your IRCTC website for?
Either you make a booking, you check a booking, you cancel a ticket, or you just want to kind of check what is the current status of a ticket, so on and so forth, right? So when you perform all those actions, what happens is, in the database, right? So database is nothing but this is just a storage where all the data is dumped for you, right? So this is the icon for database. So this essentially only contains all the data which is stored as a table or as a record, depending on the technology that is being used.
So what happens is, whenever the user performs any action over here, so say maybe like, say, he or she says, book a ticket. So what happens is, in your database, a new record gets created or inserted stating that, you know, this is the user ID, this is the passenger information, this is the train, this is the date, this is the payment made, and this is the kind of like, you know, the card used for making payment, so on and so forth. So all that record will be entered in the database, but this transaction from UI to database will not happen directly.
There is a layer in between, which can be called as the API layer or the service layer, like there are various terms for it. So the work of this API is to ensure that whatever request is coming from the UI, right, you kind of act on it, transform it, apply your business rules, any logics that you have. Say, for example, like, you know, you want to book a tatkal ticket, a tatkal ticket cannot be, like, you know, booked early in the morning or late in midnight.
Like, I'm just giving a hypothetical scenario. Or maybe, like, you know, you are opening your Swiggy application and you want to book some food, but what if the hotel itself is closed? So all this kind of business logic checks, validation is what the API will first do on whatever request is received from the UI or the user. And then it will check in the database whether it is a valid transaction which can be allowed. And if so, it will then, like, you know, allow that proceed that transaction to happen.
So in case, in this case, if it has to be a new ticket booking, it will allow this record to be entered in the database. If it is a new food ordering order, it will allow that order to be placed, so on and so forth. Similarly, if you want to even fetch some information from database, so say, for example, you want to see the list of all the tickets that were booked. So what happens is the user will make a call to the API. The API will then make a call to the DB.
The DB will return the data that is fetched. And the API, if required, will transform the data in a way that it becomes easy for the user to understand on the user interface and send that data back to the UI. So this, as you can see, is a two-way process. So the data will also, like, the request will also go from UI to API to DB and also vice versa. So it will also come back once you make a request, the data will flow back from database API and UI.
So this is how any application works irrespective of the architecture use or the technology use. So this is a high-level understanding of how an actual entire application works. OK, and the focus of our course, since this is going to be a microservice course, we are going to be focusing on this part, right, the API part. So what we are going to essentially do is we are going to cut off this part of, like, you know, just having this API and DB independently hosted as separate applications.
We'll first understand what is microservices in due course of time. But just to let you know that the focus of this course is going to be, like, you know, understand how we are going to create this API part and ensure that, you know, just talking with the database part and also, like, you know, kind of sending the request back to the user interface. Like, you know, once any request is made, we are not going to create any user front end user facing screens because that is out of outside the purview of this course.
But what we will definitely do is we will take up a real world example. What we will do is we will take an example of a bank. So you can just assume any bank that, you know, so maybe like SBI, City Bank, like, you know, any bank. So what we are going to do is in our course, we are going to create banking microservice application, which will be composed of multiple departments. So as you know, a bank has multiple departments. So what we will do is we will try to create microservice for this bank and then we will take it up and we will put it in a container.
So what is the container? Don't worry, we will be discussing on that and then we will be orchestrating this container. So what is the meaning of orchestrating is we will be kind of automating a few tasks and a few stuff configuration for this container so that, you know, our work, our job of maintaining this microservices become easy. And also we will be having a few more additional stuff added, like, for example, monitoring, self-healing and all that diagnostic and all that stuff. So what happens is as you kind of build your application, we will also take in the real world scenarios where we will try to understand how does that microservice applications actually kind of deployed into the cloud.
So we will be doing all that stuff together. Okay, so this was just a quick detour to understand how what is the application all about. So coming back to the types of various architectures. So first, we saw that it was on a high level. There are kind of three types of application architectures. So we saw that one is the tightly bound, one is the loosely bound, loosely coupled, and the third is like decoupled, right? So just also right coupled over here, so all these three together are nothing but your types of architecture, right?
So first, we saw what is a tightly bound, tightly coupled architecture. So for the example for that we saw is monolithic. So what we saw in the monolithic application is, as I said, you just take all your UI code, put it in one module, take all your API code, put it in one module. And you know, for this API, you also need to write, you know, kind of write a layer or a module which will be doing the work of communicating with the database. We normally call this layer as data access layer, okay?
So what we essentially do is, we take all this code together, okay, wrap it up as a single application and deploy it in a server as a single bundle. So this is nothing but monolithic application and then from the server, this application will be talking to a database, okay? So you can have a separate database that is all right. So what happens is, like, you know, in a monolithic application, since all these are tightly coupled or bundled together in a single code, whenever you try to make change to any one of these components, the other components will be definitely affected, okay?
So that is kind of like, you know, a feature characteristic of monolithic. But one advantage of having a monolithic application is that, you know, the development is faster because everything you're going to bundle it as a single application and it is tightly bound. So it is, the development would be kind of easier. You don't really need to bother about, like, you know, too many of network calls happening between each layer, so on and so forth. And also, there are fewer cross-cutting concerns. So what I mean by cross-cutting concern, okay?
So this is an important term which you should understand. So what is a cross-cutting concern is, any feature or characteristic which will be acting on all the three layers, which is UI, API, and also data, right? So say, for example, one aspect could be security, one other aspect could be latency, right? So what if I have to ensure that my application is secure? So in the monolithic kind of setup, you don't really need to worry too much because all your code is going to sit in a single server and as in a single module.