Helping your Interns / Juniors grow

12 April 2021 ยท Updated 12 August 2022

I consider this topic very important for everyone working in IT and even those that are currently interns, because eventually you will become Senior Developers and will need to nurture your own interns.

There are few things in the world of software development that have such a huge ROI as nurturing your interns to be the best possible engineers possible. While this goal is not achieved with every intern, I think it is the job of the manager (or the Team Lead) to bring out the best qualities in them and improve those qualities.

Over the years, I've had some interns that exceeded my expectation as well as those that didnโ€™t due to being unmotivated. Usually, the main difference between those two types was, that the former type had some sort of passion for programming. And that's currently my rule of thumb - if I see that a person lights up when he's talking about programming (e.g. some cool stuff he has built over the summer/weekend) - he's probably going to be a good developer in 2-3 years.

Nonetheless, every intern needs to be taught and nurtured. Here are some rules that I developed during my years that I'd like to share.


Pay them

This goes without saying, I never believed in unpaid internships. An intern is an asset with unlimited potential, so investing time and money into their future is a no-brainer.

Don't hire just anyone

Interns might not have much knowledge, but that doesn't mean they need to be hired differently than other employees. They still need to be tested for a cultural fit and for the adequacy. Furthermore, try to hire interns when you have projects for them to work on, there's nothing worse than an intern coming in and having nothing to work on.

Increase the complexity progressively

This is the easiest thing to do, and also the most important one as I see it; the tasks that are given to an intern always need to be just a tiny bit harder than what he can currently manage. As a very basic example consider this: Your intern successfully wrote some script last week to do some aggregation, as a next task you might consider asking him to improve the solution with raw SQL, or add concurrency/parallelism, or implement it as CLI Tool. This keeps them on their feet as they browse StackOverflow trying to find a solution.

We all know how hard programming is at the start, so it's better to battle against many small challenges, increasing the difficulty over time, rather than only few big ones.

Stupid questions are acceptable. Once.

The policy that I try to enforce is that you can come up to me with any question, regardless of how dumb you think it might be, I will try to answer as thorough as I can or at least give some pointers. But this can happen only once per question, so if a week later a person comes up to me with the same question, I will tell him to try and find the answer himself.

Get the entire team involved in identifying and evaluating project risks. Everyone looks at the project differently, and sometimes the input from the student intern can be vital.

This has worked quite nicely over the years, because people started to really try and remember the answers and write them down if necessary. (Although usually the answers are in Slack, so it's even easier to go back and reread them)

Giving problems from different domains

It's important to let them have a taste of problems from different domains. This serves two purposes, the first one being - broadening their problem-solving spectrum. This is useful because it's possible that in the future they will end up in a situation where they will need to have some basic knowledge of some random domain. The more domains the person has "tasted" as an intern the easier it will be for them to adapt later.

The second reason is - they may end up liking that domain even more than they do their current one. This is self-explanatory, as the intern doesn't have many experiences, he may suddenly find a passion for something different.

A well-rounded experience is the most important asset for the interns future career.

As an example, consider this scenario: An intern working in the Frontend that has zero knowledge about the Backend - it's probably wise to let them fix some bugs in the Backend, even though it would take them more time. Or maybe give them some tasks from the DevOps for them to understand how the whole CI/Deployment looks like etc.

Teaching them standards

It's important to teach good standards from the start. Good standards result in good habits and good habits eventually lead to good quality code. The earlier a person develops some of those habits the better.

Good habits formed at youth make all the difference

It's far harder to try and get rid of bad habits than it is to develop good ones, so enforce standards as much as possible, even when the intern complains and doesn't really understand why they are so important. It will definitely benefit them. As an example of some of these good habits: Terminal usage as much as possible, reading documentation/comments before trying to use a library, rebase instead of merge, DRY and KISS principles, limiting function size, tests etc.

Working on their Soft Skills

In my opinion having good communication skills is as important as having technical skills. Some interns may think that their academic achievements are the most crucial part of their work success, but that's not the case. You will probably need to teach them the opposite. The idea of being a loner and coding in your cubicle for hours on end without interacting with anyone doesn't work nowadays.
This means you need to start teaching them good communication - translating ideas into words and conveying complex information in an understandable way. This is important not only inside your team but with other departments also.

Giving them freedom and holding them accountable

Although some interns truly need to be managed constantly (e.g. micro-managing), most people are able to complete simple tasks on their own and take responsibility for them.

He that is good for making excuses is seldom good for anything else.

Not even interns enjoy when someone is constantly looking over their shoulder. Let them work autonomously, but have an agreement that if the intern is stuck for more than several hours on a single problem he should come to you or ask for help from someone else.

Allow them to fail

You need to take into account that most likely, they will fail and make mistakes a lot.
Several years back I read a story about an intern who dropped a production database and the supervisor got really mad about the whole situation and the intern was fired.

Here's the original Story

I do understand the position of the manager, it's a pretty tough situation to be in, but the responsibility is 100% on the supervisor and not on the intern.
There should never be a possibility for the intern to fail so spectacularly, they need to work in a controlled environment.

Experience is the name every programmer gives to their mistakes.

Rules for software Interns

Pair programming

This topic is always up for debate and people will have their preferences, but I think this can be a really productive thing. Allow the intern to be the driver, while you observe their thought process and guide it. Over time this will help them see the patterns on their own. Another bonus of this exercise is that the intern can't get distracted by Whatsapp or reddit while you're sitting there with them, so they are more concentrated.

Tech Talks, Books, etc

There are so many good tech talks on youtube, that it's important to share them with your interns. Otherwise, you're losing an extra source of knowledge for them. I would suggest having a list of must-views and must-reads for the programming language of your teamโ€™s choice. You can then have some Fun-Fridays where you watch those Tech Talks together or maybe some of your Senior engineers can hold their own internal tech talks (depending on the size of your company and the resources available)

Teach other people to be good mentors

As crazy as it sounds, not everyone is aware of how to be a good role model for interns. An overall cross-company guide with links to resources where one can learn how to be a good mentor is a very nice thing to have.

Regular 1 on 1 Meetings

You need to catch the blockers early, so a bi-weekly meeting with an intern about their progress is necessary. The usual questions include:

  • What did you do since our last meeting?
  • Did you have any problems during that time?
  • What do you need to improve your stay at the company?
  • What were the highlights/low points of your week?

Constantly improve your internship program

After the intern finishes his internship it's important to ask the critical questions:

  • What would you like to have known before the internship started?
  • Did you accomplish what you wanted to with this internship?
  • What was the most beneficial experience for you?
  • What would you have done differently?


In conclusion, I want to say, that the first internship a person has, has a huge impact on their later life. It's important to make it a good one, let them have fun, let them explore, let them find their passion, and don't make them stress too much as otherwise, they may reconsider their career choice and we really don't have enough developers in the world to allow that to happen.

Do you remember your first internship? If you think I missed any points, or you just want to talk about the topic, send me an email.

Thanks for reading! Here are some things I think you might like:

  • Felix

    Intern pay ensures mutual respect and motivates both parties to invest in the internship genuinely. In my experience, regular code reviews are crucial. They not only improve code quality but also offer a platform for continuous learning for interns. Code reviews expose hired interns to best practices and alternative solutions they might not encounter otherwise.

  • Nate York

    I’ve always believed that compensation is crucial for the value they bring, not to mention it’s just the right thing to do. Your emphasis on increasing complexity of tasks progressively is spot onโ€”it fosters growth without overwhelming them. I’ve seen firsthand how tailored challenges can spark an intern’s confidence and skills. It might also be worth exploring how remote work has impacted internships. I’ve noticed it requires a different approach to mentorship and collaboration, making clear communication more important than ever.

  • Sky

    Implementing a gradual increase in task complexity for interns truly optimizes their learning and development in the tech industry. This strategy effectively balances the challenge and support needed to foster skill growth without causing burnout. Additionally, incorporating immediate, constructive feedback significantly enhances their learning process, ensuring they can apply corrections and advice in real-time. Engaging interns in discussions around tech talks and literature not only deepens their technical knowledge but also boosts their ability to relate concepts to practical scenarios, preparing them for real-world challenges. This holistic approach to internship programs not only benefits the interns but also enriches the tech community by preparing well-rounded professionals.

  • Jade E.

    Progressively challenging tasks truly do wonders for an intern’s growth, reflecting my own experiences. Yet, I’ve found that blending these challenges with opportunities to develop soft skillsโ€”like communication and teamworkโ€”can dramatically enhance their readiness for the technology sector. Incorporating structured workshops or team-based projects can be a key step in rounding out their professional capabilities.

  • Kyle Mendez

    In my early days, having a mentor who involved me in client-facing projects made a huge difference. It wasn’t just about coding; understanding the client’s needs and seeing my work in action taught me the real impact of software solutions. This hands-on approach demystified the tech world for me and fueled my passion for development.