From internship to production

What Working on a Production Application Taught Me About Software Engineering

From a dropdown bug that took two days to a workflow redesign, these are the experiences that changed how I learn, debug, and build software.

Nipul Yansith
Nipul Yansith

11 min read

When I started my journey as a software engineering intern, I had a few assumptions about what being a software engineer would be like.

I thought knowing programming languages and frameworks was one of the most important things. I also thought that if I didn't know a particular technology, adapting to a project that used it would be difficult.

But working on a production application changed quite a few of those assumptions.

I started with an internship, moved on to working as a Software Engineer, and got the opportunity to work on different parts of a real-world application. Along the way, I worked with unfamiliar codebases, implemented features, investigated bugs, dealt with unexpected behaviour, and learned from other engineers.

Looking back, some of the most valuable things I learned weren't about any particular programming language or framework.

Here are some of them.

You Don't Need to Know Every Technology Before Joining a Project

One of my biggest concerns when starting my internship was working with technologies I hadn't used before.

I had no previous experience with AngularJS. Initially, I thought that not knowing the framework would make things difficult.

Surprisingly, I became familiar with it within about a week.

I didn't spend most of that time reading documentation from beginning to end. Instead, I started exploring the existing codebase, reading functions, debugging simple pieces of functionality, and trying to understand what was happening behind the scenes.

That experience changed how I approached unfamiliar technologies.

I realized that when you understand the fundamentals of programming and software development, adapting to a new framework becomes much easier.

You don't necessarily need to know every framework before joining a team. You need to know how to learn, how to read code, and how to understand what an existing implementation is doing.

One thing I discovered during this process was that debugging made me a better code reader.

Debugging Is More Than Just Fixing Bugs

I still remember one of the first bugs I worked on during my internship.

It was a relatively simple UI issue. The requirement was to select the first option in a dropdown instead of leaving it unselected.

Sounds simple, right?

It took me almost two days just to understand where the issue was.

I remember starting with a JSP file, following the execution flow to identify the relevant controller, and then searching for the function responsible for the behaviour.

Eventually, I found the relevant implementation and fixed it.

Today, I would probably approach the same issue differently. I'd inspect the element, identify the relevant function, and use a global search to trace its implementation.

But that first experience taught me something important.

When working with an unfamiliar application, the challenge isn't always writing the solution. Sometimes, understanding where the problem actually exists is the hardest part.

I also developed an interest in debugging APIs. I enjoy following how data travels from the frontend to the backend, inspecting what gets passed at each stage, and identifying where something goes wrong.

Rather than immediately changing code, I find it much more useful to understand the execution flow first.

The more I worked with unfamiliar modules, the more comfortable I became with exploring code I hadn't written myself.

Working with an Existing Codebase Is Very Different from University Projects

University projects teach you a lot about software development. You learn how to build applications, implement requirements, work with databases, and collaborate with others.

However, working on an established production application introduces a different challenge.

In most university projects, you have a reasonable understanding of the entire codebase. You know what you implemented, how the modules connect, and why certain decisions were made.

In a professional environment, that's rarely the case.

You're working with an application that has evolved over time, with contributions from many developers. There are existing patterns, dependencies, business rules, and functionality that you might not even know exists.

A seemingly small modification can affect something that was already working perfectly.

I remember an interesting incident involving MongoDB during my internship.

I was working with a JSON configuration where the order of key-value pairs determined the order in which certain content appeared in the UI.

I needed to change that order, so I kept modifying the document in the database.

But nothing happened.

There were no errors, and the application wasn't behaving differently.

After spending quite some time investigating, I randomly started suspecting that the issue might be related to the database update mechanism. In that particular implementation, changing only the field order wasn't causing the document to be updated.

As a temporary workaround, I added a flag to make the document different, saved it with the correct ordering, and then removed the flag.

It was a small incident, but I remember it because it taught me something I wouldn't necessarily have learned from a university assignment.

Sometimes, the problem isn't where you initially expect it to be. You have to understand how the existing system behaves before deciding how to fix it.

Break Large Problems into Smaller Deliverables

One of the most challenging things I worked on was a major redesign of an existing workflow management feature.

The legacy implementation had a very large number of features. Looking at the amount of functionality that needed to be reimplemented was honestly overwhelming at first.

It was one of those situations where looking at the entire task at once could make you feel like you weren't going to finish it.

But I gradually realized that the most important thing was to approach it systematically.

Instead of thinking about the entire system as one enormous task, I started breaking it down.

The approach was to:

  • Understand the core workflow first.
  • Identify the essential functionality.
  • Implement the basic parts before moving to more complicated requirements.
  • Gradually introduce additional functionality based on priority.
  • Compare the new implementation against the existing system.
  • Work with QA to validate the behaviour.

This also helped make the redesign more manageable from a delivery perspective. Essential functionality could be tested and delivered before moving on to less critical parts, allowing users to transition gradually.

One thing this experience taught me is that engineering isn't always about finding the most complicated technical solution.

Sometimes, it's about understanding priorities and making a large problem manageable.

Breaking a complex task into smaller, deliverable pieces is an engineering skill in itself.

Before Reimplementing Something, Understand What It Actually Does

Another interesting experience was reimplementing an existing configuration management portal that had originally been built using vanilla JavaScript.

The task was to recreate its functionality using AngularJS.

Initially, looking at the amount of functionality made it seem like a huge task.

Instead of immediately starting to write AngularJS code, I spent time using the existing portal and exploring how it behaved.

I tried different interactions, observed what happened, and gradually built an understanding of the complete functionality.

Once I had a clearer picture, I started working on the new implementation.

This taught me an important lesson about working with existing applications.

Documentation and existing code are useful, but sometimes the best way to understand an application is to actually use it.

Before replacing or redesigning something, understand the behaviour you're trying to preserve.

Otherwise, you might successfully recreate what you think the application does while missing functionality that users already depend on.

AI Can Make You Faster, But It Shouldn't Make You Careless

This is something I think is particularly important for software engineers today.

When I started my internship, AI coding agents weren't part of my everyday development workflow. When I got stuck, I would Google errors, look through Stack Overflow, inspect the existing code, or ask senior developers for help.

Today, I also use AI when I get stuck.

There's no doubt that these tools can make development faster. They can help us understand unfamiliar code, explore possible solutions, and implement things more efficiently.

However, I've also noticed something concerning.

Sometimes developers ask AI to make a UI look better or improve an implementation without clearly understanding what they actually want.

The results might look impressive initially, but that doesn't mean they're necessarily good solutions.

For example, asking an AI tool to "make this UI better" is very different from understanding what needs improvement and explaining the expected behaviour, layout, and constraints clearly.

You need to understand the problem before you can give it good instructions.

And more importantly, you need to understand the code that comes back.

That has made me more deliberate about reviewing AI-generated implementations before accepting them.

We're working with production software. We cannot simply generate code, glance at the output, and push it without understanding what we're shipping.

AI-generated code can contain bugs, introduce unnecessary complexity, or solve the wrong problem entirely.

My personal philosophy is simple:

AI should help developers build better, more reliable, and scalable software. It shouldn't help us produce software that even we don't understand.

Use AI as a tool. Don't trust it blindly. The responsibility for the code you ship still belongs to you.

Good Senior Engineers Can Make a Huge Difference

Something else I learned during my professional journey is how important the people you work with can be.

Helpful senior engineers are just as important as having access to a good AI model. Maybe even more important.

A good senior doesn't just give you the answer to a problem. They help you understand how to approach it.

They give you opportunities to explore different areas of the application, work with unfamiliar technologies, make mistakes, and learn from those experiences.

I believe this is particularly important for junior developers.

You cannot learn everything through documentation. At some point, you need hands-on experience.

You need the opportunity to experiment, investigate, and sometimes get things wrong.

Of course, this doesn't mean you should expect someone else to solve every problem for you. You should make an effort to investigate things independently before asking for help.

But having experienced people who are willing to guide you makes a huge difference in how quickly you grow.

Code Reviews Can Change the Way You Write Code

I used to think that if my implementation worked, I had done my job.

Code reviews taught me that there's more to writing good code than simply making something work.

I still remember having pull requests rejected because they didn't follow the expected coding standards.

Initially, it was frustrating. But over time, I started paying more attention to the feedback.

I began checking my implementations more carefully before pushing them for review.

I became more conscious of coding conventions, consistency, readability, and maintainability.

Eventually, I went from submitting code and waiting for someone to point out issues to trying to catch those issues myself before creating the pull request.

That change made me a much more careful developer.

I also realized that code reviews aren't just about approving or rejecting someone's work. They're an opportunity to learn different approaches and improve the quality of what we build as a team.

Communication and Teamwork Matter More Than You Think

Before joining the professional environment, I thought being a software engineer would be an extremely stressful job.

There are deadlines, technical challenges, complicated requirements, and situations where things don't go as planned.

But something I didn't fully appreciate beforehand was how much the people around you influence the experience.

Having good teammates makes a huge difference.

Being able to ask questions, communicate blockers, clarify requirements, share ideas, and even have fun together makes the work much more enjoyable.

In some ways, working on a professional software project isn't entirely different from working on a university group project.

You still need to communicate with people, understand what others are doing, ask for help when necessary, and make sure everyone is moving in the same direction.

Technical skills are important, but being able to work effectively with other people is equally valuable.

I'm grateful for the people I've had the opportunity to learn and work with along the way.

Teammates together during a casual beach outing
Some of the people who made this journey more enjoyable.

You Should Always Be Willing to Learn

If there's one thing that connects almost everything I've mentioned, it's the willingness to learn.

I started my internship thinking that not knowing a particular framework could be a major disadvantage.

Now, I'm much more comfortable exploring unfamiliar projects and technologies.

I've learned that you don't have to understand everything immediately. You need to be willing to investigate, experiment, ask questions, and gradually build your understanding.

If I were to give three pieces of advice to someone preparing for their first software engineering job, they would be:

1. Build strong fundamentals, but don't become attached to a particular technology.

Frameworks and tools change. Understanding programming concepts and knowing how to adapt to unfamiliar technologies will help you throughout your career.

2. Learn to debug and explore existing code.

Don't always look for someone to give you the solution. Follow execution flows, inspect API requests, read unfamiliar functions, experiment, and understand why something works the way it does.

3. Be curious, accept feedback, and take responsibility for what you build.

Learn from experienced engineers, take code reviews seriously, communicate with your teammates, and use AI responsibly. Never submit code that you don't understand.

Final Thoughts

Looking back, working on production applications has changed the way I think about software engineering.

I used to associate being a good developer with knowing programming languages and being able to implement features.

Today, I think it's much more than that.

It's about being able to understand unfamiliar systems, investigate problems, make thoughtful decisions, work with other people, and take responsibility for the software you build.

You won't always know the answer. You won't always understand the codebase immediately. Sometimes, even a seemingly simple bug can take two days to figure out.

And that's okay.

Every unfamiliar project, every debugging session, every code review, and every challenging feature gives you an opportunity to improve.

I'm still learning, and I have a long way to go. But that's probably one of the things I enjoy most about this profession.

You never really stop learning, and that's what makes software engineering interesting.

This article reflects my personal experiences and lessons learned while working on production software. Specific company, client, and internal implementation details have intentionally been omitted.

Written by

Nipul Yansith

Software Engineer. Still learning, still building.

More about me