/You can understand what a REST API is.

You can learn what a controller does.

You can watch someone create a Spring Boot application.

But the real learning starts when you have to sit down and build something yourself.

That is one of the biggest things I experienced during my Infosys Springboard internship journey.

In this post, I want to share my experience with Infosys Springboard, what I learned, how Spring Boot became an important part of my learning journey, and how the experience eventually connected with one of my projects, MediStock - A Medical Inventory Management System.

Github Repo :- https://github.com/aryanvatsaa/MediStock

How I Came Across Infosys Springboard

I saw a post on Linkedin announcing the starting of Infosys Springboard.

Infosys Springboard is designed as a digital learning platform with courses covering technology, emerging technologies, digital skills and life skills. It is also aimed at making quality learning resources accessible to students and lifelong learners.

It was the opportunity to learn in a more structured environment and explore technologies that were relevant to the direction I wanted to take as a developer.

Starting My Journey

At this stage of my learning, I was becoming increasingly interested in backend development.

I had already worked with web development and had experience with technologies such as React, but I wanted to understand what was happening behind the frontend.

How does a backend handle requests? How are APIs designed? How does a Java application communicate with a database? How are different parts of an application connected?

And most importantly:

How do you actually build a backend application instead of just learning backend terminology?

This is where Spring Boot became particularly important for me.

Spring Boot gave me a practical way to work with Java on the backend and start understanding how real backend applications are structured.

Learning Spring Boot

One of the most valuable parts of my journey was getting more comfortable with Spring Boot.

Before working seriously with it, concepts like controllers, services, repositories, entities and APIs could feel like separate pieces.

While learning and implementing them, I started understanding how those pieces fit together.

I began working with basics concepts such as:

• Spring Boot application structure

• REST APIs

• Controllers

• Services

• Repositories

• Entity classes

• Database integration

• CRUD operations

• Request and response handling

• Dependency injection

• Backend application architecture

The important thing for me wasn't memorizing these concepts.

It was understanding why they exist and where they belong in an application.

That's when the concepts start becoming real.

From Tutorials to Implementation

One thing I gradually realized was that following a tutorial and building your own application are completely different experiences.

While following a tutorial, everything is usually predictable.

The instructor already knows everything when and what things need to be created and connected.

When you build something yourself, none of that is guaranteed. You have to make decisions, you have to debug, You have to search for errors.

Sometimes an error message makes sense, Sometimes it absolutely doesn't.

And sometimes the problem is something as simple as a configuration mistake that takes an hour to find.

That was one of the most useful parts of my learning experience.

I started becoming more comfortable with the process of figuring things out.

Building with What I Learned

The Spring Boot knowledge I gained eventually became useful while working on my project, MediStock.

MediStock is a medicine and inventory management system that I worked on as a practical project.

Rather than treating everything I had learned as isolated concepts, I could use those concepts while thinking about an actual application.

For example, the system involved different users and roles, medicine inventory, suppliers, purchase orders, notifications and other application workflows.

One feature I worked with was expiry management. Medicines approaching expiry or already expired needed to be identified, and notifications could be sent to the relevant users.

Similarly, low-stock medicines needed to generate notifications.

These kinds of requirements made backend development feel much more meaningful.

Instead of thinking:

I'm learning Spring Boot.

I started thinking:

How should I implement this feature?

Understanding Backend Architecture

The general flow started making more sense to me:

Client → Controller → Service → Repository → Database

Of course, real applications can become much more complex than this, but understanding this basic structure gave me a much better foundation for backend development.

It also made me more comfortable reading other Spring Boot projects.

The Importance of Debugging

If there is one skill that every developer eventually learns, it is debugging. And I definitely experienced that.

Things don't always work the first time. An API may return an unexpected response.

A database operation may fail. An entity relationship may not behave the way you expected. A configuration may be incorrect.

Sometimes the application runs perfectly until you change one small thing. Then everything breaks.

Initially, errors can feel frustrating. But over time, I started looking at them differently. Instead of thinking:

Why isn't this working?

I started asking:

What exactly is the application telling me?

That small change in approach made debugging much more productive.

I learned to read error messages more carefully, trace where an issue was occurring and investigate the actual cause instead of randomly changing code.

Learning Beyond Technical Skills

Another part of my Infosys Springboard experience that I don't want to overlook is the importance of communication and professional skills.

As developers, we often focus heavily on technical skills.

Java.

Python.

Spring Boot.

React.

Databases.

Git.

Docker.

AI.

etc

But software development is rarely done completely alone. You need to explain your ideas. You need to communicate problems. You need to understand requirements. You need to ask questions. You need to present your work. You need to collaborate with other people.

Infosys Springboard itself includes learning resources beyond purely technical subjects, including communication and other professional or life skills.

For me, this was a useful reminder that becoming a developer isn't only about learning more technologies.

It's also about becoming better at working with people and communicating what you're building.

What I Learned from the Internship

If I had to summarize my learning from the Infosys Springboard internship, I would divide it into a few major areas.

1. Technical Understanding

I became more comfortable with backend development and Spring Boot.

I gained a better understanding of how different backend components interact and how APIs connect application logic with data.

2. Practical Implementation

I learned that knowing a concept isn't enough.

You need to implement it, break it, debug it and improve it.

That's where real understanding develops.

3. Problem Solving

Development involves constantly solving problems. Sometimes you know the solution. Sometimes you have to research it. And sometimes you have to experiment until you understand what's happening.

The ability to investigate a problem became just as important as knowing the technology.

4. Communication

Technical knowledge becomes much more useful when you can explain what you've built and why you built it that way.

This is something I want to continue improving.

5. Confidence

Perhaps the biggest personal improvement was confidence.

Not the confidence of thinking that I know everything. Rather, the confidence of knowing that if I don't know something, I can learn it and figure it out.

That is a much more useful kind of confidence as a developer.

My Biggest Takeaway

Before this journey, I mostly looked at technologies individually.

Java was one thing. Spring Boot was another. Databases were another. Git was another.

But building projects gradually changed that perspective.

Software development isn't really about knowing isolated technologies. It's about understanding how those technologies work together to solve a problem.

That's something I started understanding more clearly through my Spring Boot learning and project work.

Where I Am Going Next

Learning backend development has made me more curious about what comes next.

I'm currently interested in expanding my knowledge across areas such as:

• Backend development

• Docker and containerization

• Databases

• APIs and system design

• Python

• Artificial intelligence

• AI agents

• Cloud technologies

I've already started exploring Docker and Python, and I'm also becoming increasingly interested in AI and AI agents.

The goal isn't to learn every technology at once.

Instead, I want to build a strong foundation and gradually learn technologies that help me build better projects.

Final Thoughts

My Infosys Springboard internship was more than just another item on my learning journey.

It helped me move a little further from "I am learning this technology" toward "I can use this technology to build something."

And I think that transition is one of the most important stages for any student developer.

I still have a lot to learn.

There are technologies I haven't explored yet, concepts I don't fully understand and plenty of mistakes I'll probably make along the way.

But that's also what makes development interesting.

Every project gives you new problems. Every problem teaches you something. And every new skill opens the door to another area of learning.

For me, Infosys Springboard was one of those doors.

It gave me an opportunity to explore backend development, work with Spring Boot, apply what I learned to a real project like MediStock, and understand that becoming a developer is not about knowing everything.

It's about being willing to keep learning, keep building, and keep improving.

And that's exactly what I plan to do.

Thanks for reading!

If you're also a student learning development, I'd love to hear about your experience.