Many wanna-be-developers ask me how to start their first software developer job. In this article + video lesson I explain my experience, based on my 16K students alumni from SoftUni (as of March 2022) and my 20 years of experience as educator devoted to train programmers and give them a tech job.

Video Lesson: Starting the First Job in the Software Industry

TLDR: Build a GitHub Portfolio of Software Projects to Prove Your Skills and Experience and You Will Start a Tech Job Easily!

Software companies want proven skills and experience to hire you as a junior developer. This experience is your GitHub profile, which you should intensively build for 1-2 years before applying for your first tech job!

The recipe to start an IT job is simple: learn coding and technologies ➡ create a portfolio of projects ➡ learn what the employers need ➡ apply carefully ➡ interview / assessment ➡ job. It takes from 6 months to 2-3 years, mostly learning the software development profession and building a portfolio of practical software projects.

Now, I will give you the details: the steps to gain software development skills, to build a developer portfolio and CV, to find job offers for junior developers, to prepare and carefully apply for a job and to pass the technical interview.

Most career guides focus on the tech interview, but only 5% of the applicants reach an interview. I focus on the other 95%: learning, skillset development, building a portfolio of projects and CV, applying with careful preparation for each job position.

Lesson Slides: How to Start Your First Developer Job?

About the Author: Svetlin Nakov, PhD

I am a passionate software engineer and a tech trainer, with 20+ years of experience in the software industry, a co-founder of SoftUni – the largest tech education institution in South-Eastern Europe, with 300K+ students in the last 9 years. I am author of 15+ tech books on programming and software technologies. I am a regular conference speaker and inspirator for thousands of young people to learn programming and start an IT job.

Steps to Start a Developer Job: Learn ➡ Portfolio ➡ Apply ➡ Job

These are the essentials steps to start a tech job (in 6 months to 2-3 years, depending on the time you invest and your skills level at the start):

• Goals: decide what profession to learn (e.g. Java developer, QA engineer, front-ebd developer, etc.)
• Learn: learn coding and software technologies, build practical skills, write 100K lines of code in 2000 hours, spend 6-36 months in your tech education
• Portfolio: build a portfolio of software projects in GitHub (the most important step!)
• Positions: find junior job positions to apply (positions, which match your skills)
• Prepare: add skills to match the job requirements (learn more to match the job requirements)
• Apply: carefully prepare and send a job application (application message + CV + cover letter)
• Interview: prepare for a technical job interview or technical assessment (I will not focus on this topic, because only 5% of the applicants reach an interview)
• Survive: make your best to survive the trial period (learn and improve your skills constantly, especially in out-of-work hours)

The steps to learn programming and start a developer job are summarized below:

Define Your Career Goals: What IT Profession to Learn?

Defining your career goals should be your first step when you consider starting to invest in a software development career.

My tips and tricks about the process of understanding your career goals here are the following:

• Learn about the most wanted tech professions on the market, e.g. Java developer, JavaScript developer, Python developer, C# developer, QA automation engineer, front-end developer, etc.
• Research the job market, talk with friends and experts, read articles, find what is hot and is possible for you to learn in a short timeframe
• Play with different languages and technologies! This is quite important before you months or years invest in learning. Who do you know what you like? How do you know the difference between Java and Python for example? You should try them: follow tutorials, run code examples, watch videos, play with sample projects.
• Answer for yourself individually: what is exciting and motivational for you? Is this a front-end and UI or code logic and algorithms? You will feel it! Try! Try! Try! This is how you will know.
• Start learning and check if computer programming is your passion! How?
  • Once you start a coding tutorial or code academy, you will know if you like this. Do you really enjoy coding? Shall you do this every day for years with pleasure?
  • Is it easy for you to learn programming? Some people learn with ease, others have different style of thinking and need more effort to learn engineering and technologies.
  • Do you have enough time to spend in learning the software engineering professions (2000-3000 hours to an entry level developer job). If you don’t have time, how you could find it?
• Important: what the market needs? Once you find what technologies, programming languages and frameworks you like, match them with the market demand. For example, JavaScript is quite more popular and in demand than Perl or Ruby. At the start, for your first job learn the technologies that the market wants. Check them in the IT jobs portals.

This is an example how you could use LinkedIn Jobs to compare the market demand for different software technologies in certain locations:

Educate Yourself! Study Hard! Learn Programming, Concepts, Platforms, Frameworks, Tools

The next step, which is highly time-consuming, is to learn software development: develop practical programming skills, algorithmic thinking and problem solving skills, learn the software development fundamental concepts, learn modern development platforms and software technologies, software frameworks and developer tools.

Learning the software development profession takes time: 2000-3000 hours (from 6 months at full dedication to 2-3 years at part time).

You should learn coding, algorithmic thinking, development concepts, software development, software platforms, frameworks, tools and engineering practices. But how to learn the software development profession?

There are have many sources of tech education available (free and paid): tutorials, books, video courses, code camps and many others. For example, SoftUni Global provides an excellent zero-to-career learning program for software developers, taken already by 16K students and most of them started a tech job!

The most important part of your education for a software developer is to get a practical experience.

Practice, Practice, Practice! Learn by Doing!

Why do you need to practice? Because coding is a skill. It cannot be learned by watching videos.

The only way you can learn to code is by coding. Follow the exercises and hands-on projects from your course / tutorial / book, write the code, play with it, modify it, run it, fix the bugs and you will get the practical skills from your tech education process, not just the theory.

The recipe for developing your practical coding skills is simple and is used in all successful tech education centers (academies, courses, tech colleges, etc.): practice hands-on exercises, follow coding tutorials, do hands-on projects, gain experience, develop your own unique software projects.

How Long Does It Take to Learn Software Development?

I already explained this, but it is important to repeat it:

To learn software development for a career start, you should spend on learning 2-3 years @ part-time (or 6-12 months @ 12 hours / day). This means that you should spend of coding at least 2000-3000 hours! Measured as lines of code to write in order to reach an entry level dev job, this effort could mean 100K-150K lines of code (LOC).

Your learning speed depends on the level of your mathematical thinking, on your previous experience and on your passion and dedication to the learning process. I have students who managed to learn programming and start a junior developer job in less than 6 months, but this is not the typical case. Typical students go from zero to IT career for 2 years, while they preserve their other activities (e.g. going to the university or practicing their daily job)!

Learn by Doing! Write Code Every Day for Years!

I will repeat this again, because it is really important:

To learn programming, you need to write code! Watching videos or reading books gives you only knowledge. Solving hands-on exercises, following hands-on tutorials and developing practical projects gives you experience and practical skills. These activities are the essential part of learning the software engineering profession.

In the beast case scenario, you should code every day for 2-3 years!

2000-3000 Hours of Practice for a Junior Dev Job

Let’s do a simple calculation: 2 years = 600 days (I leave some free days) * 3-4 hours / day == 2000+ hours. Another simple calculation: 600 days * 200 lines of code (average) == 120K LOC. The same could be achieved in 6 months if you invest all your time (6 days a week): 6 months * 26 days * 12 hours = 1872 hours.

As I already mentioned, 2000-3000 hours of practical programming is enough to start a junior developer job. It takes significant time and effort to reach a junior level expertise.

That’s why the demand in the IT industry is so high and salaries are so good: it is not easy to become a software engineer and start a tech job! To get hired as software developer, you should match the industry requirements and it takes time to develop such skills.

GitHub Portfolio of Projects: Prove Your Experience

The most important part of your software developer education are your practical projects, which you build for months of hard study and hard work! In the modern software industry the best way to showcase your practical software projects is your GitHub profile.

Do you know these green blocks represent? These blocks represent the days with code commits in your GitHub coding history. More green blocks and darker green color is better.

Why Your GitHub Profile is So Important?

GitHub is the world’s largest software project hosting platform, where most developers and software companies put the code they write. It acts as social network for developers. If you are a wanna-be-developer, you should definitely build a rich GitHub profile to showcase your projects and experience!

Your GitHub profile is more important than your CV, because in GitHub your skills come with evidence of time and effort spent on practical coding.

Your GitHub profile is your proof of developer experience! Make sure your GitHub portfolio it is carefully developed, maintained and well documented.

This is extremely important if you don’t have employment history in the software industry or other evidence to prove your experience with certain software technology. Employers want skillful developers with experience. You should have experience to start a junior dev job or event an internship (typically 1-2 years)! That’s the reality. To match the requirements, you should spend 1-2 years in coding (or less in more intensive form) and leave a proven track record of your skills in GitHub.

Job Market Says: 1-2 Years of Experience for a Junior Developer Job

Job ads almost always require previous experience as software developer. These are some typical examples (taken from LinkedIn Jobs in March 2022), demonstrating what companies want for a junior dev position:

Another example of junior developer job requirements:

How to Prove Your Developer Experience before Your First Dev Job?

Typically job positions require 1-2 years of experience for junior developer. But how could you have 1-2 years of experience as software engineer before your first developer job? The answer is simple: you should work as software developer on your own educational projects for 1-2 years (or less time in more intensive form) before your first tech job. To prove your developer experience, you should build a solid GitHub developer portfolio of projects!

Your Project portfolio with your commit history proves your experience. It holds an evidence of your work as a software developer and the code you have written in the lest few years.

This is an example of a GitHub profile of my student (in its starter phase in March 2022): https://github.com/yavorhr. This guy is intensively studying software engineering and is carefully preparing his developer portfolio in order to showcase his developer skills and prove his developer experience and match the requirements for a junior dev job. This is how his history of code contributions looks like:

I am sure that he will start a developer job in the next few months, because he has proven track record of developing Java projects with Spring, Hibernate and MySQL. His CV will not be empty, but will have several projects and will show 1-2 years of experience. He will match most of the requirements for a junior Java developer position.

Number of Commits in Your GitHub Profile

Another important metric in GitHub is the number of commits. My students from the above example has 400+ commits in the last year. This means that he wrote some code 400 times and sent it to GitHub. This demonstrates hard work and proves that this guy is writing code regularly. This is a very good sign for the employers.

I know that someone could try to cheat and create a fake the commit history, but this is hard to be achieved with a bot or by hand without investing a significant effort. If the commits are fake (e.g. a bot could every day increase a number in a text file and commit automatically), but this will be easily visible, because your profile and commit history are public. It is better to invest in writing code and develop your real skills, instead of faking your GitHub profile!

Strong GitHub profiles should hold at least 500-1000 commits per year. Longer commit history is better (2-3 years is better than 6 months).

This is of course indicative, but you can use this number as reference. Committing often, after each significant and meaningful change, is highly recommended. Regular commits serve as evidence of your coding experience gained over the time! Your commit history is easily visible from the contribution map (the green blocks) in your GitHub profile:

If you are a wanna-be junior developer, track your commit history and make sure you demonstrate through your public commits that you work hard on software projects over a long period of time. This is your coding experience, which is often required in the job descriptions.

Sample GitHub Portfolios

Now, I will give some examples of strong GitHub profiles, which you can use as guidelines, when you build your. The most important thing is to demonstrate that you write a lot of code for a long time and you have developed one or several practical projects.

These are a few sample developer portfolios of my students from SoftUni, who have learned programming, created several practical projects in GitHub with solid commit history to prove their skills and started their first dev job in the software industry with ease:

• GitHub: https://github.com/TodorBelchev (2600 commits in the period 2020-2022)
  • LinkedIn: https://linkedin.com/in/todor-belchev-329a58171
• GitHub: https://github.com/tsonewa (350 commits in the period 2021-2022)
  • LinkedIn: https://linkedin.com/in/dimitrinka-tsoneva-65650b105
• GitHub: https://github.com/mischelll (520 commits in the period 2019-2020)
  • LinkedIn: https://linkedin.com/in/mishel-ivanov-703094191
• GitHub: https://github.com/alexmehandzhiyska (450 commits in the period 2021-2022)
  • LinkedIn: https://linkedin.com/in/alexandrina-mehandzhiyska
• GitHub: https://github.com/Sineastra (1100 commits in the period 2020-2022)
  • LinkedIn: https://linkedin.com/in/orfey-kostadinov-a152131b6

You could look at these profiles and find how these students have demonstrated a proven track record of software development experience through their software projects and rich GitHub commit history. As a result of their effort to build their developer skills and portfolio, they already started their first junior developer job. Their profiles prove their hard work as developers for at least 2 years. We could say that these GitHub profiles demonstrate coding experience of 1-2 years (at least).

Document Your GitHub Projects!

More than 99% of the projects in GitHub consists of just code, without any documentation: description, goals, technology stack, design and architectural decisions, API documentation, etc. This is not good!

When you are wanna-be junior developer, you should showcase your work as software developer, to demonstrate what projects you have in your portfolio and to publicly show your skills and hard work in software development through your commit history. Your GitHub profile demonstrates what languages, platforms and software technologies you have experience with. If you have developer experience and you don’t show it, how would the employers know about your skills?

GitHub is the ideal tool to publicly demonstrate your experience and skills. Work on software projects, create a solid commit history, document your project and deploy a 1-click live demo!

My recommendation for each showcase project in your GitHub software project portfolio is to follow this structure in your project documentation:

• Meaningful project title, e.g. Car Reservation System, not MyApp2
• Short project description: goals, use cases, implemented functionality, technologies used, etc. Example: The JS app “Contact Book” holds a searchable list of contacts and provides list / view / add functionality. It is based on Node.js + Express.js + Pug. Examples:
  • https://github.com/marinakolova/BeautyBooking
  • https://github.com/Valkozaur/PlanShift
  • https://github.com/nakov/ContactBook
  • https://github.com/VelinovAngel/My-ASP.Net-Core-Web-Project
  • https://github.com/yotkoKanchev/LetsSport
• Live demo: deploy your app live in Internet to allow your future employer to see it in action through a one-click link. You may use Heroku, ReplIt, AWS, Firebase hosting or other online cloud platform. Make sure the app is accessible without a registration, or provide a sample login credentials.
• Technical documentation: API endpoint descriptions, architectural diagrams, class diagrams, etc. This helps external users to learn how your project works from a technical perspective.
• Screenshots: this is very, very important! When your project provides screenshots, visitors of your GitHub profile can get an idea what you have build in just few seconds.

These examples could serve as reference how you should document and showcase your portfolio projects in GitHub (description + tech stack + screenshots + live demo):

• https://github.com/marinakolova/BeautyBooking
• https://github.com/nakov/ContactBook
• https://github.com/nakov/Eventures
• https://github.com/nakov/ShortURL
• https://github.com/nakov/TaskBoard 

GitHub Portfolio: Tips and Tricks

➡️ Start building your GitHub profile as early as possible! Ideally, in the first month when you start writing code. Thus you will get more proof of your coding skills. Initially you will upload very simple code, but over the time, your projects will become more rich and valuable. At some time, you could hide your earliest projects and showcase only the final achievements of your work.

➡️ Constantly commit and push your daily work. This creates a commit history in your GitHub profile and makes your contribution history blocks green. Committing often demonstrates that you write code regularly. This is what employers want to see in your job application: a proof that you have long history of coding experience!

This is how your contribution graph will look like in your GitHub profiles if you commit often during your software engineering education and portfolio building period:

This is how your profile may look like if you have similar experience and projects, but you commit only from time to time, when you have something valuable to push to GitHub:

➡️ Document well your projects. Describe project goals, technologies, architecture, APIs, etc. This is an example how you can do this: https://github.com/nakov/ContactBook.

➡️ Deploy your projects as 1-click showcase. This is an example how to do this in Repl.it: https://replit.com/@nakov/contactbook.

One-click showcase means that your app should be accessible in 1-click:

• It should be accessible without installation. Provide a link to the live app deployment, e.g. in Heroku, Repl.it, GitHub Pages, AWS, Azure, Google App Engine or Firebase hosting.
• It should be accessible without registration. Provide sample auto-filled login credentials at the login page, or another way to login with a single mouse click.
• It should have enough sample data in the database. Nobody will add data just to check if your app works correctly.

➡️ Publish your contacts in your GitHub profile! If you are looking for a job, be open to accept messages from potential recruiters who want to offer you to apply in their company. Publish your email address and LinkedIn profile. You may get some spam, but also some job offers. This is an example how to do this:

➡️ Make your GitHub profile look nice. Make a profile README, embed GitHub stats, GitHub trophies, pin repositories, add descriptions and topics to your repos, etc.

➡️ Publish your developer CV online as interactive Web page. This demonstrates some HTML, CSS and front-end skills, as well as increases the chance for some recruiter to find your resume in GitHub.

These are some examples how you can create a good looking online CV in GitHub Pages:

• https://vasilstoyanov99.github.io/CV
• https://boykopetevboev.github.io/CV
• https://radevdaniel.github.io
• https://kristian9577.github.io
• https://radoslavdimitrov.github.io

These tools, samples and tutorials could help you make an impressive GitHub profile README:

• A collection of nice looking profile README layouts: https://zzetao.github.io/awesome-github-profile
• A guideline on creating a beautiful profile README: https://www.sitepoint.com/github-profile-readme
• Profile README generator: https://rahuldkjain.github.io/gh-profile-readme-generator

Other Developer Profiles: StackOverflow, Spoj, NPM, NuGet, etc.

In addition to your GitHub profile, to demonstrate that you are a keen developer with experience, you could develop your other developer profiles.

➡️ Build reputation on StackOverflow by answering questions from the technologies you learn and work with. Add your StackOverflow profile link to your CV and GitHub profile. Put your contacts in your profile, if you want to get job offers. Spend 1-2 months to answer the questions in certain category and this will help you master this category, as well as gain reputation and catch the recruiter’s interest. These are some examples of StackOverflow profiles of my students from SoftUni, who demonstrated their tech skills at StackOverflow and started a developer job:

• https://stackoverflow.com/users/4804019/codearts
• https://stackoverflow.com/users/6368528/ivan-ganchev
• https://stackoverflow.com/users/8540759/radrex

When you achieve a good reputation (e.g. over 200-300 points), put your StackOverflow profile link in the “Developer Profiles” / “Dev Achievements” section in your CV.

➡️ Publish your own libraries on the popular package management repositories, such as NPM (for JavaScript), NuGet (for C#), Maven Central (for Java) and PyPI (for Python) to show your skills to write software packages and help other developers in their daily jobs.

The easiest way to get started with creating and publishing your own library is to take an interesting and useful library, which is no longer supported by its original author, and to modernize it for the latest version of its target platform (e.g. upgrade Java 5 library to Java 17). You can add features and improve it’s API. Also you can add unit tests.

These are a few examples of dev profiles at the popular developer package repository sites:

• https://www.npmjs.com/package/jadejs
• https://www.nuget.org/profiles/nakov
• https://www.npmjs.com/~petarov

Put your published libraries in the “Projects” section in your CV.

➡️ Build a profile and solve problems at coding challenge and competition platforms like Spoj, HackerRank, TopCoder, CodeForces and others. make sure to make your profile public, add your contacts (to allow recruiters find and contact you) and also to upload your code solutions with short documentation at GitHub.

These are sample coding challenge profiles from students, learning programming and algorithms:

• https://www.spoj.com/users/deyanpb
• https://www.spoj.com/users/laspinko
• https://www.hackerrank.com/profile/tsvetelinkostad1
• https://www.topcoder.com/members/kiri4a
• https://www.topcoder.com/members/kiril.kartunov

Find Junior Positions, Matching Your Experience

The next step in your journey to your first developer job is to find junior job positions, that match your experience. Of course, if you don’t have experience, you should return to the previous steps to learn software development and develop a portfolio of practical projects in GitHub.

How to research the job market and decide where to apply? You could analyze the job market for junior positions and answer about yourself the following:

• What skills employers require, which you don’t have?
• What skills are required everywhere in the junior dev job ads? Do you have them?
• Some typically required skills for the junior dev positions are: coding, Git, OOP, databases, Web technologies

Once you find your skill gaps, return back and learn more to match better the job market! Make projects in your portfolio, to keep record of your skillset. For example, if you find that most job offers in your region require PostgreSQL, you could learn it like this:

• Install PostgerSQL and play with it.
• Follow a tutorial about PostgreSQL. Commit all your sample code from the tutorial in a GitHub repo, named for example Node-Express-PostgreSQL-Sequelize. When someone opens your profile and see your PostgerSQL projects, it will be obvious that you have some experience with this technology.

Repeat the above for the other technologies, that are in high demand and you don’t have experience with, e.g. Docker or Selenium.

Prepare to Apply Carefully ➡ Match the Job Requirements

Most job applicants don’t read carefully the job description and don’t try to match the job requirements. Of course, they have very low success rate. Be smart! Match the job requirements with your GitHub portfolio and CV and you will have significantly higher chance to get to a job interview!

This is what I recommend to do during the process of finding job offers and analyzing them carefully:

• Analyze each specific job position you want to apply for! What is missing in your skillset? How can you add skills to match the requirements?
• If your skillset totally cannot match the job position, proceed to the next job offer.
• If your skillset and GitHub portfolio matches most of the job requirements, do your best to match all the others! How? Add the missing skills required by the job position.
• Watch a video lesson, then follow a tutorial, then create a project in GitHub, to build a public evidence that you have some experience with the required technology or skill.

Example: Extracting the Requirements from the Job Description

Assume this is the job description:

You can easily extract the technical requirements from it like this:

Now, you should match these requirements in your GitHub portfolio and in your CV (professional resume). This is how you can add skills to match the job position.

Example: Matching the Requirements

Go through the technical keywords from the job description and match them with your GitHub profile. For example, lets assume, that your GitHub profile is this one: https://github.com/kristian9577.

These are the keywords from the job description from the job ad:

• Java ➜ you have a solid coding portfolio with Java here: https://github.com/kristian9577/Java-OOP. You should mention this link in your CV, cover letter and job application message.
• Spring ➜ you have a solid practical project with Spring framework, Spring MVC, Spring Boot, Spring Data, Hibernate and MySQL: https://github.com/kristian9577/Spring-Project. Obligatory put this project in your CV, cover letter and job application. This is the strongest asset of your job application.
• Mockito ➜ this is a technology, that you don’t know. You don’t have any experience with it. What to do? Learn it and add it to the your GitHub portfolio! How to learn Mockito? First find lessons and tutorials: https://google.com/search?q=mockito+tutorial. Next, play with it ➜ create a Mockito project in GitHub for your portfolio. This is an excellent example how you could integrate Mockito tests in your existing Spring MVC app: https://github.com/royrusso/spring-mvc-rest-mockito.
• Docker ➜ this is the next technology from the job offer, which you don’t know it, but many companies want it. What to do? Learn Docker and add it in your GitHub portfolio! Watch video lessons, follow tutorials, add Docker to your existing projects.
• Do the same for the other required technologies from the job ad. In the above examples, these could be: Cucumber, Oracle, React, Maven. Make sure you have a link from your project portfolio in your CV and cover letter.
• Spend more time and effort on technologies, which are commonly required, and less time and effort to exotic technologies. In our case, React and Maven are “should learn” technologies, while Cucumber is a kind of exotic technologies, which are not widely used. You can ask friends from the software industry to help you recognize what to learn and what to skip. Here “to learn” means to have it in your GitHub and “to skip” means just to watch a video to have an idea what is it.

The above process could take several days, even weeks, but it will pay off! If you have already spent 1-2 years to learn programming and modern software technologies, why you don’t want to spend additionally 1-2 weeks to extend your skillset and match more closely what software companies want from you for a junior dev position?

Invest in yourself! Extend your tech skills. Match the job requirements, then carefully apply and you will succeed! Trust me, I have helped thousands of students to start a tech job. These guidelines really work!

The Job Application: Portfolio, CV, Cover Letter

Most people start from this step and skip the previous preparation. They will fail 99%, be sure!

The carefully prepared job application is quite important to get to a job interview. Yes, it is. But you can’t have a good job application, if you don’t have skills, if you don’t have rich GitHub portfolio of projects and you have solid gaps in your skills. First, invest in your skills to match the job requirements.

If you match the job requirements, you should carefully prepare your unique job application. Yes, the job application should be unique and personal. If you copy / paste it, you will fail. Guaranteed!

The Job Application: Assets

A strong job application for a tech position typically consists of application email + CV + cover letter:

Let’s review these components of the job application and what they typically could hold, with examples:

• Email / application message, e.g.
  • Dear HR Manager, I would like to apply for the [position] in [company name], which I found [where].
  • Write a personal text, don’t copy/paste my template. Mention the name of the company, its values, culture, whatever you find interesting in the job description.
• Portfolio of projects
  • My portfolio of projects are available at: [GitHub link]
  • I have experience with [technology from the job requirements] during the development of this project [GitHub portfolio link] and this project [link] …
• Resume (CV)
  • My resume is attached as PDF document / available online at [link].
  • Your CV should be adjusted for the target job position! It should match the job requirements. The most important technologies for the target job position, should be put first, with more detailed description + link to your GitHub projects.
• Cover letter (CL):
  • You could send your cover letter as separate PDF document or put it as free text in your application email. It should explain why you are the right candidate: skills + technical experience + personal attitude. It should be unique, personal, honest. Never copy/paste!
  • Example: I am the right candidate for this position, because [personal qualities]. I have the required skillset, visible from my GitHub portfolio of projects: [link]. I know the industry of [company name] from [where]. I am highly motivated to join [company name], so please give me a chance to come to an interview to demonstrate my skills and motivation.
  • Don’t copy/paste the above template. It is just an example to catch the idea!

The above assets could serve as reference how to apply for a tech job, after you have matched the job requirements. You should always send the following assets: application message (or cover letter), CV (professional resume), GitHub portfolio (it can be inside the CV or in the cover letter or a separate document).

Apply for the Job Carefully!

Job applications should be prepared carefully, with attention to details. Remember this!

These are my hints for preparing your job application:

• If you have bugs, wrong company name, typos, bad text formatting, bad file names like `CV-new(2).docx`, this will reduce your chances.
• The job application should be individual, for the specific position, personal, unique (just like a love letter). It should match the certain company and certain position. It cannot be general.
• Never copy / paste your cover letter or application message! Your will fail, guaranteed!
• Adjust your CV to match the target position. Put something about each keyword from the job description. To have what to put, first perform a research and extend your skillset and portfolio.
• Always write your cover letter from scratch for each individual job position.
• Give you contacts (email, phone, etc.) and expect to be contacted! Write your full name (not badgys37 or asfd).
• If your age is 30+, don’t mention it. You are not obligated. If you are too young (e.g. at age of 15), don’t mention this. In your CV put a photo, where you look serious, at age of 20-30, in a business style, not from a disco bar. Match the cultural values of the target company. Some companies discourage sending photos in the CV.

How to Write a CV and a Cover Letter?

Writing a technical CV and a cover letter are out of scope for this guide, because these topics are very, very common and are discussed everywhere in the job assistance portals.

You could find thousands of guidelines on writing CV and cover letter in Internet:

• https://google.com/search?q=writing+a+technical+cv
• https://google.com/search?q=writing+tech+cover+letter

Remember: it is quite more important not to write an impressive CV, but to put enough effort to match the job requirements with relevant GitHub projects in your portfolio and thus to have what to put in your CV.

Hundreds of companies provide guidelines and CV building tools which you can leverage. Try to find and explore some CV building tools online:

• https://www.google.com/search?q=cv+builder

In Internet you could find thousands examples of good and bad CV and cover letter. I leave this step to you. Just research this topic yourself. When you have what to put in your CV and cover letter, to match the job position, the technical details, design, layout, etc. are of your choice.

The Tech Job Interview / Exams / Technical Assessment

Remember that 95% of the candidates are not invited to an interview! Why? because they don’t match the job requirements. Put your effort to match the job requirements. If you really match the job description and you can prove this by your GitHub portfolio and commit history, your interview will be just a formality.

Focus on preparation in order to reach an interview: study hard, build an impressive portfolio, select job positions and apply carefully! I already explained in detail all these steps.

Understanding the Hiring Process

From the employer perspective, the typical tech job hiring process works like this:

In more details, the typical hiring process in most tech companies works like this:

1. The company posts a job ad in several job portals (e.g. in LinkedIn Jobs, in a local job portal or the social channels).
   • Typically this is done by the HR team (or by the company owner in smaller companies).
2. The company collects all job applications for a time-bound period (e.g. 2 weeks).
   • This is typically done by the HR (human resource manager).
3. Employer selects the best candidates based on their job application documents (CV, cover letter, portfolio).
   • Obviously stupid candidatures are directly rejected, e.g. empty CV, job application full of mistakes, copy/pasted applications, and many others. This step is performed by the HR team or by the team leader, who will manage the new employees when hired.
4. Selected candidates are either invited to an interview or to some kind of technical assessment and then to an interview.
   • The technical assessment could be an online or onsite test or coding exam or project assignment to check the skills and motivation of the candidates.
   • Some companies rely on exams, tests or other skill assessments, while others will just call you for an interview.
5. After the technical assessment and the interview, the company sends a job offer to the best performing candidates.
   • The job offer describes the offered position, job responsibilities, offered salary and benefits, offered starting date, contract terms and other details.

Interview Preparation

In case you are invited to an interview, you should prepare yourself for the interview.

These are the most important steps to prepare for the technical interview:

• Research the company: learn as much as possible. What they do? What is its target industry for the job position you apply? Do you have friends in this company? Look in Internet and in the social channels. What are the company values?
• Research the technologies from the job advertisement! I already explained how to do this: watch video lessons, follow tutorials, create a GitHub projects with the target technologies.
• Prepare for typical tech interview questions: https://google.com/search?q=tech+interview+questions.

There are thousands of tech interview guidelines that you could find in Internet or in YouTube, so it is always a good idea to prepare for the most common tech questions, but do when you are invited to an interview. 95% of job applications don’t reach an interview. Focus yourself on the previous steps!

Finding Tech Interview Guidelines

If you are a software developer, you should know how to search in Internet. Put your job position + “interview questions” and you will find many useful resources. Examples:

• https://google.com/search?q=junior+java+interview+questions
• https://google.com/search?q=junior+javascript+interview+questions

The Technical Assessment

Some companies prefer to give a technical assessment before inviting you to an interview.

• In case you are invited to live exam (onsite or remotely), collect as much information about it and prepare yourself.
  • If you have strong developer skills, it is likely to pass the exam with good results.
  • If you are not well prepared, you will find out where are your skill gaps, and you may fill them before your next job application.
• In case you are given a practical project assignment, make your best to fulfil it in the best possible way, which matches your skills.
  • Read the project assignment carefully and do what it says, not what is easiest for you.
  • Write your solution, following the industry best practices: use a GitHub repository, work in branches, commit often, create documentation, write clean code, etc.
  • Use the best practices for the project architecture, project quality, write automated tests, implement continuous integration in GitHub Actions, etc.
  • If you have a friend, who is an experienced developer, you can ask him for advices, for mentorship and for a code review. Do not submit a project, which is far away from your skills! You will fail to defend your project later during the job interview. You can only take small advices and reviews from friends, not their code.
  • Using an external mentorship help is a good idea, but never assign someone else to write your code! This is a cheat and you will be rejected at the interview and eventually will be added to some blacklist. Remember that you will eventually start the job, not your friend!
  • It’s always better to write your code without external help, and eventually ask a friend for a code review to improve your code, than heavily use external help!

Once Hired → Survive the Trial Period

Once you have successfully passed the technical assessment and the technical interview, if you are successful, you will be given a job offer. The job offer typically will have a trial (probation) period, in which you can be fired at any time, if you don’t perform as expected.

To survive the trial period, in the first few months of your first dev job, make your best to demonstrate motivation, hard work, dedication to your job and willingness to learn and improve every day. How?

• Come early at work, stay until late (after your direct manager), work hard, answer to chats and emails fast, and deliver more than expected. If you have assigned tasks, try to make them with excellent quality and attention to detail. You may put additional effort after work to exceed the expectations of your manager and colleagues. This way you demonstrate motivation and diligence.
• Spend time to add new skills after work. In the evenings and in the weekends, learn additional skills that can help you at work. For example, if your first project uses Docker, Kubernetes, Terraform and AWS, and you are not familiar with Terraform, learn it. Watch a video, follow a tutorial, make a sample project. This way you demonstrate willingness to learn and constantly improve your skills.
• Take the feedback seriously. Listen to your manager and colleagues, especially for their technical guidelines and instructions. Your job depends on your manager, so you should follow him. This way you demonstrate a willingness to adopt in the company’s environment, culture and work style.
• Build network. Talk with your team members, know your colleagues, take a coffee or lunch with them. Be positive and friendly, offer help, volunteer for the new tasks / projects / initiatives, collaborate, share knowledge, take part in the team’s social activities. This way you build a personal connection with your team and they will want to work with you for a long.

When to Start Coding? Is It Too Late to Learn Programming at Age of 35+?

Many people ask me when to start learning programming. I always answer the same way: as early, as possible, ideally when you are still a child. You can start later, but you will pay the price for being late.

Start Coding at Age < 15

When you are less than 15 years old, it’s time to test your interests and find if you like coding. You should try coding to find out if you like it. Your GitHub profile at age under 15 could look like this:

• You can join some kids programming club or kids coding academy and play with coding, educational robots, educational game development, digital arts for kids, etc.
• Some kids may find that coding is their meaning of life (like me at age of 10) and you can’t stop them. Unfortunately this rarely happens.
• It’s too early for most people to start coding at age under 15, but students who start at this age and keep coding over the years, gain strong expertise and experience and start a developer job with ease at age of 19-20, just after school graduation, or even during the high school.
• I personally started coding at age of 10 and soon I found that programming is my passion. I leaned coding, algorithms and software technologies for 4-5 years and started a part time job freelance during the high school.
• My school students at “SoftUni Svetlina” Tech High-School start with coding at age of 13-14 and become experienced junior developers even before graduation. It is excellent if someone loves programming, to attend a specialized tech school to boost his skills and passion for technologies.
• Note: it is unlikely to find a job at this age. Invest your time in building your own projects to increase your skills and have fun with coding and technology. You can try working on freelance projects.

Look at these sample profiles of my students, who learned coding at SoftUni / SoftUni Svetlina / Nakov School at age < 15 and achieved excellent software development expertise at age of 17-18:

• George Dautov: https://github.com/OKAY808
• Dean Donkov: https://github.com/DeanDonkov
• Lachezar Kolev: https://github.com/Lacho123
• Kaloyan Dimitrov: https://github.com/Kaloyan-Dimitrov
• Ivan Iliev: https://github.com/ivan-iliev
• Alex-Valentino Georgiev: https://github.com/tino26

Start Coding at Age of 15-18

When you are 15-18 years old, you have a lot of free time and you can spend years in coding without any pressure. This is an excellent timing to become a passionate developer, if you like coding. This is a typical GitHub profile of young developer at high school age:

• Typically, at this age you have the greatest comfort in your life: your parents handle your daily needs and expenses, so you can enjoy learning and spend as much time as you need (e.g. 3-4 years) to become a very skillful developer. Don’t miss this period!
• At age of 15-18, it is the best time to start coding and to learn the software development profession with ease, without hurrying.
• Many of my best students at SoftUni start with coding at this age and have an exceptional tech career later.
• Note: it is hard to start a developer job at this age, because tech companies prefer full-time employees. Freelance and part-time jobs are not typical in the software industry, but you can find freelance projects to work on.
• Hint: don’t put your age in your CV, because some companies will reject your job application for being too young. You are not obligated to declare your age when you apply for a job. Put a photo, where you look mature, stable and not too young.

Look at these sample profiles of my students, who started SoftUni at age 15-18 and graduated at age of 17-20, then started an exceptional IT career:

• Konstantin Gerov: https://linkedin.com/in/konstantin-gerov, https://github.com/kgerov
• Martin Mladenov: https://linkedin.com/in/martinmladenov, https://github.com/martinmladenov
• Daniel Yordanov: https://linkedin.com/in/daniel-yordanov-a63ab1208, https://github.com/DDeveloperBG
• Simeon Petkov: https://sites.google.com/view/simeon-petkov

Start Coding at Age of 19-25

When you are 19-25 years old, this is the time when you focus on your college education and career start. You are now a conscious person who has already taken his life into his own hands. This is how a typical GitHub profile of a college student looks like:

If you have missed your chance to start earlier, at this age you have a good chance to learn coding, along with your formal education.

• Typically, at this age you still don’t have children and mortgages, so you are free to invest in yourself. You are young and you have a lot of power and freedom to devote most of your time to learn the software engineering profession, while attending your formal college education.
• It is a very good time to start coding at the age of 19-25. Don’t miss this chance!
• Most of my students (30-40%) at SoftUni start at this age, when they study in a traditional university and they realize that they need modern practical tech education to boost their career start.
• Note: companies love candidates at this age, because they are young, full of power and have many years to grow as professionals. Your chance to start a job at this age, when you learn programming and build a strong project portfolio, is very high.

Look at these sample profiles of my students, who started SoftUni at age 19-25 and graduated at age of 21-26, then started their career as software engineers:

• Polina Mincheva: https://linkedin.com/in/polina-mincheva-4040481b7, https://github.com/polly-rm
• Alexander Gruev: https://linkedin.com/in/alexander-gruev, https://github.com/Alexander-Gruev
• Rosen Santev: https://linkedin.com/in/rosen-santev-34864b202, https://github.com/R-Santev

Start Coding at Age of 26-35

When you are 26-35 years old, this would be a slightly painful career change to learn programming and start a tech job. It is possible, but you should be ready to pay the price. This is an example of SoftUni student who started coding at this age range:

In modern world people massively change their career path from other professions to the IT industry for better career perspectives. It is quite possible, even common to change your career, but it might cause some discomfort, so prepare yourself!

• You should be ready to learn under stress. Typically, you should combine your coding lessons, exercises, assignments, projects and exams with your daily job, while taking care of your children (if you have) and paying your mortgage to your housing (if you have). Still, thousands of people have strong will and succeed in their career change at this age range.
• At age of 26-35, it is challenging to become a software developer, but many, many people do it successfully.
• Most people who learn coding at this age suffer from lack of time and sometimes lack of sleep. People who survive this discomfort and keep coding, become developer and start a tech job.
• In most cases you should be ready to start with a smaller salary than your current non-developer job. A junior developer salary is typically smaller than a senior salary from non-tech jobs.
• Most of my students (35-45%) at SoftUni start at this age, with a career change. Typically people from engineering professions learn coding easier, with less effort. People with non-engineering and non-math background typically have difficulties (e.g. artists, sportsmen, baby-care workers, etc.).
• At SoftUni I have students who became software developers from: architects, constructors, mechanical engineers, civil engineers, aviation engineers, mathematicians, physicists, teachers, financial professionals, etc. Sometimes I have people entering into software development from unusual professions like hair-dressers, musicians, medical doctors, or even poker players, but these are rather exceptions. People who have strong algorithmic / math thinking, learn coding fast.
• Hint: don’t put your age in your CV, because some companies will reject your job application because they prefer younger candidates. You are not obligated to declare your age, unless explicitly asked. Put a photo in your CV, where you look young and full of energy.

Look at these sample profiles of my students, who started SoftUni at age 26-35 and graduated at age of 28-32, then switched their career to software engineering:

• Marina Kolova: https://linkedin.com/in/marina-kolova, https://github.com/marinakolova
• Martin Taskov: https://linkedin.com/in/martin-taskov-9b7900159, https://github.com/megadeth91
• Liliya Ignatova: https://linkedin.com/in/liliya-ignatova-551918109, https://github.com/l-ignatova

Start Coding at Age of 35+

Yes, it’s not too late to start coding at age of 35 or 37 or even 40+! I have many examples of successful career changers at age of 35+ who learned coding at SoftUni and joined the software industry. This is how a typical GitHub profile could look at this age:

It takes more effort and time, but it is possible to learn programming from scratch, build a GitHub portfolio and start a tech job at age of 35+ or even 40+. I will give you examples below.

• At age of 35+, it would be a very challenging career change to learn programming a start a tech job. It is possible, but you should be ready to pay the price.
• People with strong will and real passion for the software development profession will succeed. You may have time, but you should stay motivated and work hard for 2-3 years until your first tech job.
• Prepare to fall from a height when you will get several times less for your new job at the start than for your old job. You should be highly motivated.
• If you have a previous coding background or if you already work in the tech industry but you are not a developer, it will be easier to switch your career at this age. For example, if you an IT project manager, or PLC programmer or IT teacher, you may switch your job easier than if you are a musician or gardener.
• At SoftUni I have many students who become developers at age of 35+ and started a developer job, but only highly motivated people succeed.
• Note: because of your age, you should put special efforts to avoid revealing how old are you. Pay attention to your CV, LinkedIn profile, GitHub profile, etc. Not revealing your age will help you not being rejected by the recruiters before reaching a technical job interview.
  • Use photos when you look younger and full of energy.
  • In LinkedIn don’t put the years of your school and college graduation. Don’t lie, but avoid revealing information, which makes it obvious that you are 35+ years old.
• Note: your age will be revealed at the job interview, so you should be a strong candidate to get the job. Be sure to follow diligently all the recommendations about your portfolio, job preparation, job application and interview preparation!

Look at these sample profiles of my students, who started coding at age 35+ and graduated SoftUni at age of 37+, then switched to an IT career:

• Plamen Rusanov: https://linkedin.com/in/plamen-rusanov-742678152, https://github.com/plamenrusanov
• Denitsa Lips-Pesheva: https://linkedin.com/in/denitsa-lips-pesheva-94037a105, https://github.com/Dpessheva
• Irena Mikovska: https://linkedin.com/in/irena-mikovska-201161169, https://github.com/irenamikovska
• Angel Raychev: https://linkedin.com/in/angel-raychev, https://github.com/Araychev

Invest in Yourself: Learn → Build Portfolio → Start a Job

If you are still reading this guideline on “How to Start Your First Developer Job“, you should remember the most important key points from it:

• Your carefully prepared GitHub profile is your strongest asset to start a developer job! Your portfolio of practical projects is the proof your experience and it is the best way to demonstrate that you match the job requirements.

• To learn software development and start a tech job, you need to invest 2000-3000 hours in coding. This means to spend from 6 months (intensively) to 2-3 years (part time) to develop your skills and write 100K-150K lines of code in your GitHub repository.

• Starting a developer job is 95% preparation (study, practice, experience, job research, matching the job requirements) and only 5% to apply for a job and eventually reach a job interview.

Follow this first dev job guide and you will succeed! Already 16K young people learned programming and started a tech job with SoftUni. Join them at:

https://softuni.org

Invest in your skills, learn programming and start a tech job.