8 tips to prepare for your first software engineering job

If you've never worked as a developer before, getting that first job offer is a huge milestone, so congrats!

But it can also be scary.

Will you be up to their standards? What if you're not good enough? How can you make a good impression and succeed in your new career?

Here are 8 things that either helped me—or that I wish I'd done—that you can do now to prepare for success in your first software engineering job.

1. Learn Git (properly)

Git is an incredibly useful tool, but it's also not the most intuitive for beginners.

When you're starting out, it's possible to get by for a while by memorizing a set of commands to achieve a certain thing, without any understanding of what's going on behind the scenes. The problem with this is that it's very hard to get yourself out of a tricky situation when something goes wrong.

It's worth learning enough to build a mental model of what's happening when you run each Git command, as well as to discover other commands you might not need while working on your own, but will use professionally.

By the time you get your first job, you'll probably have at least used version control for personal projects, but the workflow you'll use when collaborating with other people will be different. There are even different workflows you could find depending on things like the type of company you're working for and the size of your team.

Try to make sure you have an understanding of these concepts before starting your job:

  • Forking
  • Branching
  • Stashing
  • Merging and rebasing (and the difference between them)
  • Resetting any unstaged changes
  • Amending a commit (for example if you made a typo in the commit message)
  • Reverting a commit
  • Squashing several commits together

I recommend reading at least the first 4 chapters of Pro Git, or if video courses are more your style, Version Control with Git is a free course by Udacity which also covers all the basics.

2. Get to know your text editor or IDE

You'll spend a lot of time using your editor, and you don't want to be pointing and clicking and dragging stuff around with your mouse once you're working professionally, as it will slow you down a lot. If this sounds like you so far, it's worth trying to break those habits.

Start by learning the keyboard shortcuts for all the common things you do multiple times a day—then practice until it becomes second nature.

If you're using Visual Studio Code, the Mac OS keyboard shortcut cheat sheet is a handy resource to bookmark (there are also versions for Windows and Linux).

Pro tip: If you want to become a real pro with advanced features like themes, extensions, snippets, debugging and source control integration, Learn Visual Studio Code is an excellent Udemy course that will teach you everything you need to know.

3. Learn your ecosystem's developer tools

The exact tooling you need to learn will depend on your language and tech stack, but you'll want to know—at a minimum—one or two popular frameworks, a testing library, and how to use a debugger.

For front-end or full-stack web developers, it's worth knowing your way around the Chrome DevTools in a bit more depth than just logging to the console or tweaking CSS.

For example, you can explore the contents of any JavaScript file in the Sources tab, and set breakpoints directly in there. This is a much quicker way of checking out the code at a particular point than putting debugger or console.log() statements in your code. The Network tab will show you the status of all the HTTP requests the page is making, and how long it's taking to fetch all its resources. With Chrome's device mode, you can view your site as it would appear on different mobile devices, but also simulate network throttling to check how it will perform for users with different connection speeds.

4. Make sure you're typing properly

This one sounds obvious, but you would be surprised how many people (especially those coming from other careers—I know, I was one of them) just never learned to type properly.

Learning to touch type made a massive difference to how fast I could work. I could type quite quickly before, but the patterns I had learned were focused on the keys you use for writing sentences, not code, so they didn't make reaching certain keys easy.

You might type fast, but if you don't put your fingers on the 'correct' keys, you will have a harder time when it comes to things like making keyboard shortcuts a smooth part of your workflow.

There are plenty of free online courses if you don't touch type already, like TypingClub. Most of them are a mix of explanatory videos and repetitive drill exercises to train your muscle memory. I can't say the learning process is exciting exactly, but the results are more than worth it.

5. Get good at Googling

As a developer, you'll become intimately familiar with Google. Sometimes, you'll spend more time searching for the answer to a problem than you will on fixing the problem itself.

Whenever you encounter an error (yes, there will be many), you're probably not the first person to discover it, so paste the text into the Google search box. Most of the time, you'll get either a Stack Overflow thread, a GitHub issue, or a blog post, with other developers discussing the problem and (hopefully) suggesting a solution.

If you're Googling about some specific piece of syntax, remember to include key information like the language and version you're using, or the name of a library or framework if you think the problem could be specific to that.

Pro tip: As a developer, it can be useful to know that Google ignores most non-alphanumeric characters in search queries. This is why symbols like !@#$%^&* or (){}[] don't make any difference to your results.

There are many more advanced ways to use Google that it's worth knowing about. These are not developer specific, but to become a pro at software development, it will help significantly if you are also a pro at Googling.

6. Timebox getting yourself unstuck

When you start a new job, be prepared to get stuck (a lot) in the first few weeks. This happens to everyone, but it's especially true in your first professional role.

The key is to find the right balance between trying to figure out the problem by yourself, and asking for help.

On the one hand, you don't want to waste time struggling on your own for days when a coworker could have got you unstuck in 5 minutes. But nor do you want to bother your teammates too frequently, or you'll be annoying and never learn to be self-sufficient.

As a general rule, spend long enough by yourself to run through everything you can think to try, but try not to be stuck on one specific bug or error message for more than an hour or two.

Something I found useful was setting a timer for how long I would spend being 'stuck' on a thing before asking for help. So it might be "I'll spend one hour trying to figure this out, then I'll get help" or "I'll keep going till lunch, then say something after if I still haven't made progress".

7. Keep a "Don't Know" list

As a new developer, you come across things all the time that you don't know anything about.

The same terms keep popping up—maybe it's Docker, or code splitting, or serverless—and you start to feel like you should at least have some idea of what they mean.

Of course it's not practical to just drop whatever you're doing and go learn about a new thing every time this happens, so what I like to do is maintain a list of things I don't know, but would like to at some point.

Then, next time I come across a word or concept I don't know, I'll add it to the list. When I get some free time, I'll occasionally look at the list, and choose an item from it to look up and learn a little bit about.

The best thing is when I forget about the list for a few months, then come back to it, and realize I have since learned what most of the things are without even trying! It's an excellent way to remind yourself how much progress you're making.

8. Focus on high-impact tasks

This tip is about what you can do to start off on the right foot in terms of getting visibility and recognition for yourself and the work you're doing.

As a junior developer, it can be easy to get sucked into overoptimizing something for no reason, or rewriting code that doesn't need it, or trying to find an excuse to introduce the latest framework just because it sounds cool.

But when you work for a business, it's useful to remember that it is just that: a business.

You'll make the best impression if you can align your priorities with business goals, and this means figuring out how to prioritize.

Try to focus your time and effort on things that will have the most commercial or mission-critical impact: fix a visible bug, work on a feature that helps a large number of customers, or make some tangible difference to a team process.

This doesn't have to apply to everything you do, but if you can make a positive noticeable difference, you'll be a more successful developer—in your first role, and beyond.

Succeed in tech

Get actionable tips on coding, getting hired and working as a developer.

I won't spam you. Unsubscribe any time.