How to Start Your First Developer Job?

Many of wanna-be-developers ask me how to start their first software developer job. In this 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 IndustryTLDR: Build a GitHub Portfolio of Software Projects to Prove Your Skills and Start a Job!

Software companies want proven skills and experience to hire you as a junior developer. This experience is your GitHub profile, which you should 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.

About 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 educationPortfolio: 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)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 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 timeframePlay 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

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-329a58171GitHub: https://github.com/tsonewa (350 commits in the period 2021-2022)LinkedIn: https://linkedin.com/in/dimitrinka-tsoneva-65650b105GitHub: https://github.com/mischelll (520 commits in the period 2019-2020)LinkedIn: https://linkedin.com/in/mishel-ivanov-703094191GitHub: https://github.com/alexmehandzhiyska (450 commits in the period 2021-2022)LinkedIn: https://linkedin.com/in/alexandrina-mehandzhiyskaGitHub: 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 MyApp2Short 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.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 or ReplIt or AWS 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/nakov/ContactBookhttps://github.com/nakov/Eventureshttps://github.com/nakov/ShortURLhttps://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!

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.

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:

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 cod from the tutorial in a GitHub repo, named “PostgreSQL-projects”. 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

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 easier 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 99% fail, 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 should consist of:

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 projectsMy 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!I am the right candidate for this position, because [personal qualities]. I have the right 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 prove 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. Remember this!

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. You could find thousands of guidelines in Internet:

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

Much more important is 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. In Internet you could find thousands of good and bad examples. I leave this step to you.

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: 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:

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).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).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.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.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:

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 good resources. Examples:

https://google.com/search?q=junior+java+interview+questionshttps://google.com/search?q=junior+javascript+interview+questionsThe 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, ask him for advices, for mentorship and a for a code review. Do submit a project, which is far away from your skills. You will fail to defend you project later during the job interview.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!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 (at 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) 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.