5 Quick tips to succeed in your first developer internship

A quick guide on how to maximize your success as an intern, based on my recent experience.

Hi friends! Welcome back to another blog post. Over the past four months, I got the chance to work my first web development internship. From this experience, I gained a good feel for the types of skills you need to succeed in this environment through my successes and shortcomings. In this post, I hope to share 5 quick tips from the almighty power of hindsight so you too can do well (or better than me) in your first internship. If these sorts of things interest you, be sure to follow me on HashNode or subscribe to my newsletter to be notified of future posts.

Tip 1: Be persistent and persevere

This is the most important point to be made here. I can attribute much of my success to my determination to get things done which was the quality I was most recognized for. While you will likely be inexperienced and lacking the knowledge and intuition of a more seasoned developer, one thing you can always be on par with or better than others at is working damn hard. Furthermore, because of this lack of experience, how hard you hustle or how hungry you are to get things done is what I feel will have to stand out the most. Assuming you’re around the same level as me, you’ll most likely fumble here and there which is alright and expected from a newbie; worrying too much there can only make you second guess yourself too much and paralyze you. Instead, focus more on what you can control the most: how hard you work, and use it to pick yourself up and persevere through these challenges. Not only that, but you’ll certainly face some unholy bugs here and there that will be a test of your resolve (and also your sanity).

Tip 2: Learn to interpret existing code well

Another skill that helped me succeed was my ability to interpret existing code. Whether you’re debugging or adding enhancements to the application, this skill is critical, especially early on. When it comes to debugging, you’ll need to trace the underlying flow of effected parts of the program so being able to effectively understand it is critical. Even in adding enhancements, you need to understand how similar functionalities were implemented and the existing modules you could use for that feature. In fact, every task I was assigned required me to interpret existing code in one way or another.

Tip 3: Don’t be afraid to ask questions

While this may seem obvious, many people, including myself occasionally, need this lesson. It can feel a little scary at times doing this because of the perception that you’ll be annoying to them. However, as long as you have a legitimate question and are respectful of their time and boundaries, you’d be surprised by how willing others are to lend a hand. Of course, there is a balance to be struck where you need to be sure that it’s not something you can easily find on your own. Even still, you can’t deny yourself from using any resources at your disposal for the job. In fact, the experience of others would be among your most valuable resources, especially as an intern.

Tip 4: Hone in on your debugging skills

Debugging code is arguably the most important skill for a software developer. Other than death and taxes, software having bugs is an unavoidable part of life that you need to accept. No matter how good your QA team is or how thoroughly you test your code, the bad news is that something will go wrong. Hell, even while you are implementing a new feature, I’m willing to bet you’ll stumble upon a problem along the way (unless of course, it's a hello world program). Thus, your ability to debug code will make you a huge asset as a programmer. Moreover, based on what I’ve seen and heard, debugging code will be a larger responsibility for a junior developer so be sure to work on those skills. I could probably write a whole other blog post on debugging code (and maybe I will) but I’ll just leave you with some of the main points.

To start, you need to reproduce the bug as closely as possible yourself. Find the steps and conditions to reproduce the problem and ideally do so in the development environment where you’ll have more tools at your disposal to fix it. This is easily the most fundamental step because through this, you can start to understand where in the codebase the problem manifests and trace the related logic.

As context for those who don’t know, software teams will have separate environments for/copies of the application. Typically, you’ll hear of a development and production environment (there are more but this is for simplicity). The development environment represents an environment you use while developing code, and production environments are what the clients will see.

From there, as I already briefly touched upon, you need to trace through the code involved in this bug. In doing so, be sure to understand and appropriately use all the tools you have at your disposal, whether it be logs, documentation, debuggers, browser developer tools, etc. If you haven’t been able to reproduce the problem in the development environment, it can be impossible to trace it. In this case, I would analyze the problem and nature of the bug as closely as possible using whatever tools I have. With whatever findings I got, I would develop a theory on the possible cause of the problem and attempt a fix from there.

Tip 5: See the bigger picture

As a final and highly important tip, I leave you with the simple idea of seeing the bigger picture. This is something that I struggled with and was told about by my supervisor as being perhaps my biggest weakness. As a junior developer working on a new codebase larger than anything I’ve worked with, it was difficult to see how everything clicked and functioned together as a whole (and understandably so). This can be a problem in that you may end up making changes that affect unintended parts of the codebase which can lead to new bugs. In fact, I saw this happen firsthand with some code I wrote leading to bugs later down the line. The moral of the story is that you need to be careful and understand the scope of your changes before you commit to them. Try to look and see where else your changes might affect the code and if those changes won’t lead to unintended consequences. Always err on the side of caution when it comes to these things, avoiding any assumptions and trying to isolate your changes to only be for the problem at hand.


With that, I hope to have given you some key points on how you can be best equipped for your first tech internship. Using these ideas, I’ve managed to make a fairly large impact where I could, and through other ideas mentioned here, you can avoid some of the pitfalls I fell into. If you have any tips of your own that you want to share, feel free to mention them in the comments below. And with that, I wish you all the best in tackling that first internship. Have fun and give it your all!

If you like what you read, consider subscribing to my newsletter or following me on Hashnode to be notified of new blog posts. Also, check out my programming tutorials here.