Full Stack Java — Skill Lab
What I Learned From 5 Days of Full Stack Java at BMSCE
For five days, from 21st to 25th September 2026, we had a hands-on Skill Lab on Full Stack Web Development in Java at BMSCE.
It was one of those sessions where you start with one technology and, by the end of the day, realise that there are a lot more pieces involved in building an actual web application.
The Skill Lab was organised by the Department of Artificial Intelligence & Data Science, BMSCE, and our sessions were conducted by Thanesh Sir.
We had around 27.5 hours of sessions across the five days, from 9:30 AM to 4:30 PM.
And honestly, the most useful part for me was not memorising another list of technologies.
It was understanding how everything connects.
Starting with the Frontend
We started with the basics of web development — HTML, CSS and JavaScript.
These are things we hear about very often when talking about web development, but working with them together gives a different understanding.
We also got introduced to Angular, including its component-based architecture, routing and forms.
We explored how components are structured, how routing works between different parts of an application, and how forms can be handled on the frontend.
We also worked with Bootstrap and looked at different UI elements and concepts such as carousels.
At first, there are a lot of new terms to keep track of. But once you start looking at the application as a collection of components and understand how they communicate, the structure starts making more sense.
This was probably one of the first times I started looking at frontend development as an actual system rather than just writing HTML and CSS to make a webpage.
Then Came the Backend
After the frontend, we moved towards the backend side using Java and Spring Boot.
This was probably one of the parts I was more interested in because I already had some familiarity with Java.
It was interesting to see how the Java concepts we normally learn can be used as part of a complete web application.
We went through backend architecture, dependencies and the basic structure of a Spring Boot application.
We also worked with different ports while running the applications, including 4200 for the Angular development server.
These may look like small details when reading about them, but when you actually run different parts of an application and something doesn’t work, you start understanding why these things matter.
Debugging also becomes a part of the learning.
Connecting It With a Database
Then we moved towards MySQL.
This completed another important part of the picture.
A web application isn’t just a webpage and some backend code. It usually needs somewhere to store and retrieve information.
So we looked at database connectivity and how data moves between the different parts of the application.
We also worked with JPA (Java Persistence API) and explored how it helps Java applications interact with databases.
This helped me understand the backend-to-database connection much better.
Instead of thinking about Java, Spring Boot and MySQL as completely separate technologies, I could start seeing how they work together.
A simplified version of the flow we explored was:
Frontend → Spring Boot → JPA → MySQL
and then the required data makes its way back through the backend to the frontend.
Before this, I had learned many of these technologies separately.
During the Skill Lab, I started seeing them as parts of the same system.
Working With Postman and Swagger
We also got hands-on with tools such as Postman and Swagger.
Postman was useful for testing the backend independently.
Instead of depending completely on the frontend to check whether something was working, we could directly interact with the backend and inspect the responses.
We also explored Swagger, which provides an interactive interface for understanding and testing the available backend operations.
These tools made the backend side feel much more practical.
They also showed me that development isn’t only about writing code.
Get Lochan Gowda T M’s stories in your inbox
Join Medium for free to get updates from this writer.
You need ways to test what you have built, understand the responses and figure out where something is going wrong.
Understanding the Bigger Picture
Another thing I found interesting was that we didn’t look at only one way of becoming a full-stack developer.
We were also introduced to different full-stack ecosystems such as:
- MEAN
- MERN
- Java Full Stack
- .NET Full Stack
- Python Full Stack
The technologies may change, but the fundamental idea remains similar — the frontend needs to communicate with the backend, the backend needs to handle the application logic and work with the database, and everything needs to come together to provide the required functionality to the user.
That was probably the biggest takeaway for me.
Instead of just asking, “What technology should I learn?”, it becomes more useful to ask, “Where does this technology fit in the overall application?”
More Than Just Learning Technologies
One thing I realised during these sessions is that knowing the names of technologies is very different from understanding how they work together.
You can know HTML, Java, Spring Boot, Angular, JPA and MySQL individually and still not have a clear picture of how a complete application is built.
The Skill Lab helped bridge that gap for me.
It wasn’t about becoming a full-stack developer in five days. That’s obviously not realistic.
It was about getting a proper starting point and understanding what happens behind a web application instead of only looking at one layer.
And that difference matters.
When you understand how the frontend, backend and database fit together, learning the individual technologies becomes more meaningful.
What Debugging Taught Me
Another thing that stood out during the week was debugging.
When you’re learning something from a tutorial, everything usually works because you’re following a predefined path.
When you’re actually working with multiple technologies together, that’s not always the case.
A configuration can be wrong.
A dependency can cause an issue.
The application may not be running on the expected port.
The database connection may not work as expected.
The frontend may not receive what you expected from the backend.
These are small things, but they force you to stop and understand what is actually happening.
For me, that was an important part of the learning experience.
It made the process feel much closer to actual development rather than simply following instructions.
Thanks to Thanesh Sir and BMSCE
A big thanks to Thanesh Sir for making the sessions practical and interactive.
The explanations were easier to follow because we were not just going through theory. We were actually working with the technologies, testing things and seeing how the different parts fit together.
Also, thanks to the Department of Artificial Intelligence & Data Science, BMSCE for organising the Skill Lab and giving us the opportunity to explore something outside the usual classroom learning.
What I Take Forward
For me, this week was a good reminder that learning development is not just about completing tutorials or knowing a programming language.
You have to build, break things, debug them, and understand why they work.
The Skill Lab gave me a better foundation to continue doing exactly that.
I wouldn’t say I came out of these five days as a full-stack developer.
But I definitely came out with a much clearer picture of what full-stack development actually looks like and where the different technologies fit.
There is still a lot more to learn, practise and build.
But now I have a better idea of where to start.
Learning → Building → Debugging → Understanding → Growing.
And now it’s time to actually use what we learned.
