How to Prepare for Your First Software Engineering Internship

A first internship is rarely about knowing everything already. Teams hiring interns are looking for someone who learns quickly, communicates clearly and finishes what they start. This guide covers three stages: before you apply, before your first day, and during the internship itself.

Before you apply

Get comfortable with one language

Depth in one language beats a list of five you have touched. Being comfortable means you can write small programs without looking up basic syntax, you know the standard collections — lists, dictionaries and sets in Python; arrays, maps and objects in JavaScript; ArrayList and HashMap in Java — and you can read an error message and a stack trace to find where things went wrong.

Learn the fundamentals that interviews and real work share

• Data structures: arrays, hash maps, stacks, queues, trees and graphs, and what each one is good at.
• Complexity: estimating how the running time of your code grows with its input.
• Git: committing, branching, merging, resolving a conflict, pushing and opening a pull request.
• SQL: SELECT with WHERE, JOIN and GROUP BY, and what an index is for.
• HTTP: methods, status codes and JSON, and calling an API from the command line.
• The command line: moving around the file system, running programs and reading logs.

You don’t need to master all of these. You need enough to follow a conversation about them and to learn the rest on the job.

Build one or two projects you can explain

A project you built and can discuss in depth is worth more than a long list of course completions. Why building projects matters more than collecting certificates covers what makes a project worth showing and how to present it.

Write a clear, honest résumé

• Keep it to one page: education, projects, any experience and skills.
• For each project, say what it does, what your part was, which technologies you used, and link to it.
• Prefer specifics to adjectives. “Built a REST API with Express and PostgreSQL for a club’s event sign-ups” says more than “passionate full-stack developer”.
• List only skills you could answer questions about.
• Proofread it, export it as a PDF and give the file a sensible name.

Preparing for technical interviews

• Practise regularly. A few problems every week builds more skill than many in one sitting before an interview.
• Practise out loud. Interviewers assess how you reason, not only whether you reach an answer. A structured approach helps: see how to approach an unfamiliar coding problem.
• Know your projects. Be ready to walk through the architecture, a bug you fixed and what you would change.
• Prepare questions of your own. What would an intern work on? How is code reviewed? Who would you go to for help?

Before your first day

Set up your environment

Install the language runtime, your editor and Git. Tell Git who you are, and create an SSH key for your Git host so you can push without typing a password:

git config --global user.name "Your Name"
git config --global user.email "you@example.com"
ssh-keygen -t ed25519 -C "you@example.com"

Then add the public key (the file ending in .pub) to your account on the Git host, following its documentation.

Practise the team Git workflow

Most teams work on short-lived branches and merge them through pull requests. Rehearse the full loop on a project of your own until it feels routine:

git switch main
git pull
git switch -c fix-login-redirect

# ...edit, run the tests, then review and stage your changes piece by piece
git add -p
git commit -m "Fix redirect after login when the session has expired"
git push -u origin fix-login-redirect

Then open a pull request, describe what changed and why, and respond to review comments with follow-up commits. Teams differ on details such as rebasing or merging, so follow your team’s conventions once you join.

Practise reading code you didn’t write

Most of your first weeks will be spent reading code, not writing it. Practise on an open-source project in your language: clone it, get its tests running, then pick one feature and trace it from where a request or user action enters the program to where the data is stored.

During the internship

Understand before you change

• Get the project running locally, and note every step that wasn’t written down. Updating the setup instructions is a useful first contribution.
• Ask for a small first task, so you learn the full path from ticket to merged change.
• Learn how work flows through the team: tickets, branches, code review, continuous integration and deployment.

Ask good questions

Spend some time on a problem before asking, but don’t stay stuck for hours; agree with your mentor on roughly how long to try first. When you ask, include:

1. what you are trying to do;
2. what you have tried;
3. what you expected to happen, and what happened instead — with the exact error message;
4. your best guess at the cause.

A question in that shape is quick to answer, and writing it often reveals the answer before you send it.

Make your progress visible

• Give short, regular updates: what you finished, what you are doing next and what is blocking you.
• Open a draft pull request early, so feedback arrives before you have built too much in the wrong direction.
• Treat review comments as information about the codebase and its conventions, not as judgements of you.

Write things down

Keep a simple work log: tasks, decisions and why they were made, useful commands and things you learned. It helps in stand-ups, in your end-of-internship presentation and, later, when you describe the internship in a résumé or an interview.

Finish well

• Leave your work in a state someone else can pick up: merged, or documented with clear next steps.
• Write a short summary of what you built and where it lives.
• Ask your mentor for feedback on what to improve.
• Update your résumé while the details are fresh, without sharing anything confidential about your employer’s code or customers.

A short checklist

Before applying: one language you are comfortable in, the fundamentals above, one or two projects you can explain, and a one-page résumé.

Before day one: a working environment, a rehearsed Git workflow and practice reading unfamiliar code.

During: understand before changing, ask well-formed questions, make your progress visible, keep a log and finish cleanly.