My first real software engineering internship was at Galaxy Software Services in Taiwan during the summer of 2021. I was tasked with developing a Personal Financial Audit System for Fubon Bank using the ASP.NET MVC framework. Looking back, this project taught me more about professional software development than any course ever could.

The Project

The system was designed to help bank customers track and audit their financial transactions. Think of it as an internal tool for financial advisors to review customer accounts, identify anomalies, and generate audit reports.

This wasn’t a toy project—it was going to be used by actual bank employees with real customer data. That responsibility made everything feel different from school projects.

The Stack

• Backend: C# with ASP.NET MVC
• Database: Oracle SQL
• Frontend: Kendo UI components with jQuery
• Architecture: Traditional MVC pattern with clear separation of concerns

At the time, ASP.NET MVC felt like a massive framework with a steep learning curve. Model binding, routing, Razor views, Entity Framework—there was a lot to wrap my head around.

What I Built

Over the course of the internship, I:

1. Developed the core financial audit system - Built out the backend services for transaction queries, audit rule engines, and report generation
2. Implemented 15+ new features - Everything from search filters to data export functionality
3. Created responsive frontends with Kendo UI - This was my first time working with a commercial UI library, and it was both powerful and frustrating (documentation was… interesting)
4. Wrote unit tests for API functionality - Learning to write testable code from the start was invaluable

Challenges I Faced

Learning C# and .NET on the Job

I had some C# experience from school, but building a real application was different. I had to learn:

• Dependency injection and IoC containers
• Entity Framework and LINQ queries
• ASP.NET MVC conventions and routing
• Authentication and authorization patterns

My mentor at Galaxy was patient, but there’s no substitute for diving into documentation and Stack Overflow at midnight when you’re stuck.

Working with Oracle SQL

This was my first time using Oracle SQL instead of MySQL or SQL Server. The syntax differences were subtle but important. Stored procedures, sequences, and Oracle-specific query optimizations took time to understand.

I learned to appreciate database design during this internship. A well-designed schema makes everything easier. A poorly designed one makes every query painful.

Understanding Banking Domain Logic

Financial systems have rules that don’t exist in typical CRUD apps:

• Transactions need to be atomic and traceable
• Audit trails are mandatory (you can’t just delete records)
• Data validation is critical (one decimal place error = big problems)
• Security isn’t optional (we’re dealing with people’s money)

This taught me that software engineering isn’t just about code—it’s about understanding the domain you’re working in.

What Went Well

The ASP.NET MVC Framework - Once I got over the learning curve, I appreciated how opinionated it was. Convention over configuration meant less decision fatigue and more consistency.

Kendo UI - Despite the documentation challenges, Kendo components saved a ton of time. Building those grids and charts from scratch would have taken weeks.

Unit Testing - Writing tests for each API endpoint seemed tedious at first, but it caught bugs before they hit QA. It also made me write more modular, testable code.

Mentorship - Having a senior developer review my code and explain why certain patterns existed was invaluable. Code reviews weren’t just about catching bugs; they were learning opportunities.

What I Learned

1. Professional Code Is Different

In school, if your code works, you’re done. In production, working code is just the baseline. You also need:

• Error handling
• Logging
• Security considerations
• Performance optimization
• Maintainability

2. Reading Code > Writing Code

I spent more time reading existing code than writing new code. Understanding how the system worked before adding features was essential. This taught me to write code that others can understand.

3. Testing Isn’t Optional

I learned to write unit tests for API endpoints. At first, it felt like extra work. Then I refactored something and the tests caught three bugs I would have missed. Sold.

4. Communication Matters

When I didn’t understand a requirement, I had to ask. When I hit a roadblock, I had to communicate it early. When I made a mistake, I had to own it. Professional software development is collaborative, not solitary.

The Impact

By the end of the internship, I had:

• Delivered a functional financial audit system
• Implemented 15+ features that made it into production
• Learned to work with enterprise frameworks and commercial tools
• Gained confidence that I could build real software, not just school projects

More importantly, I learned what I didn’t know. That list was long, but at least now I knew what to focus on.

Reflections

Looking back, this internship set the foundation for everything that came after—the IBM role, the Meta internship, and my current grad studies. It taught me:

• How professional software is structured
• Why architecture and patterns matter
• The importance of testing and documentation
• How to work on a team with code reviews and sprints

If you’re a student looking for your first internship, don’t worry too much about having the perfect skillset. What matters more is your ability to learn quickly, ask good questions, and deliver on your commitments.

My first internship wasn’t glamorous—it was a lot of reading docs, debugging, and rewriting code after review. But it was real, and that made all the difference.

Tech Stack: C#, ASP.NET MVC, Oracle SQL, Kendo UI, jQuery
Duration: January 2021 - June 2021
Company: Galaxy Software Services (Taiwan)