Lessons learned as an entry-level software engineer


If you had asked me a year ago what a software engineer did, I would have said something like “solving problems with code”. It’s a simple answer that indicates how the work we produce is evaluated. For engineers on product-focused teams, these issues might include how to implement a new feature requested by customers or how to improve the performance of existing features.

If you asked me the same question today, I would give a slightly different answer. Software engineers are responsible for solving good problems through code, and when solved effectively, they achieve business goals. Figuring out what problems to solve and how to solve them is the most important part of being a developer, the actual implementation details being secondary.

My Journey to Software Engineering

I became interested in programming after taking a course at Upperline Code the summer before my freshman year of college. I got this opportunity through a college and career readiness program I was part of called The Opportunity Network.

Upperline Code was my first introduction to programming, and I quickly realized I was interested in learning to code. Later that summer, I received my Notre Dame enrollment package and transferred from the College of Arts and Letters to the College of Engineering so that I could major in Computer Science (CS).

Some of my favorite CS courses were Algorithm Design/Analysis, Cloud Computing, and Programming Challenges. The problems were interesting and the teachers were excellent at presenting new ideas and explaining concepts.

Throughout undergrad, I knew I wanted to work as a software engineer and use the technical skills I had learned. Luckily, the summer before my senior year, I had the opportunity to intern as a software engineer at Kantata and pair-program with other engineers to help deliver functionality.

My internship experience, along with the pep talks from my professors, gave me the confidence to not settle for another role when I started applying for jobs. After spending a lot of time in office hours, I graduated with a degree in Computer Science in 2021 and accepted an offer to become an Associate Software Engineer at Sprout Social.

Settling into Sprout Social

Part of being new to the role and new to the company was developing both general software engineering skills and Sprout-specific domain knowledge. I found that tasks that required general programming knowledge to understand were the easiest for me to solve. However, tasks that required knowledge of Sprout’s architecture took me a long time and I had to rely on my team for help. While there are some issues you can solve by reading the online documentation, you can’t always find information that’s relevant to the work you’re doing – being able to seek advice from others is crucial.

One of the first things that struck me when I joined Sprout was how collaborative the development process is. I knew it took entire teams to develop features, but I didn’t know what it looked like in practice. I quickly realized that releasing a successful feature required the collaboration of many people in different roles, from product managers defining project requirements to designers creating mockups and engineers implementing features. Collaboration was not something optional, but a necessity to achieve our team’s goals.

Photo of co-workers Julius Boating and Sprout in front of Calder's flamingo statue in downtown Chicago

Learning to navigate the different codebases and building a mental model of how the different services interact with each other was a steep learning curve. Since Sprout’s core business is software, its architecture is heavily shaped by its business needs. As I scaled up, I had to be aware of the business issues the developers were trying to solve and why previous architectural decisions were made.

Initially, I was a little intimidated by the fact that pull requests required revisions before they could be merged into the codebase. Understanding that the primary purpose of code reviews is knowledge sharing and maintaining code standards helped me change my perspective.

Going through code reviews allowed me to sharpen my technical skills and improve the quality of my pull requests. Having peers give me advice on what to change, introduce me to new patterns, and point me to relevant areas of the codebase has been very helpful. Reading other engineers’ pull requests has also given me valuable visibility into other services that I don’t work on directly.

Your previous experiences matter

There is a prevailing idea that as you enter new stages in life, your past experiences no longer matter. Once you get into college, your high school experiences don’t matter. Once you enter the job market, your college experiences no longer matter.

But something that is often overlooked is that our experiences, knowledge, and habits have a cumulative effect. We can usually only achieve new things because of the work we have done before. The knowledge and skills I acquired previously greatly influenced my approach to new challenges as an entry-level software engineer.

The undergraduate courses that had the most direct impact on my day-to-day work at Sprout were Programming Challenges and Database Concepts. The first taught me how to break big problems down into smaller pieces to solve them more effectively. It helped me become more intentional about how I structured my code and improved my code readability.

Database Concepts taught me fundamental relational database concepts and covered topics such as database schema design and SQL. I learned how to write queries, which was extremely useful to me since I frequently need to query our databases to solve problems or answer questions.

Animated gif of a TurtleBot robot kit.

The opportunities I had outside of the classroom were just as valuable. Java was not a language covered in most of my courses, however I had the opportunity to work on it for a business project led by one of my professors. I gained hands-on experience writing Java, working with MySQL databases, and building Docker images. Learning Java was especially helpful because most of Sprout’s services are written in it.

There are many other skills I learned during my undergraduate studies that I take for granted, such as navigating the command line and understanding basic programming concepts. It’s a common misconception that since most undergraduate topics are theoretical in nature, they won’t prepare you for careers in software engineering. However, I believe the opposite is true – the skills you learn in undergrad are important, even if they are not directly applicable to your day-to-day work.

Computer science is an extremely broad field.

CS covers a variety of specializations such as artificial intelligence, machine learning, and data science. The experience you gain at the undergraduate level serves as foundational knowledge that can serve you well in a variety of entry-level roles not exclusive to software engineering. Moving from an undergraduate to a full-time position provides an opportunity to explore the type of role and specialty that suits you best.

If you’re looking to start a career in software engineering, Sprout is a great place to start.


Comments are closed.