The Junior Developer Survival Guide: three pillars for success
Tags: career, beginners
Published: 2020-01-31 22:11:43

Are you a recent CS grad who just started a new job as a junior developer? Or maybe a self-taught developer on the lookout for a new job? You’re where every software developer once began! Starting out as a junior developer comes with its unique joys and challenges. Today, we will go through all you need to know to survive as a junior developer. Our goal is to cover topics not commonly tackled in technical tutorials. Let’s jump right in!

Here is what we will cover today

* Part 1: The three pillars for success as a junior developer

* Part 2: Five red flags to look out for on the job

* Part 3: Ten small bonus tips to keep in your back pocket

* Part 4: Complete resource guide for junior developers


___

# Part 1: The three pillars for success



Jumping headfirst into the tech industry can be overwhelming. To get you started on the right foot, let's walk through the three pillars for career success as a junior developer. We hope to keep you pointed towards satisfaction and growth on the job!

## Pillar One: Professionalism

Technical skills will only get you so far in real-world business. Even if you were top of your class, you may not be prepared for the rigor of the professional world. Professionalism is key to surviving as a junior developer, no matter what your long-term goals may be. Professionalism can roughly be defined as a set of behaviors, attitudes, and habits that characterize a professional person and align them with their company’s values. Let’s break down professionalism as a junior developer into five key points. 

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/6ey09i5cyl6pi9xmilgj.png)

### 1. I ask questions when I don't understand something 
 

It’s not easy to admit when you don’t know something, and it’s especially challenging to know how to ask the right questions when you’re in need. But amateurs or beginners who pretend to know all the answers fall back on old habits, get left behind, or even end up looking foolish. Professionalism means being honest about your work, your knowledge, and your eagerness to improve. *Asking questions is essential to career success.*

Whether or not you see them now, there are inevitable gaps in your knowledge when you’re starting out, and asking questions empowers you to continue learning and become more specialized in your company’s needs. 

If you get stumped or confused, you may fear that your coworkers will think you’re dumb or undereducated. But in reality, people want to help others. On top of that, asking questions demonstrates an eagerness to work well on your team. 

While it’s true that there is no stupid question, there are better and worse ways to ask questions, and learning how to ask good questions will save you time and prevent frustration. 

Start by asking yourself,
* Have I understood the code to the best of my ability?
* Have I checked with reliable sources like StackOverflow?
* Have I used a debugger program to help me with this problem?

If you have tried your best to solve the problem on your own, it’s time to ask for help. The best way to ask questions is to contextualize your question and explain your process for the person you are asking. Point to exactly where you went awry, what you think went wrong, and what you did to fix it. For a more detailed breakdown of how to ask good questions about your code, take a look at [this article](https://medium.com/@gordon_zhu/how-to-be-great-at-asking-questions-e37be04d0603).

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/e93vukws2psvolmprf0h.png)

### 2. I seek mentorship with experienced developers 

Having a support system will not only make you a better worker; it will also make you a more fulfilled person as well. Having people at your side for aid, advice, or even just a listening ear can transform your work environment. Professional mentorship relationships create a space for you to engage with professional expertise in your field.

You may not be assigned a mentor like you were in college, so it’s important to seek out mentorship from someone who is invested in your success. This doesn’t have to be a formal relationship; even just regular chats with a more seasoned developer is a great place to start. And since you are turning to work for the same company, everything you learn from these allies will be rooted in practical application on the company’s codebase and culture. 

If you’re unsure how to develop a mentorship relationship, start just by taking an interest in other people’s work to build connections. Another easy way to seek out mentorship is to share your milestones. Involve other people in your progress, and they will want to see you succeed. 

> *Pro tip: We recommend finding a mentor who has 5-10 years on your experience level so that they have valuable insight without being directly in competition with your work.*

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/qypomgaaw5zy7xkpn24t.png)

### 3. I ask for feedback on everything I do 

Professionalism means having an attitude toward professional growth. Your goal as a junior developer is not to be perfect; your goal is to learn your craft. This means that you will make mistakes along the way. Just as it is important to ask questions, it is also important to ask for feedback directly, especially if your company doesn’t already have a system in place for technical reviews. Seeking out opportunities for feedback is a way to demonstrate professionalism in an action-oriented way. 

You shouldn’t just ask for feedback on the technical aspects of your job but also on your day-to-day habits and practices. Getting feedback about your role in the workplace extends to how you fit in with your coworkers, how you communicate, and how you organize your time. 

The key to asking for constructive criticism is to be prepared for honesty. Don’t mistake feedback as an opportunity for praise. Instead, think about asking questions like these:

* What is something I could do differently that would add value to our team?
* What is something you would like me to stop doing?
* What is something you would like me to start doing? 

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/iswxqxbi746m1r8lquz6.png)

### 4. I stay organized with my work and time 

Organization is key to professionalism in every field, especially software development! Those who can’t stay on top of their work or time stand out as a red flag to employers and managers. Let’s discuss two easy ways that you can stay organized as a junior developer.

**Take notes.** On the job, you will be learning every day, correcting mistakes, hearing terminology you might not know. Taking notes is a great way of ensuring that this new knowledge doesn’t get lost. From documenting questions you have to recap conversations with mentors, to writing down a word you didn’t know, taking notes will empower you and your career in the long run. There is no right way to take notes, and it absolutely does not have to be a formal system. Even just a small notebook to scribble down your thoughts or questions is enough. 

**Practice time management actively.** Time management is notoriously challenging for developers of all levels, so get started now in the early years of your career working on this skill set. The key to time management is effective communication. State your needs early on, and never make promises you cannot keep. Since you are early in your career, consider tracking your work strategically for organized and action-oriented data. You can check out our [article here](https://www.educative.io/blog/10-tips-for-managing-time-estimations-on-coding-projects) for more tips on that. 


![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/jm1pz373cia7w7xndkfv.png)

### 5. I maintain healthy work boundaries. 

Professionalism means setting clear boundaries about your time, work ethic, and commitment. Setting healthy work boundaries means taking responsibility for your actions and attitudes, and taking no responsibility for the actions or miscalculations of others. Being able to negotiate the difference is a skill that comes with time and practice. 

As a junior developer, you may not yet know what your work boundaries are, and that’s okay. The key is to communicate and pay attention to your emotions as things arise. Here are a few tips on setting healthy work boundaries. 

**Learn more about yourself:** Everyone has different values, triggers, and needs. Learning yours early on in your career is incredibly empowering, and it makes communication all the easier. Consider taking some personality tests like Strengthsfinder, The Enneagram, DiSC, or True Colors, amongst many others. 

**Communicate clearly and early on:** don’t wait until your feelings boil over to express how you feel. Learning how to be effectively assertive is key to your career as a junior developer.

**Maintain structure at work:** Having an agenda sets you up for success and prevents others from taking advantage of your time or getting lost in the weeds. 

**Prepare for things to go wrong:** The professional environment will not be perfect, and that’s okay. When things go awry or a boundary is broken, it’s an opportunity to regroup, communicate, and practice better boundary setting. 
 
___

## Pillar Two: Soft Skills 


Your technical skills are essential to your potential and aspirations as a developer, but you will fall behind if you only bring tech skills to the table. The difference between an employee and a professional is a person’s soft skills.

Why are soft skills so important? Let’s discuss three reasons. 

**You will stand out to non-developers.** You need to learn to speak the language of non-developers. Just having hot tech skills won’t get you far because non-developers cannot necessarily relate to you or understand the value it brings. Soft skills, like communication, team building, etc., are universal and enable people in other departments to notice you, care about your work, and become invested in your role.

**Tech skills change and are replaceable.** You need to bring something else to the table if you are in this for the long-haul. The hot new thing you devote all your energy to may be irrelevant in a few years. But developing an optimistic, supportive attitude towards your team? Well, that’s a skill that will never go out of fashion. If you want to play the long game and seek promotion, don’t get too distracted by the shiny object of the fanciest new technology. Turn to the good old fashioned soft skills to dig in your roots. 

**You’ll become a problem solver.** A developer is really just a problem solver at the end of the day. Only being good at hard, tech skills means you probably don’t understand the wider application of your work, and you may miss things. Focusing on soft skills tunes your mind towards human needs. You’ll likely create more intuitive and helpful products for your customers or company. 

So, what are the soft skills that you need to be a good junior developer? Let’s discuss five.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/dfyyqjw0qzyla4nnm1q5.png)


### Teamwork. 
Being a developer does not mean you are sitting alone in a basement with a computer. You will almost always work on a team, cross-check your work with others, and collaborate to get problems solved, even if you work remotely. Teamwork means recognizing strengths in others and respecting boundaries. 

### Adaptability. 
Every project you work on will be a little bit different: different frameworks, different setup, different goals, different team members. Being adaptable will make you a happier, more effective worker who has a lot less catch up to do! 

### Curiosity. 
You need to be curious about why things are or aren’t working to fix or improve them. Being curious leads to best practices, creative solutions, and new passions. Those who like to tinker and figure things out are some of the best developers out there. 

### Listening. 
Listening to others is essential to succeeding as a developer, especially when you are working with non-developers who may not know the same lingo but have important requests or ideas for your work. 

### Critical Thinking. 
Critical thinking is all about problem-solving. Critical thinking engages with the *why* question of a problem before jumping right to an answer. Why is this happening? How can that be improved? This skill allows you to analyze your work, the codebase, etc, before rushing into an ineffective or incomplete solution. 

___

## Pillar three: Technical competency 

Building tech skills is the foundation to your career. And remember: being a developer means you will always have to update and reskill as the industry changes. So, let's discuss a few ways you can jumpstart that tech journey.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/iafc8d4cn3j786y9isou.png)

### 1. Choosing your language(s)


There’s a lot of discussions out there as to which languages are best for junior developers to know. Many junior developers stress over their hire-ability because of their lack of programming language knowledge. Let’s dispel some of those concerns today. 

*The truth is simple: it does matter what languages you know, but not for the reasons you might think.* 

**Use a language that is easy to read.** As a junior developer, you will have a lot of technical reviews, so picking a language with simpler syntax will generally save you time and make your life easier

**Use a language that many of your coworkers/peers use.** Popular languages are, well, popular for a reason. Generally, using a programming language that is familiar to your peers is a good idea, as it encourages collaboration. You may also choose a language based on your career aspirations. Take a look at the most common languages for these fields: 

* Web development: PHP, HTML, JavaScript, Java
* Desktop programs: .NET, C++., Java
* Game development: C#, C++, Python 
* Machine learning: Python, C++, R

**Use a language with lots of cool add-ons.** Some programming languages have more features than others, and as a junior developer, it’s a good idea to turn to these to save time and energy. Languages with built-in dev tools mean you can make cool things way easier. 

**Use a language that is comfortable for you.** As a junior developer, you already have a lot to learn and figure out, so using a language that feels second-nature to you will make your work easier and more enjoyable.

___

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/qmw5jud3f9s09hnmzzd8.png)

### 2. Things that may be more important than your language skills

Yes, your language skills matter, but there are other technical skills that set you apart as a junior developer. These are skills that will carry you forward in your career. Let’s discuss what other technical things you should be investing in at this stage in your career. 

**Software/Computer Architecture:** These skills are necessary for a successful career down the line. This knowledge helps you develop a bigger picture of your role on a team. And understanding how your computer works is required for all developers who want to reach beyond. At this stage, you should learn about UML charts, MVC patterns, RAM, and CPU. 

**System Design:** System design knowledge makes you a more employable developer, as it shows more generalist skills. 

**Databases:**
Databases can add a lot of flexibility and value for junior developers. If you want to make it beyond the (sometimes arbitrary) “junior” title, you need some knowledge of SQL. It will help you understand how your code scales and performs, and it’s just interesting, at the least!
___

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/3p10f69owm3mdktu4qxt.png)

### 3. Writing and navigating code

**Write shorter methods.** Junior developers tend to write long functions and methods, which can clog up the code and may not work at a very high level. Lengthy methods are hard for external readers to follow or understand, and it can slow down production. Learning how to write short methods will save you in the long run. The easiest way to practice this is to start with your long method and break it down into private methods to eliminate unnecessary steps along the way to produce cleaner, more readable code. 

**Learn through your side projects**. Side projects give you a playground to explore, develop passions, and build your experience without timelines or harsh consequences. Programming skills come through hands-on practice, and nothing feels better than completing a cool passion-project. You could build an interactive portfolio or an app that is tailored to your restaurant preferences. Think of little problems in life and try to solve them in an exploratory way. You’ll learn valuable skills, feel more confident, and make something fun. 

**Take code reviews seriously.** Code reviews may be intimidating at first, so it’s important to remember that these aren’t criticisms but constructive opportunities for improvement. If you were educated in university, this may feel like you are being graded for your work, but that is not the case. Try to remove the lens of a rubric and think more like a problem solver who is being taught a more effective solution. You can gain valuable insight into new approaches, company practices, and places you need to improve.  

**Commit to your IDE/text editor to increase productivity.** The more familiar you are with your tools, the quicker you work. You will know the shortcuts and be more in-tune with your workflow. Invest the time in your text editor, and it will help you succeed. Learn the shortcuts; utilize the suggestions for code improvements offered by modern IDEs like IntelliJ or Eclipse. Work smarter, not harder. 

**Learn how to zoom out.** It’s easy to let your focus narrow when you’re trying to solve a problem or debug code, but it’s important to remember that everything you do needs to fit within the whole system. What unexpected side effects may this have on the code? Is this consistent with the rest of the codebase? A more experienced developer knows that zooming out is key to succeeding. So, as you get started as a junior developer, remember to zoom out, especially when you get stuck or frustrated. 

**Learn to recognize good industry code.** Read a lot of it. As a junior developer, you aren’t expected to write everything from scratch. You’re going to use a lot of code written by others, so it’s important to know how to recognize good industry code. Good industry code should be three things: readable, defensive, and optimized. 


**People who read a lot tend to be better writers.** The same goes for developers. Reading other people’s code will make your code better. You’ll catch techniques and simplifications that you might not have thought of on your own. Recognize good code; read it; learn from it. 

**Use visualizations to solve problems.** If you get stuck, try using visuals to solve the problem. Sometimes your brain just needs to see the logic in a different way to understand the solution. Use visuals, whiteboards, or metaphors to get to the perfect solution.

___

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/4b7z22q4q0elitlyn1k4.png)

### 4. Invest in your ongoing education. 

You've probably heard this before, but your ongoing education is essential to the longevity of your career. The industry changes a lot, and since developers are solving real human problems, we need to always be actively seeking the best solutions. There is no one right way to keep yourself educated, but here are some simple ways to stay engaged with your tech skills. 

**Read blogs and forums.** Open-source material is your new best friend. You should be reading blogs and articles every week. Reading free content exposes you to trends in the industry, new technologies, innovative solutions, and more. See our resource list below to get started with some amazing free blogs. 

**Take online courses.** Online courses are an easy way to engage with your ongoing education in a hassle-free way. You can learn a new language, a new dev tool, or even tackle something like machine learning, all from your own home. Check out [Educative's online courses](https://www.educative.io/learn) for reliable, stress-free courses on need-to-know topics. 

**Contribute to open source.** One of the best ways to learn is to teach. As you move forward in your career, share your story, your successes, and your ideas. You'd be surprised how much you can learn!

**Try [pair programming](https://en.wikipedia.org/wiki/Pair_programming).** An easy way to engage with your ongoing education is to learn by watching others. Pair up with another programmer to see how they solve challenging problems. Be sure to ask questions along the way! 

___

# Part 2: Ten red flags to look out for on the job 

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/jbs3j5mqo4feljdzija4.png)

No job is perfect, but some are a lot *less perfect* than others. To empower you as a junior developer, we want to share 10 red flags to watch out for in a company. Keep in mind that these things can be hard to notice. So, of course, just because a red flag appears doesn’t mean you should run away or quit. Let’s jump in. 

1. **The company does not provide opportunities for continued education.** Watch out for a company that thinks of continued education as something developers should do in their “free time”. This is a sign that a company is not invested in your long-term. 

2. **The company does not provide peer/technical reviews.** This is likely a sign that the leadership is not willing to receive feedback themselves, which can lead to toxic work dynamics. It may also be a sign that they will be inflexible with your mistakes.
 
3. **The company only uses the hottest, newest technologies.** This is likely a sign that their systems are vulnerable or subject to unnecessary change. There is wisdom in using tried-and-true approaches as a foundation. 

4. **The company isn’t diverse.** This is a bit of a no-brainer, but companies that aren’t diverse likely have deep issues at their core. Diversity can take many forms (i.e. gender, race, ability, lifestyle, etc), and any group of people needs to have different kinds of people otherwise we get stuck in old ways, solve the same problems, and do great harm, even if we don’t set out to.  

5. **The company won’t onboard you.** Not being properly on-boarded may set you up for disaster and insecurity on the job. Even if there is not an onboarding process in place, you should at least be given a point-person/advocate for questions.

6. **The company “motivates” you with ultimatums.** There is a difference between a deadline and an ultimatum. You should never feel manipulated into working overtime or making promises you can’t hold to.

7. **The company relies on indirect communication or tacit rules.** This isn’t “A Few Good Men”. The company rules and expectations should be clear to you from day one. This may be a sign of passive aggressive management, which is rarely a good time. 

8. **The company relies on non-technical people to make all technical decisions.** This will happen on occasion at any company, but an organization that doesn’t respect the expertise or voice of the technical team may lead to disaster. Watch out for companies that are intensely top-down oriented. 

9. **The technical team avoids documentation.** Poor organization on a team-level will lead to difficulties, extra work, stress, and more. Some companies may just not have a good system in place, which is workable, but you want to watch out for a team of lazy developers who avoid documentation. It will come back around, and not for the good. 

10. **The company controls your workflow.** As a junior developer, you absolutely need to be taught workflow and best practices, but that is different than being controlled. Every person works differently. If your team or manager is hyper-rigid with the way you work, it may be a sign that they are inflexible.

___

# Part 3: Ten small bonus tips for your back pocket

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/ujrwauxdxjqcjqqp9t4l.png)

1. Familiarize yourself with coding lingo to feel more confident in the field 

2. Build your CV on the side through small, passion projects

3. When marketing yourself, avoid calling yourself a programmer or junior developer

4. Learn some design theory, storytelling techniques, and graphic art skills to improve your ability to think critically and develop cool products.

5. Don’t ignore the world outside of your work - you are more than a developer! 

6. Contribute to open source

7. Reduce social media usage to a minimum, especially when you’re trying to learn something new

8. Embrace the work of debugging - it makes you a better developer 

9. Consider being open about your salary to [combat pay inequality](https://www.nytimes.com/2018/08/31/smarter-living/pay-secrecy-national-labor-rights-act.html) 
 
10. Familiarize yourself with the [SOLID](https://scotch.io/bar-talk/s-o-l-i-d-the-first-five-principles-of-object-oriented-design) development principles

___

# Part 4: Resource guide for junior developers 

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/ui4dmo5dx639uyp65vuu.png)

One of the great parts about being a junior developer is the sheer amount of information available to you for free. If you have a question, if you need advice, it’s certainly already out there. All you have to do is ask. We’ve compiled a list of some reliable resources that every junior developer needs to survive. 

### Books
* [Clean Code by Robert C. Martin](https://www.amazon.ca/gp/product/0132350882/ref=as_li_tl?ie=UTF8&tag=stemmlerjs09-20&camp=15121&creative=330641&linkCode=as2&creativeASIN=0132350882&linkId=63a7fb47960db0590eabb58edf25aee5): on how to write readable, maintainable code and set boundaries at work 

* [When I Say No, I Feel Guilty](https://www.amazon.com/When-Say-No-Feel-Guilty/dp/0553263900)by Manuel J. Smith: on how to assert yourself effectively
 
* [Refactoring by Martin Fowler](https://www.amazon.ca/gp/product/0134757599/ref=as_li_tl?ie=UTF8&tag=stemmlerjs09-20&camp=15121&creative=330641&linkCode=as2&creativeASIN=0134757599&linkId=cd665cc1a6483955a2d51dd2d1a576d1): guide and techniques to refactoring an application

* [Soft Skills: The Software Developer’s Life Manual by John Sonmez](https://www.amazon.ca/gp/product/1617292397/ref=as_li_tl?ie=UTF8&tag=stemmlerjs09-20&camp=15121&creative=330641&linkCode=as2&creativeASIN=1617292397&linkId=d1e4c3b453d124d01e886aab876c8ff9): how to strive for a well-balanced life as a developer

* [The Complete Software Developer’s Career Guide by John Sonmez](https://www.amazon.com/gp/product/0999081411/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=sandordargo-20&creative=9325&linkCode=as2&creativeASIN=0999081411&linkId=4352bf7508b6d1ed74a0ee74960b831e): how to develop healthy habits inside and outside the workplace 

* [The Effective Engineer by Edmond Lau](https://www.amazon.ca/gp/product/0996128107/ref=as_li_tl?ie=UTF8&tag=stemmlerjs09-20&camp=15121&creative=330641&linkCode=as2&creativeASIN=0996128107&linkId=c26139ec47911c60569dc5851da21d06): how to manage your time and be productive

* [Code Complete by Steve McConnell](http://amzn.to/2FhxGGU): techniques on writing maintainable code 

### Online Courses 
* [Grokking the Coding Interview](https://www.educative.io/courses/grokking-the-coding-interview) 
* [Learn a language from scratch](https://www.educative.io/m/learn-a-new-programming-language-from-scratch )
* [Grokking the System Design Interview](https://www.educative.io/courses/grokking-the-system-design-interview)
* [Grokking Computer Networking for Software Engineers](https://www.educative.io/courses/grokking-computer-networking)
* [Practice Data Structures](https://www.educative.io/m/data-structures-for-coding-interviews)
* [Practice Algorithms](https://www.educative.io/m/algorithms-for-coding-interviews)
* [DevOps for Developers](https://www.educative.io/track/devops-for-developers)

### Articles 
* [7 hard truths about starting a career as a developer](https://www.educative.io/blog/7-hard-truths-about-starting-a-career-as-a-developer)
* [Thinking one level ahead: your path to becoming a senior dev](https://www.educative.io/blog/your-path-to-becoming-a-senior-dev) 
* [An open mind is the key to career success](https://www.educative.io/blog/open-mind-is-key-to-career-success) 
* [Why a FAANG company may not be right for you](https://www.educative.io/blog/why-a-faang-company-may-not-be-right-for-you)
* [What software technologies will earn you the highest pay?](https://www.educative.io/blog/what-software-technologies-will-earn-you-the-highest-pay) 
* [Jobs you might not think to apply for as a Software Developer](https://www.educative.io/blog/jobs-you-might-not-think-to-apply-for)


### Forums/Blogs 
* [CodeBetter](https://twitter.com/codebetter?lang=en)
* [Geeks for Geeks](https://www.geeksforgeeks.org)
* [Hackernoon](https://hackernoon.com)
* [Dev.to](https://dev.to)
* [Daily JS](https://medium.com/dailyjs)
* [A List Apart](https://alistapart.com)
* [StackOverflow](https://stackoverflow.com)
* [Talking Code](https://talkingcode.com)
* [Coding Horror](https://blog.codinghorror.com)
* [Junior Dev Diaries](https://medium.com/coderlist)
* [The Ultimate List of Software Developer Blogs by Category](https://simpleprogrammer.com/ultimate-list-software-developer-blogs/)


### Coding Practice/Competitions 
* [HackerRank](https://www.hackerrank.com)
* [Daily Programmer Reddit channel](https://www.reddit.com/r/dailyprogrammer/)
* [Triplebyte](https://www.triplebyte.com)
* [LeetCode](http://leetcode.com)
* [CodeWars](https://www.codewars.com)
* [CodeSignal](https://codesignal.com)
* [CoderByte](https://coderbyte.com)
* [10 most popular coding challenges of 2020](https://www.freecodecamp.org/news/the-10-most-popular-coding-challenge-websites-of-2016-fb8a5672d22f/)