And yet the applications go out, and nothing comes back.

This is one of the most frustrating experiences in tech. You're genuinely learning, genuinely putting in the time, and you have nothing to show for it in terms of results. You start to wonder if the market is too competitive, if you need one more certification, or if there's some hidden door everyone else found that you're missing.

The truth is simpler and more actionable than any of that: hiring managers can't see your YouTube watch history. They can see your GitHub. Most beginners optimize for learning. Hired candidates optimize for proof.

In this guide, you'll get an honest breakdown of the nine factors hiring managers actually evaluate when they look at a junior cloud or DevOps candidate and a concrete 90-day plan to address each one. By the end, you'll know exactly where you stand and exactly what to do next.

Table of Contents

• The Three Patterns That Keep Beginners Stuck

  • Pattern 1: The Tutorial Loop

  • Pattern 2: The Theory-Practice Gap

  • Pattern 3: Silent Learning

• What Hiring Managers Are Actually Evaluating

• Factor 1: Proof of Work (The Non-Negotiable)

  • The Three Projects That Cover Everything

• Factor 2: System-Level Thinking

• Factor 3: Software Engineering Fundamentals

• Factor 4: Communication Skills

• Factor 5: Consistency Over Intensity

• Factor 6: Networking and Visibility

• Factor 7: Ownership Mindset

• Factor 8: Business Awareness

• Factor 9: Learning Agility

• Your 90-Day Action Plan

• Honest Self-Assessment: Where Do You Stand?

• Conclusion

• References and Recommended Resources

The Three Patterns That Keep Beginners Stuck

Pattern 1: The Tutorial Loop

Week 1: You watch eight hours of Docker content. Week 2: You start an AWS course and get 70% through. Week 3: A Kubernetes series looks interesting, so you start that instead. Week 4: You open LinkedIn and wonder why you're not getting callbacks.

Watching tutorials feels like progress. It's comfortable, passive, and has no failure state. Nothing breaks. Nothing goes wrong.

The problem is that it produces nothing a hiring manager can evaluate. Courses and certifications tell an employer what you've been exposed to. Your GitHub tells them what you can actually do.

Pattern 2: The Theory-Practice Gap

You can explain CI/CD fluently. You've read the Kubernetes documentation. You understand the conceptual difference between a container and a virtual machine.

But you've never taken a simple application, containerized it, connected it to a pipeline, and deployed it to a cloud server with a real URL that someone can visit.

In an interview, "I understand how it works" and "I have built this and here is the link" are not equivalent answers. Hiring managers hear the first version from hundreds of candidates. The second version gets callbacks.

Pattern 3: Silent Learning

This one is perhaps the most painful pattern because the learning is real. You're putting in the work every day but nobody knows. No GitHub activity. No LinkedIn posts. No community presence. Just cold applications sent from job boards to ATS systems that filter you out before a human ever sees your name.

The hard truth: people get hired through people. A hiring manager who has seen your LinkedIn post about a problem you solved is significantly more likely to give your résumé serious attention than a stranger who applied through a portal.

What Hiring Managers Are Actually Evaluating

I've grouped the nine factors that follow into three buckets: Mindset, Execution, and Visibility. The order matters: mindset shapes how you execute, and execution is what powers visibility.

Let's go through each one.

Factor 1: Proof of Work (The Non-Negotiable)

If there's one thing to take from this entire article, it's this: no portfolio means no serious consideration. The most technically capable candidate in the applicant pool is invisible without proof of work.

This isn't about impressing anyone with complexity. It's about demonstrating that you can take a system from zero to deployed, documented, and working.

Here's the checklist every portfolio project should meet before you consider it done:

• It's deployed: there's a real URL you can share, not "it works on my machine"

• It has a CI/CD pipeline: code changes are automatically tested and deployed

• Infrastructure is defined as code: not manually clicked together in the AWS console

• It has monitoring and alerting: you know when it breaks before users tell you

• It's documented: a README explains what it does, how to run it, and how it works

• It's on GitHub publicly: with real commit history showing iterative work

If your project meets all six criteria, you have proof of work. If it meets four of six, you have a project in progress. Finish it before you start applying.

The Three Projects That Cover Everything

You don't need ten projects. You need two to three projects that together demonstrate the full range of DevOps skills.

Project 1 : The Full-Stack Deploy Pipeline

This is the foundational DevOps project every beginner should build first.

Take any simple web application – a Python Flask app, a Node.js API, or even a static site. Containerize it with Docker. Write a CI/CD pipeline that runs tests, builds the Docker image, and deploys to a cloud server automatically on every push to the main branch. You can also set up Nginx as a reverse proxy and add an uptime monitor (UptimeRobot has a free tier).

Tools: GitHub Actions, Docker, AWS EC2 or Render.com, Nginx.

Why it matters to a hiring manager: it proves you can automate a full deployment workflow end-to-end. The hiring manager can visit your URL, see it running, and inspect your pipeline history.

This single project puts you ahead of most applicants who only have course completion screenshots.

Project 2: Infrastructure as Code with Terraform

Write Terraform code that provisions a complete environment: a VPC, public and private subnets, an EC2 instance with properly scoped security group rules, and an S3 bucket for remote state. Destroy it and recreate it from scratch to prove the code actually works. Add a GitHub Actions workflow that runs terraform plan on pull requests and terraform apply on merge to main.

Tools: Terraform, AWS (or Azure/GCP), GitHub Actions.

Why it matters: Infrastructure as Code with Terraform is a required skill at almost every company running cloud infrastructure. Showing you can write, version-control, and automate Terraform demonstrates a core professional competency.

Project 3: Monitoring and Observability Stack

Deploy a monitoring stack using Docker Compose: Prometheus scraping metrics from your application and the host, Grafana dashboards showing CPU, memory, request rates, and error rates, and Alertmanager configured to send alerts to Slack or email when thresholds are crossed. Connect this to your Project 1 application so the pipeline deploys and the monitoring watches it.

Tools: Prometheus, Grafana, Alertmanager, Node Exporter, Docker Compose.

Why it matters: most beginner portfolios have zero observability work. This project immediately signals that you understand production engineering, not just deployment. Any senior DevOps engineer or SRE reviewing your application will notice it and it will set you apart.

Factor 2: System-Level Thinking

This is the mindset that separates a DevOps engineer from someone who just knows a collection of tools. System-level thinking means you can see the whole picture, not just the part you happen to be working on at any given moment.

Here's the mental test hiring managers are running throughout your interview: can you trace a user request from the moment they click a button to the moment they see a response, and explain what happens at every layer in between?

Here's the full journey of a web request, the map of modern infrastructure every DevOps engineer needs to understand:

Why does this matter in an interview? Consider two candidates answering the question: "Tell me about a time something broke in production."

Candidate A: "The website was down."

Candidate B: "The load balancer health checks were failing because the app containers were running out of memory due to a memory leak introduced in the previous deploy. We identified it via memory metrics in Grafana, rolled back, and added a memory limit to the container spec."

Same incident. Completely different answer. System-level thinking is what makes the difference.

Factor 3: Software Engineering Fundamentals

Many beginners rush to learn Kubernetes and Terraform before mastering the foundations that make those tools make sense. This creates a knowledge structure that looks impressive but has no solid base underneath it.

Here are the fundamentals that actually matter and what to do if you have a gap in any of them:

1. Linux and the Command Line

DevOps tools run on Linux. CI/CD jobs run in Linux containers. SSH is the front door to every server. If the terminal makes you uncomfortable, you're not ready for a production environment. This is not a preference, it's a prerequisite.

Start with daily Linux practice. The Linux Foundation's free introductory materials are a solid starting point. And here's a solid freeCodeCamp course on Linux basics.

2. Networking Fundamentals

DNS, TCP/IP, HTTP/HTTPS, load balancing, firewalls, VPCs, subnets these concepts appear in every cloud architecture. Without them, Terraform and Kubernetes are magic boxes. Study the request flow in Factor 2 above until you can draw it from memory without looking.

Here's a computer networking fundamentals course to get you started.

3. Scripting: Bash and Python

CI/CD pipelines are scripts. Automation is scripting. If you cannot write a Bash script that reads a config file, calls an API, and handles errors gracefully your automation ceiling is very low. Fix this by writing one small, useful script every week. Solve real problems with code.

Here's a helpful tutorial on shell scripting in Linux for beginners.

4. Git and Version Control

Not just git commit and git push. Branching strategies, pull requests, merge conflicts, rebasing, and tagging releases are all standard practice in professional DevOps teams. Use Git for everything including your personal learning notes. Practice branching workflows intentionally.

Here's a full book on all the Git basics (and some more advanced topics, too) you need to know.

5. Docker and Containers

Docker is the universal packaging format for modern software. Understanding layers, multi-stage builds, volumes, networking, and container security is the floor not the ceiling. Every project you build should be containerized. Write your Dockerfiles by hand instead of copying them.

Here's a course on Docker and Kubernetes to get you started,

Factor 4: Communication Skills

Technical skills set your ceiling. Communication skills determine how fast you reach it. This is the most consistently underestimated factor among beginner DevOps candidates.

Two candidates with identical technical ability will have very different career outcomes based on how clearly they communicate. Here's what that looks like in practice:

Architecture explanation: Can you describe how your project works to someone who has never seen it? Can you draw the architecture on a whiteboard and walk someone through your design decisions and the trade-offs you made?

Trade-off articulation: "I chose X over Y because..." is one of the most powerful phrases in a technical interview. It shows you understand that every decision has pros and cons and you made a conscious, reasoned choice rather than just copying a tutorial.

Written documentation: A README is your project's cover letter. A well-written README with clear setup instructions, an architecture diagram, and documented decisions demonstrates engineering maturity that most beginners don't show.

Here's a quick test: open your most recent project on GitHub and read the README as if you're a hiring manager seeing it for the first time. Does it answer these questions?

• What does this project do, and why did you build it?

• What does the architecture look like?

• How do I run this locally, and how do I deploy it?

• What decisions did you make, and why?

• What would you improve if you continued working on it?

If you answered "no" to more than two of those rewrite the README before applying anywhere. This single action will meaningfully improve your response rate.

Interview communication: Hiring managers assess communication throughout the entire interview not just your answers. Thinking out loud, structuring your responses, and admitting uncertainty honestly are all evaluated.

Factor 5: Consistency Over Intensity

Hiring managers are pattern recognition machines. They look at your GitHub contribution graph, your LinkedIn activity, and your learning trajectory and form an impression before reading a single word on your résumé.

A binge-learning approach, 10-hour weekends followed by weeks of nothing produces a GitHub graph that tells the wrong story. Thirty minutes of focused daily practice for six months beats a monthly 10-hour binge. At the six-month mark, the daily practitioner has 90 hours of focused work. The binge learner has 60 with significantly worse retention.

Here's how to build consistency in practice:

• Pick a time slot in your day that you will protect. Thirty minutes is enough to make progress.

• Define a four-week learning sprint with a specific goal, not "learn Terraform" but "build and deploy a VPC with Terraform and write the README."

• Keep a private learning journal: date, what you studied, what you built, what confused you.

• When the sprint ends, evaluate what you built and plan the next one.

What to avoid: declaring publicly on LinkedIn that you're "grinding DevOps full time" and then disappearing for six weeks. The absence is noticed. Only commit publicly to what you will actually sustain.

Factor 6: Networking and Visibility

This is the factor most beginners resist most, and the one that makes the biggest practical difference in time-to-hire.

Most DevOps jobs are filled through people referrals, community connections, LinkedIn conversations. A warm introduction from someone who has seen your work outweighs fifty cold applications every time.

Here are three ways to build visibility without it feeling performative:

Community Engagement

Join communities where DevOps engineers actually talk: AWS User Groups, local DevOps meetups, DevOps Discord servers, Reddit communities like r/devops and r/kubernetes. You don't need to be the expert. Ask specific questions, answer what you genuinely know, and show up consistently. After three to six months, people will recognize your name.

LinkedIn Content

Post once per week about something you learned, built, or got stuck on. Not marketing – documentation. A post that says "This week I configured Prometheus alerting for a Docker Compose stack. Here's what tripped me up and how I solved it" attracts recruiters, leads to conversations, and builds a searchable record of your growth over time.

Asking Good Questions in Public

When you get stuck and figure it out, write it up. Post the solution in the same community where you asked the question. Answer someone else's version of the same question later. You position yourself as a helpful, engaged learner, exactly who hiring managers want to hire.

Here's a concrete three-month visibility sprint to follow:

By month three, recruiters searching for "DevOps" in your location will encounter your activity. Some of the best entry-level DevOps opportunities come from exactly this kind of low-pressure visibility.

Factor 7: Ownership Mindset

This factor is less about personality type and more about observable behavior. Hiring managers are looking for evidence that you finish what you start not just that you start things.

Here's what the contrast looks like:

Ownership mindset has three components. First, finish things: a complete, simple project is worth ten times more than ten incomplete complex ones. Second, take responsibility without blame when something breaks: ownership means identifying the cause, fixing it, and adding monitoring so it doesn't happen again. Third, self-direct your learning you don't wait for someone to tell you what to learn next. You see a gap, identify how to close it, and close it. This is what "junior who can work independently" actually means in job descriptions.

Factor 8: Business Awareness

Technical skill gets you in the door. Business awareness keeps you there and accelerates your career.

The core question hiring managers are testing is: can you connect your technical decisions to cost, uptime, and user impact? Infrastructure decisions are business decisions. Cloud costs are typically the second-largest engineering expense at most companies after salaries. A misconfigured auto-scaling group or a forgotten large EC2 instance can burn thousands of dollars overnight.

Here are a few benchmark questions worth being able to answer comfortably:

• If your company has a 99.9% SLA, how many minutes of downtime per month is that? (About 43 minutes.)

• If you move workloads from on-demand EC2 instances to Reserved Instances, what's the approximate cost saving? (Around 40–60%.)

• If your CI/CD pipeline takes 45 minutes per build and you run 20 builds per day, how much developer wait time does that represent weekly?

Most junior candidates can't answer these fluently in an interview. Candidates who can stand out immediately not because the questions are hard, but because so few people bother to connect infrastructure and business.

The simple habit to build: whenever you describe a technical decision in your project documentation or in an interview, add the business dimension. "I configured auto-scaling" becomes "I configured auto-scaling to handle traffic spikes, which eliminated the cost of over-provisioning and reduced our estimated monthly cloud spend by approximately $X."

Factor 9: Learning Agility

Everyone claims to be a fast learner. It's the most overused phrase in technology job applications. Here's how to make it actually mean something.

Saying "I'm a fast learner" in an interview is table stakes. The question is whether you can prove it. Proof sounds like this: "I had never used GitHub Actions before. I needed a CI/CD pipeline for a project I was building. In 48 hours, I had a working pipeline that runs tests, builds a Docker image, and deploys to AWS."

What makes that credible: it names a specific tool, a specific timeframe, and a specific outcome. There is a GitHub repository with a commit history and a working pipeline that a hiring manager can actually look at.

Learning agility is not about knowing many tools shallowly. It's about picking up new tools quickly because you deeply understand the underlying concepts. Tool names change every few years. Concepts networking, automation, observability, reliability do not.

To build a concrete track record of learning agility: once a month, pick one tool you haven't used. Follow its quick-start guide. Build something small. Document what was difficult. Post about it. This is your learning agility portfolio visible, dated, and specific.

Your 90-Day Action Plan

Here is a concrete, sequential plan that takes you from where you are now to your first DevOps interview-ready state.

Month 1: Build Your Foundation

Focus entirely on Project 1 from the Proof of Work section. Build it completely. Deploy it. Get the live URL. Don't start Project 2 until Project 1 meets all six checklist criteria.

Alongside the build: 30 minutes of Linux and Bash scripting practice daily. This isn't optional, it's the foundation everything else runs on.

Month 2: Expand Your Execution and Start Your Visibility

Begin Project 2 (Terraform IaC). Write your first LinkedIn post, it doesn't need to be polished, it needs to be specific. Join one community and introduce yourself.

Month 3: Complete the Portfolio and Document Everything

Finish all three projects to full checklist standard. Polish every README. Add architecture diagrams. Optimize your GitHub profile, pin your three best repos, write a profile README that describes who you are and what you build, and add links to your live project URLs.

Month 4 Onward: Apply with Strategy

Don't start applying before month four. Apply with real proof of work in hand. Target five to ten quality applications per week rather than spraying a hundred. Include your GitHub and your best project's live URL in every application. For roles at companies where you have a community connection, reach out to that person before applying.

Track every application in a spreadsheet: company, role, date applied, status, outcome, notes. After thirty applications, you'll have enough data to see what's working and what isn't.

Here's the full 90-day breakdown:

Honest Self-Assessment: Where Do You Stand?

Go through each statement below. Be completely honest: this is for you, not anyone else.

Count your "no" answers. Each one is a specific, actionable gap, not a vague sense of being behind. That's the difference between this self-assessment and the anxious feeling of "I'm not ready yet." You're not behind. You just have a prioritized list of what to build next.

Conclusion

Here's what you know now that most beginners still don't:

The gap between you and a DevOps job isn't a gap in certifications, a gap in courses completed, or a gap in the number of tools you've heard about. It's a gap in proof of work, visibility, and the consistency with which you execute.

Hiring managers aren't looking for someone who has watched everything. They're looking for someone who has built something, documented it, deployed it, monitored it, and can clearly explain every decision they made along the way.

The path isn't secret. It's just work. Build two to three complete projects that meet the full checklist. Document everything. Show up consistently in communities and on LinkedIn. Apply with strategy. Iterate based on feedback.

If you want a production-grade reference to support your DevOps journey complete with real Terraform modules, CI/CD workflow templates, infrastructure runbooks, and platform engineering patterns used in real startup environments The Startup DevOps Field Guide was built for exactly this stage of your career.

The information gap between you and your first DevOps role is smaller than you think. The execution gap is where the work is. Start today.

References and Recommended Resources

• roadmap.sh/devops: The community-maintained DevOps learning roadmap. Use this to sequence what you learn next and avoid random jumps between topics.

• DORA State of DevOps Report: Free annual report on what DevOps practices actually improve software delivery performance. Gives you the vocabulary hiring managers speak.

• Linux Foundation - Introduction to Linux: Free introductory Linux course. If the terminal still makes you nervous, start here.

• The Phoenix Project: A business novel about DevOps transformation. Teaches core concepts through story. Gives you vocabulary for business-aware conversations.

• ExplainShell.com: Paste any command you find online and see exactly what every part does. Use this constantly while building your projects.

• GitHub - How to Write a Good README: Official GitHub guidance on repository documentation.

• Prometheus Documentation: Official docs for the monitoring tool used in Project 3.

• Terraform Getting Started - AWS: Official step-by-step guide for Project 2.

• GitHub Actions Documentation: Complete reference for building CI/CD pipelines in Project 1.

• freeCodeCamp - Learn Linux for Beginners: Comprehensive Linux guide available on freeCodeCamp.

I've answered technical questions one-on-one with the CTO and in a group with the dev team. I've taken quizzes with a timer and built features into existing apps in live mode.

I've live coded algorithms, done take home assignments, and demonstrated my system design skills.

And all this has given me a lot of knowledge and experience that I want to share with you now.

In this guide, I'll share my top tips, recommendations, and checklists to help you prepare for and pass your technical interviews. These will level up your game and increase your chances of getting a job.

What We'll Cover:

• Introduction

• The Secret That Will Increase Your Interview Performance By 53% (at Least It Did For Me)

  • 1. Big Tech / FAANG-level Companies

  • 2. Mid-size Product Companies / SaaS

  • 3. Startups (Early-stage)

  • 4. Design Agencies / Creative Studios

  • 5. Enterprise / Corporate Companies

  • 6. E-commerce & Marketing Agencies

  • 7. AI-first / Modern Tech Companies

  • 8. Freelance / Indie / Micro-SaaS

• Step 1: Building a Strong Foundation in Core Web Development Concepts

• Step 2: Going Deeper Into Subject Matter

• Interview Preparation Guide

  • 1. Answer Technical Questions (1-on-1 / Many-to-1)

  • 2. Go Through Quizzes with a Timer

  • 3. Build Features into Existing Apps (Live Mode)

  • 4. Live Code Algorithms

  • 5. Take Home Assignments

  • 6. System Design

  • A Fun Story

• Most Important Part

  • PDCA Framework

• Conclusion

  • P.S.

Introduction

The technical interview is designed to test how you think, code, and communicate. It's about both explaining your reasoning and showing what you can do. Think of it like a performance: the more you practice, the more natural and confident you’ll feel when you're actually doing it.

You’ll usually go through three main steps:

• Technical screening: a short 15–30 minute call to check your basics and interest in the role.

• Coding challenge: you’ll solve problems either through a take-home project or a live coding test. This shows how you write, structure, and test your code.

• Whiteboard interview: you solve problems on a shared screen while explaining your thinking out loud. It’s less about being perfect and more about how you approach problems.

During these stages, interviewers focus on a few key areas:

• Data structures: Ways to organize data (like folders in a filing system).

• Algorithms: Step-by-step methods to solve problems.

• System design (for senior roles): Planning how large systems work, similar to designing a building that supports many users at once.

Overall, they’re looking at how you think, not just what you know.

The Secret That Will Increase Your Interview Performance By 53% (at Least It Did For Me)

The secret is: narrow your focus.

Before you spend even one minute preparing, specify exactly what type of company you want to work for.

Why?

Because this choice will reveal what exactly you'll have study and practice before your technical interview.

Let's go over the main categories of companies so you can work on narrowing your focus.

1. Big Tech / FAANG-level Companies

(Google, Amazon, Meta, Apple, Microsoft)

Core skills:

• Data structures & algorithms

• System design (scalability, distributed systems)

• Computer science fundamentals (OS, networking)

2. Mid-size Product Companies / SaaS

(Shopify, Stripe, Notion)

Core skills:

• Strong stack knowledge (React, Next.js, Node.js)

• API design & integrations

• Database design (SQL/NoSQL)

3. Startups (Early-stage)

Core skills:

• Full-stack development

• Rapid prototyping

• Shipping features end-to-end

4. Design Agencies / Creative Studios

Core skills:

• Advanced HTML, CSS, JavaScript

• Animation (GSAP, Framer Motion)

• Pixel-perfect implementation

5. Enterprise / Corporate Companies

Core skills:

• Backend development (Java, .NET, and so on)

• Databases (SQL, enterprise systems)

• APIs & microservices

6. E-commerce & Marketing Agencies

Core skills:

• Shopify / WordPress

• Frontend development

• SEO & performance optimization

7. AI-first / Modern Tech Companies

(OpenAI, Anthropic)

Core skills:

• AI API integration (LLMs, embeddings)

• Prompt engineering

• Backend & data handling

8. Freelance / Indie / Micro-SaaS

Core skills:

• Full-stack development (Next.js)

• Payments & authentication systems

• Deployment & basic marketing

Keep in mind that these are just high-level recommendations. There are, of course, other skills you'll need to focus on depending on the role you're hoping to get. This is just a general guideline to get you started.

Also, fun fact: if you ask a top FAANG developer to code an Awwwards-style landing page, they'll most likely fail. And similarly, an award-winning web designer from a top notch agency will probably perform poorly at an algorithm assignment. Why? Each field requires its own skillset. So make sure you choose and focus on yours.

Step 1: Building a Strong Foundation in Core Web Development Concepts

So, now I assume that you've decided on the type of company you want to work for.

The next step is check whether you have or need to work on the basic fundamentals. Most candidates fail not because they lack experience, but because their basics are shaky.

A solid foundation makes everything else easier: coding challenges, system design, and even real-world tasks.

Focus on learning the core building blocks:

• HTML & CSS

• JavaScript fundamentals

• One solid framework: Get really good at one stack (like React + Next.js).

• APIs & backend basics: Learn how data flows. Understand REST APIs, authentication, and how frontend connects to backend.

• Databases: Know the difference between SQL and NoSQL. Be comfortable with basic queries and data modeling.

• Git & workflows: You should be confident with version control, branching, and collaborating on code.

The goal is not to know everything. The goal is to be clear, confident, and consistent in the fundamentals.

If your basics are strong, you’ll solve problems faster, explain your thinking better, and stand out naturally in interviews.

One of the most effective ways to get better at fundamentals is by practicing with flashcards. I've created a system called the 99cards app that can help with this if you want to check it out.

Step 2: Going Deeper Into Subject Matter

By this step, you've chosen the type of company you want to work for and you're confident that you know core web development skills.

Next, you'll need to practice specific skills related to your company and preferred job type (for example algorithms or building features in live mode).

Hint: In about 80% of cases, the first step is an HR interview. This happens before the technical round. Use this opportunity to your advantage.

When I get invited to a technical interview, the first thing I do is ask the HR manager what I should prepare. Just a simple question – and surprisingly, I almost always get a clear answer concerning:

• What topics to focus on

• What kind of tasks to expect

• Sometimes even tools or formats they’ll use

This gives you a huge advantage. Instead of guessing, you can prepare with intention.

Interview Preparation Guide

1. Answer Technical Questions (1-on-1 / Many-to-1)

This is usually a conversation with a CTO or a full dev team. They'll want to understand how you think, not just what you know. Stay calm and treat it like a discussion, not an exam.

Keep your answers simple and structured:

• Explain your thought process step by step

• Use real examples from your experience

• If you don’t know something, say it and think out loud

In many-to-one interviews, don’t get overwhelmed. Focus on one question at a time and engage with the person speaking.

For example, when I was looking to hire a web developer for my micro SaaS, I didn't care about algorithms, but I cared deeply that they have thorough Next JS skills.

For that, I tested candidates via flashcards in live mode.

How to effectively prepare

Practice explaining concepts out loud, not just in your head. Pretend you’re teaching someone.

Do mock interviews with a friend or record yourself. Focus on clarity and structure.

• Prepare stories from past projects

• Review core concepts (JS, React, APIs)

• Practice saying “I don’t know” confidently

2. Go Through Quizzes with a Timer

Timed quizzes test your speed and basics. These are often multiple-choice or short coding questions. The goal is accuracy under pressure.

A few tips:

• Don’t spend too long on one question. Skip and come back if needed.

• Practice common patterns beforehand.

Speed improves with repetition. Train like it’s a game.

How to effectively prepare

Use platforms with timed tests to simulate pressure. Track your speed and accuracy.

Focus on common topics that appear often.

• JavaScript fundamentals

• Basic algorithms

• Output-based questions

Practice daily in short sessions. Consistency beats long study sessions.

3. Build Features into Existing Apps (Live Mode)

During technical interviews, you’ll often work on a real or mock project. This tests how you read code, understand structure, and make changes safely.

Focus on:

• Understanding the codebase first

• Asking clarifying questions

• Writing clean, simple solutions

Talk while you work. Explain what you’re doing and why.

How to effectively prepare

Practice working with someone else's codebase (not your own). Clone open-source projects and explore them, for example.

Train your ability to navigate and understand code quickly.

• Read files before coding

• Trace data flow

• Make small, safe changes

Also practice explaining your actions while coding.

4. Live Code Algorithms

This is where many developers struggle. You’ll solve problems in real time while explaining your thinking.

Don’t rush to code. First:

• Clarify the problem

• Talk through your approach

• Start with a simple solution, then improve it

Interviewers care more about your thinking than a perfect answer.

How to effectively prepare

Practice common algorithm problems regularly. Focus on patterns, not memorization.

Solve problems out loud, as if someone is listening.

• Arrays, strings, hash maps

• Sorting and searching

• Basic recursion

Time yourself and review your solutions after.

5. Take Home Assignments

These simulate real work. You get time to build something properly. This is your chance to stand out.

What matters most:

• Clean, readable code

• Good structure and naming

• Clear README with your decisions

Don’t overbuild. Focus on quality, not quantity. A smaller, more focused take-home project that's done is better than an overly complex or overly ambitious one that's incomplete.

How to effectively prepare

Build small projects with real-world structure. Practice finishing, not just starting.

Pay attention to presentation and clarity.

• Write clean commits

• Add a clear README

• Handle edge cases

Think like you’re submitting work to a real client.

6. System Design

This is common for mid to senior roles. You’ll design a system from scratch or improve an existing one.

Start simple, then expand:

• Define the requirements

• Sketch a basic architecture

• Discuss scaling, performance, and trade-offs

Think like a builder, not just a programmer. Show how you make decisions.

How to effectively prepare

Study common system design patterns and real-world architectures. Start with simple systems.

Practice breaking problems into parts.

• APIs and data flow

• Databases and caching

• Scaling basics

Watch system design interviews and practice explaining your ideas clearly.

For each of these interviews you can use my free checklists to prepare even more effectively.

A Fun Story

Once I applied to a front-end web developer job at company that focuses on building Awwwards-style websites. The tech interview was take home assignment: I had to rebuild Figma design into a modern GSAP-animated website. I failed to do that.

In 18 months, the same company had an open position. I applied. Can you guess what the tech assignment was? 😄

It was the same.

Draw your own conclusions.

Most Important Part

Here's a helpful framework to keep in mind when you're going through this process:

PDCA Framework

P - plan
D - do
C - check
A- act

It's my go to framework for every subject I want to get better at. Let me explain how to apply this to tech interviews.

Plan: in this stage, you plan your preparation routine and work on your interview performance game.

Do: in this stage, you're actually trying to do what you have planned.

Check: here, you compare your Plan and Do stages. Analyze the difference and see what you can improve.

Act: finally, make adjustments that will help improve Plan 2.0.

Repeat until you get the desired result.

Conclusion

Technical interviews are not about being perfect. They’re about showing how you think, communicate, and solve problems under pressure. The more you practice the right way, the more confident and natural you’ll feel.

Focus on the basics, prepare for your target company, and train in real interview conditions. If you do that, you’ll already be ahead of most candidates.

P.S.

If you want to speed up your prep and stop guessing, I put together a complete toolkit for you.

It contains:

• Interview Checklists

• CV Template

• Cover Letter Template

• List of Top 50 Remote-First Companies

• Job Application Tracker Spreadsheet

You can find it here: 99cards.dev/toolkit

In 2021, I got my first developer job by sending one direct email and then doing a single live call. That was enough.

Later the same year, I found my second job in about three weeks through LinkedIn. At that point, I mostly knew CSS. No serious JavaScript, no strong portfolio, no polished personal brand. And I was offered a Senior Front End Web Developer position at US-based company.

Then things changed. After COVID, a lot of developers moved to remote work. Local job markets turned global almost overnight. Instead of competing with a handful of people nearby, you were suddenly up against hundreds of developers from everywhere.

By 2023, I had real experience. I’d worked at two companies – one in Europe and one in the US. I knew JavaScript, had a proper frontend portfolio, and a personal website. Finding a job should’ve been easier. Instead, I spent 18 months struggling to land a role that actually fit me. The competition was simply on another level.

Now, in 2026, it’s even tougher. AI tools have made it easier to apply, build, and present yourself, which also means companies are flooded with candidates. Things like a decent CV or a basic project don’t stand out anymore. A lot of common advice still sounds good, but it doesn’t work the way it used to.

This guide is based on what actually helped me. I’ll walk through the full process – from preparation to interviews to offers – and explain what matters today, and where most developers lose time without realizing it.

I’ve prepared for you a Dev Job Application Toolkit. By my calculation it can save you 40-60 hours.

This toolkit includes:

• CV and cover letter templates

• Eight interview checklists

• List of top 50 remote-first companies

• Job application tracker spreadsheet

You can get it here: 99cards.dev/toolkit

Table of Contents

• 1. Mindset & Strategy (Before You Start Applying)

  • Choosing a clear position

  • Deciding on the work format

  • Picking the right company type

  • Understanding the product you’ll work on

  • Real story from my experience

  • Creating a job search plan

• 2. Skill Readiness and Gap Analysis

  • Real story from my experience

• 3. Portfolio Preparation (Critical Stage)

• 4. CV / Resume Preparation

  • Header: make it obvious who you are

  • Summary: your short positioning statement

  • Work experience: results over responsibilities

  • Optional sections (only if relevant)

  • Length and customization

  • Format and tools

• 5. Cover Letter

  • What a cover letter is (and isn’t)

  • Step 1: Research before writing anything

  • Step 2: Header and greeting

  • Step 3: Strong, short introduction

  • Step 4: The body — tell a clear story

  • Step 5: Adjust for your role level

  • Step 6: Closing + call to action

  • Step 7: Formatting and final checks

• 6. LinkedIn (Turn Your Profile Into a Recruiter Magnet)

  • Step 1: Get the Basics Right

  • Step 2: LinkedIn SEO (So Recruiters Can Find You)

  • Step 3: Treat Your Profile Like a Landing Page

  • Step 4: Show Proof (This Is Huge for Developers)

  • Step 5: Get More Visible

• 7. Job Search & Application Strategy

  • 1. Job Boards (Fast but Competitive)

  • 2. Company Career Pages (Often Overlooked)

  • 3. Startups, Agencies & Communities (Hidden Gold)

  • Application Strategies (Choose Wisely)

  • Track Everything (Very Important)

• 8. Technical Interview Preparation

  • Step 1: Strong Technical Foundation

  • Step 2: Pre-Interview Strategy (Once Interview Is Scheduled)

  • Step 3: How to Act During the Technical Interview

  • Step 4: Closing the Interview Strong

• 9. HR and Behavioral Interview

  • Step 1: Pre-Interview Research (Do Your Homework)

  • Step 2: Use the STAR Method (Always)

  • Step 3: Common HR Questions (How to Answer)

  • Step 4: Teamwork, Conflict & Feedback

  • Step 5: Closing the Interview + Salary Questions

  • Step 6: After the Interview (Don’t Skip This)

• 9. Salary Negotiation and Job Offers

  • 1. When You Receive an Offer: Pause First

  • 2. Look at Total Compensation (Not Just Salary)

  • 3. Salary Negotiation Rules (Very Important)

  • 4. Advanced Negotiation Tips (Most Devs Skip This)

  • 5. Final Step: Close Everything Properly

• Conclusion

1. Mindset & Strategy (Before You Start Applying)

Before you apply anywhere, you need to decide what you actually want. This sounds obvious, but it’s one of the most skipped steps – especially by junior developers. I know this because I skipped it myself.

When you have little or no experience, it’s tempting to think: I’ll apply everywhere and take whatever I get. That approach feels safe, but it’s risky. You can easily end up in a role you don’t enjoy, working on things you don’t care about, and burning out much faster than you expect. A bad first or second job can slow you down more than having no job for a bit longer.

This stage is about setting boundaries before desperation sets in.

Choosing a clear position

First, be honest about the role you’re targeting. UI/UX, frontend, backend, full-stack, mobile – these are not just labels. Companies hire for specific problems, and they want people who are focused, not “a jack of all trades“.

If you present yourself as a generalist without real depth, recruiters don’t see flexibility. Instead, they see risk. Being specific increases your chances, especially for junior and mid-level roles.

Deciding on the work format

Next, decide how you want to work: remote, on-site, or hybrid.

This matters more than people admit. I personally dislike office work, so remote roles are my only option. That decision alone filters out a huge number of jobs – and that’s a good thing. You should make the same call based on how you work best, not on what sounds impressive.

Picking the right company type

Company type affects your daily life more than the tech stack.

Startups, agencies, and large enterprises all work differently. Startups move fast and expect long hours. Enterprises are more structured and predictable. Agencies juggle multiple clients and deadlines. None is inherently better than the others, but one will fit you better than the others.

Understanding the product you’ll work on

Finally, think about what kind of product you want to build.

Some roles mean jumping between projects. Others mean working on one large product for years. Some outsource companies throw dozens of small, unrelated tasks at you. These are very different work styles.

Real story from my experience

I once interviewed for a role where the team lead casually mentioned they build Shopify plugins. I immediately knew it wasn’t for me. I’m interested in web applications, not plugins – and no salary would’ve changed that. I applied anyway because I was desperate, which was a mistake.

Defining your criteria early saves you from this.

Practical checkpoint: if you can’t clearly describe the role, work format, company type, and product you want, you’re not ready to apply yet.

Creating a job search plan

Once you know your direction, turn the job search into something structured. Without a plan, it becomes emotional and inconsistent.

A search plan is just a set of rules you follow regardless of mood.

Plan weekly, then break it into daily goals. For example: apply six days a week, with a target of 90 applications per week. That’s 15 per day.

At first, these numbers are guesses. That’s normal. After a week or two, you’ll see what’s realistic. Maybe 15 quality applications is too much, and 6–8 is sustainable. That’s not failure, that’s data. Adjust and keep going.

Remember: the goal isn’t to hit an impressive number. It’s to stay consistent without burning out.

The second part of the plan is tracking. Use something simple, like a spreadsheet. For each application, note the date, the company, and the current status: sent, rejected, HR interview, technical interview, offer.

This gives you two benefits. First, you don’t lose track of where you’ve applied. Second, over time, you start seeing patterns. You can tell how many applications turn into interviews, where things usually break down, and what might need fixing – your CV, your targeting, or your interview prep.

You can download my free job application tracker spreadsheet here.

Practical checkpoint: if you can’t say how many applications you send per day or where they usually fail, you’re guessing – not managing – your job search.

2. Skill Readiness and Gap Analysis

Before you send your first application, you need to make sure your skills actually line up with what companies are hiring for right now. This stage is about facing reality – not in a negative way, but in a useful one. You’re trying to match your current level to the level the market expects for the role you want.

A good place to start is job descriptions. Pick a few major job boards and scan real openings for your target position. What matters is volume and focus. Look at 10, 20, or even 30 listings for the same role, not random ones. Specificity is critical here.

As you read through them, patterns start to show up. The same technologies appear again and again. At this stage, using AI to summarize requirements can save time, as long as you’re still doing the thinking. The goal is to spot common ground faster, not to outsource judgment.

What you’re looking for is a simple structure.

First, identify the core skills. These are non-negotiable. For a frontend role, that’s usually JavaScript, a framework like React, and a styling solution such as Tailwind. If you’re weak in one of these, that’s a real blocker, not something to “fix later.”

Next, identify two or three nice-to-have skills. These depend on the role and the company type. Agencies often value things like Framer Motion for polished UI work. Product companies may care more about performance or accessibility. These skills won’t always block you, but they can separate you from similar candidates.

Finally, choose at least one adjacent skill. Something that isn’t your main focus but is expected in any professional setup. Git is the most common example. Missing these often leads to quiet rejections – no feedback, just silence.

Once you have this list, it’s time for an honest audit. Don’t rely on passive learning or gut feeling. Test yourself. Use flashcards for concrete concepts (you can this tool for flashcards: 99cards.dev). Answer open-ended questions without notes. Build a small, focused project that forces you to use the skill without guidance.

The outcome of this stage should be clear. You’ll know where you’re solid, where you’re shaky, and where you’re not ready at all. From there, the job is simple: strengthen weak spots until you’re roughly at market level for your target role.

Real story from my experience

I once saw an attractive front-end web developer/web designer position that required Tailwind CSS for styling. In application company required to list two websites with Tailwind CSS in use. At that moment I had none. And I couldn’t apply. Pity.

Practical checkpoint: if you can’t clearly name your core skills, nice-to-haves, and weakest areas, you’re guessing where you stand – and the market won’t guess in your favor.

3. Portfolio Preparation (Critical Stage)

Your portfolio is simply a list of projects you’ve completed. But where and how you present that list matters a lot more than most developers think.

In my experience, the best place for a portfolio is a personal website (here is mine: https://ilyasseisov.com/). It gives you full control. You decide the structure, the wording, the tone, and the visuals.

Some developers prefer a very minimal setup. Others go for something more visual, with motion and modern UI. Both approaches are fine. What matters is that the site reflects how you think and what you care about building.

On that website, you should showcase only your best work. Not everything you’ve ever built. One, two, or at most three projects is enough. These should represent what you can do right now, not what you could do a year ago. More projects don’t make you look better – they usually make it harder for someone to see your strengths.

Choosing the right projects is where many people go wrong. Your portfolio projects should be directly related to the role you want.

When I was focusing on building modern, animated websites, I showed projects with strong visuals, animations, and micro-interactions. When I shifted toward SaaS and web applications, I replaced those with real app-style projects. The portfolio should follow your direction, not your history.

Avoid tutorial clones. Even well-made ones. Recruiters see them immediately, and they don’t tell much about how you think or make decisions. Personal or slightly imperfect projects are usually far more interesting than something copied step by step from a course.

For each project, a simple case-study structure works best. Explain what the project is, why it exists, and how you approached it. Show the final result with a live link, so people can actually use it. Code access is optional. Sometimes you don’t want to make everything public, and that’s fine. If a recruiter asks, you can always give access privately to a small group.

Here is example of my case study page: ilyasseisov.com/projects/99films/

Practical checkpoint: if your portfolio doesn’t clearly show what kind of work you want to be hired for, it’s not helping you – no matter how polished it looks.

4. CV / Resume Preparation

Your CV is not a biography. It’s a filtering document. Its job is to help a recruiter understand, in under a minute, who you are, what role you fit, and whether it’s worth moving you forward. Structure and clarity matter more than clever wording.

Header: make it obvious who you are

At the very top, include your full name, your role, and your main technologies. Be specific.
For example: Frontend Web Developer (React, Next JS).

This saves time for recruiters and helps with automated filtering. I also include my email address, and sometimes – in smaller, low-opacity text – my years of experience (for example, 10+ years). It’s a quick signal, not a headline.

Summary: your short positioning statement

Think of the summary as an elevator pitch with context. This is where you explain what you do well and what kind of problems you’re best at solving. Keep it focused. Avoid vague statements like “passionate developer” or “team player.” Say what you build and where you add value.

Work experience: results over responsibilities

This is the most important section.

For each role, include the company name, time period, and position. If it helps, add a link to the company’s website.

When describing your work, focus on accomplishments, not duties. What did you change? What improved because of your work? Metrics matter here.

For example:

Redesigned and coded the UI of a 20+ page web application, resulting in a 16.7% increase in user engagement and a 21.4% reduction in page load time. Worked closely with backend and QA teams. Designed in Figma, implemented with Tailwind CSS and React.

This tells a much clearer story than listing tasks.

Optional sections (only if relevant)

You don’t need to include everything — only what supports your candidacy.

• Education: useful if it’s related (computer science, software engineering, and so on)

• Personal projects: include only if they align with the role you’re applying for

• Interests or hobbies: optional, but can create a human connection if they’re meaningful

• Languages: valuable in a global job market

If a section doesn’t strengthen your position, leave it out.

Length and customization

A rough rule: around one page per 10 years of experience.

More important than length is relevance. Ideally, you should have a solid base version of your CV, then slightly adjust it for specific roles. This small effort often leads to a much higher response rate.

Format and tools

Don’t add a photo. It doesn’t help, and in many cases, it hurts.

Always send your CV as a PDF. This avoids layout issues and font problems.
For tools, I prefer Figma because it gives full control over layout and visuals. If that feels like overkill, Google Docs works just fine.

Create a first version, then iterate over time. Add new skills, remove outdated ones. This is normal. My current CV is version six – and it took years to get there.

Before sending your CV, run it through an ATS checker. Many companies use automated systems before a human ever sees your résumé. If the machine can’t read it properly, it won’t matter how good the content is.

You can check out my proven CV template here. It's free to download.

Practical checkpoint: if a recruiter can’t understand your role, level, and strengths in 30–60 seconds, your CV needs simplification – not more detail.

5. Cover Letter

A cover letter is short, focused, and very intentional. It’s not a repeat of your CV – it’s your chance to explain why you’re a great fit for this specific role and this specific company.

What a cover letter is (and isn’t)

A web developer cover letter should be 200–300 words max. Its main goal is to connect your skills and experience to the company’s needs in a more personal way than a résumé can.

Think of it as a bridge between:

• what you can do (CV)

• and why they should care

Step 1: Research before writing anything

Never write a generic cover letter.

Before you start:

• Read the job description carefully

• Look up the company, their product, and their values

• Try to find the recruiter or hiring manager’s name (LinkedIn helps a lot)

Then:

• Pick one strong “crowning achievement” – a project or result that clearly shows your value

Step 2: Header and greeting

Keep it clean and professional.

Header should include:

• Full name

• Email + phone

• Location (city, country/state)

• Link to your portfolio or personal website (very important for devs)

Greeting:

• Use “Dear [Name]” or “Dear [Team Name] Team”

• Avoid “To whom it may concern” — it feels lazy and generic

Step 3: Strong, short introduction

Your intro should be 2 sentences max.

Include the exact role you’re applying for and a quick hook – why this company or product caught your attention.

Example ideas:

• A product they built

• A mission you align with

• A tech stack you’re excited about

Step 4: The body — tell a clear story

This is the core of your cover letter.

Focus on technical skills (HTML, CSS, JavaScript, React, Node.js, and so on) and real impact, not just tools.

Use numbers whenever possible:

• “Improved performance by 30%”

• “Reduced load time by 2 seconds”

A great structure here is: Problem → Solution → Impact

Also don’t forget that soft skills matter: communication, problem-solving, teamwork are important. Companies hire people, not just code writers.

Step 5: Adjust for your role level

What you emphasize depends on your profile:

• Front-end → UI, UX, responsiveness, animations, browser support

• Back-end → APIs, databases, scalability, performance

• Full-stack → end-to-end ownership, deployment, architecture

• Entry-level / junior → personal projects, bootcamps, learning speed, motivation

If you lack experience, that’s okay. Show potential and direction.

Step 6: Closing + call to action

Wrap it up confidently. Reconfirm your interest in the role, briefly restate the value you bring, and add a soft CTA like being open to an interview or discussion.

End with:

• “Sincerely” or “Best regards”

• Your name

Step 7: Formatting and final checks

Details matter here.

• Use the same font as your CV

• Stick to clean, modern fonts (Plus Jakarta Sans, Inter, DM Sans, etc.)

• Keep margins simple and spacing readable

• Always send as a PDF

• Proofread carefully – mistakes here hurt more than missing skills

Practical checkpoint: If your cover letter could be sent to 10 different companies without changes, it’s not good enough.

You can check out my cover letter template here. You can have it for free.

6. LinkedIn (Turn Your Profile Into a Recruiter Magnet)

LinkedIn shouldn’t be just an online CV. For a web developer, it should work like a high-converting landing page that brings recruiters to you, even while you sleep.

Below is a practical, step-by-step approach, from fixing the basics to getting real inbound opportunities.

Step 1: Get the Basics Right

Before optimizing content, make sure your profile looks clean and professional.

• Turn off profile update notifications: Go to Settings & Privacy and disable updates before editing. No one needs to see you fixing typos.

• Create a custom LinkedIn URL: Use something like linkedin.com/in/yourname-dev. It helps with SEO, looks cleaner on your CV, and improves response rates.

• Profile photo matters a lot: Use a clear, recent headshot. Face should take ~60% of the frame, clean background, friendly expression.

• Add a custom banner: Don’t leave the gray default. Use Canva to add something simple: your tech stack, role, or personal brand.

Step 2: LinkedIn SEO (So Recruiters Can Find You)

If you’re not optimized for keywords, you’re basically invisible.

Pick your target role – for example, Frontend Developer, React Engineer, Full-Stack Developer

Then repeat that keyword in 4 places:

• Headline

• About section

• Job titles

• Experience descriptions

Then make sure you write a strong headline (this is very important). Here's the formula:
[Role] + [Main Tech] + [Value]

Example:
Full-Stack Developer | React, Next.js | Building scalable web apps for startups

Step 3: Treat Your Profile Like a Landing Page

Once someone clicks your profile, you need to convert that visit.

About section = your story

Write like a human, not a robot. Explain why you code, what problems you solve, your experience level, and your core stack

Experience = impact, not duties

Don’t list responsibilities. Show results with numbers.

❌ “Built dashboards”
✅ “Built a React dashboard that reduced load time by 30% for 5,000 users”

Skills section matters more than you think

Add at least 5 relevant skills (JavaScript, React, Git, TypeScript, and so on). Profiles with multiple skills get way more profile views and connections.

Step 4: Show Proof (This Is Huge for Developers)

Words are good – but proof is better. Here's how you can show proof:

Use the Featured section

Add your portfolio website, a linke to your GitHub profile, and live projects or demos.

Ask for recommendations

These can be really helpful, and some companies require them. You can reach out to tech leads, managers you've worked with, or clients (among others).

Recommendations add massive trust.

Pro tip: offer to write one in return.

Step 5: Get More Visible

This is how you go from “searching” to being approached.

Post occasionally

You don’t need to be an influencer. But post something once a month could invite some people to see your page.

Network with intention

Networking is a skill. Follow devs and tech creators, engage with posts (comments > likes), and connect with engineers inside companies you like.

Turn on “Open to Work”

You can make it visible only to recruiters. This is a strong signal that you’re ready for interviews.

Practical checkpoint: If your LinkedIn profile still looks like a copied résumé, you’re leaving opportunities on the table. Treat it like a product page – clear message, strong proof, and easy next step.

And here's a tips: Make sure all information you list at your LinkedIn profile is true. Especially your full name and location. Sometimes LinkedIn admins may ask you to verify it with your real ID.

7. Job Search & Application Strategy

Up to this point, everything you’ve done was preparation. Now you’re ready for the real game: finding jobs and applying the smart way.

Let's start with where to find Developer Jobs.

There isn’t just one correct source. The best strategy is to combine several.

1. Job Boards (Fast but Competitive)

There are two main types of job boards:

Open Job Boards

Examples: LinkedIn, Indeed.

• ✅ You can apply immediately

• ❌ Competition is extremely high

• ❌ Many applications never get seen

These are good for volume, but don’t expect miracles.

Vetted Platforms

Examples: Turing.com, similar invite-only platforms

How it usually works:

1. Application review

2. Automated tests or questionnaires

3. Timed live task (90–120 minutes)

• ❌ Takes time and effort upfront

• ✅ Much lower competition afterward

• ✅ Higher chance of real interviews

If you pass, you enter a smaller talent pool, which is a big advantage.

2. Company Career Pages (Often Overlooked)

Many companies hire directly through their own websites. Big companies often have dedicated career pages. These may have fewer applicants compared to job boards, and they're usually more serious about hiring.

If you already like a company, check their site first.

3. Startups, Agencies & Communities (Hidden Gold)

This is where many developers get jobs without competing with hundreds of applicants.

Agencies

Find them on award sites, directories, or portfolios.

• Visit their websites

• Collect emails

• Send direct, personalized messages

Startups

Use platforms like Product Hunt.

• Find early-stage startups

• Reach out directly via email or LinkedIn

Telegram Groups (Very Underrated)

Many dev job groups exist but aren’t publicized much.

• Jobs are posted directly by founders or managers

• You can DM the person first, ask if you’re a fit

• Attach CV + portfolio

• If they say yes, then apply

This alone can save you weeks of wasted applications.

Here is a list top 50 remote first companies. These establishments always in search of great talent.

Application Strategies (Choose Wisely)

There are three main approaches.

1. Mass Application (Spray & Pray)

• Easy Apply, Easy Apply, Easy Apply

• 20–30 applications per hour

Reality check:

• ❌ Massive competition

• ❌ Very low response rate

Good for filling numbers – not great for quality.

2. Sniper Application (High-Conversion)

This is the most effective method.

How it works:

• Pick a specific company and role

• Research:

  • Product

  • Team

  • Tech stack

• Customize:

  • CV

  • Cover letter

• Try to:

  • Talk to employees

  • Ask for a referral

• ❌ Slower (1–2 applications/day)

• ✅ Much higher response rate

• ✅ Often leads directly to interviews

If you want fewer rejections and better offers, this is it.

3. Networking (Warm Opportunities)

This is the most natural and underrated approach, and there are a couple ways of going about it.

You can focus on offline experience, like:

• Local meetups

• Developer groups

• Tech events

When people know you personally, jobs often come to you.

You can also try online methods, like:

• Discord communities

• Reddit

• Twitter / LinkedIn tech circles

You can share that you’re job hunting, DM people directly and get referrals without formal applications.

This is warm outreach, not cold applying.

Track Everything (Very Important)

Just like mentioned earlier:

• Set weekly & daily application goals

• Adjust them to your real pace

Make sure you track the date, company, and status (sent, rejected, interview, offer). A simple spreadsheet is more than enough.

Practical checkpoint: Don’t rely on just one channel. Combine job boards + direct outreach + networking, track your efforts, and focus more on quality than pure volume.

There is a very useful job application tracker I use when applying to jobs. It helps you to see the entire picture of your progress. You can download it here.

8. Technical Interview Preparation

The technical interview is not a normal conversation — it’s closer to an exam + live performance. You’re not just talking about your skills; you’re expected to prove them in real time.

Step 1: Strong Technical Foundation

1. Master One Programming Language

Pick one main language (JavaScript, Python, Java, C++, and so on) and know it really well.

• Syntax should be automatic

• You shouldn’t struggle with basics during interviews

• This lets you focus on problem-solving, not syntax

2. Data Structures & Algorithms (Must-Have)

You should clearly understand:

• Arrays & strings

• Hash tables

• Stacks & queues

• Linked lists

• Trees & graphs

• Heaps

Important: don’t just know how, know why. For example: why a hash table gives average O(1) lookup time.

3. Real Side Projects

Have projects that match the level of the job you want, that are built from scratch, that use real logic, not tutorial clones, and be ready to walk through architecture, decisions, and trade-offs.

This often shifts the interview from grilling to conversation.

Step 2: Pre-Interview Strategy (Once Interview Is Scheduled)

Now it’s about targeted prep.

Résumé Deep-Dive

Be ready to explain everything on your CV.

• Every framework

• Every project

• Every tool

If you listed it, you must defend it.

Behavioral Answers (STAR Method)

Use STAR:

• Situation

• Task

• Action (most important – what you did)

• Result

Use it for bugs you fixed, conflicts in teams, technical challenges, and failures and lessons learned.

Step 3: How to Act During the Technical Interview

This part matters as much as the solution itself.

1. Read & Rephrase

Read the task and repeat it in your own words. This shows clarity and avoids misunderstandings.

2. Clarify Everything

Ask about:

• Input format

• Output format

• Constraints

• Edge cases

Good engineers never assume.

3. Think Out Loud

Before coding, explain your approach, start with a brute-force solution, then optimize it. Interviewers care about how you think, not just the final answer.

4. Code Like a Professional

While coding, speak your thoughts, use clear variable names, and teat it like pair programming, not an interrogation

5. Test Your Code

When finished, walk through the code step by step, use example inputs, and try to catch bugs yourself. Debugging your own code is a huge positive signal.

6. Explain Complexity

Always finish with time complexity and space complexity.

Short, clear, confident.

Step 4: Closing the Interview Strong

Ask Smart Questions

When you're wrapping up, make sure you ask smart questions to show your genuine interest and thoughtfulness.

Ask about:

• Tech stack

• Architecture

• Development process

• Team collaboration

Avoid salary or benefits here – that’s for HR.

Send a Follow-Up

Within 24 hours, thank them and show appreciation.

If you realized you made a mistake, you can briefly explain the correct approach – this shows growth mindset.

Learn From Every Interview

Even failed interviews are data. After each one, ask yourself:

• Where did I get stuck?

• What topic do I need to improve?

Practical checkpoint: You don’t pass technical interviews by luck. You pass them by deep fundamentals, structured thinking, and practice.

9. HR and Behavioral Interview

The HR / behavioral interview is not just a formality. Very often, this round decides whether you move forward or not.
Unlike technical interviews, this one is about who you are, how you communicate, and whether the team can work with you long-term.

Step 1: Pre-Interview Research (Do Your Homework)

Before the interview, go deeper than your CV.

Research the company

Learn about their mission and values, their product or service, and any recent news, releases, or updates involving them.

This helps you sound intentional, not generic.

Study the job description

Make sure you highlight your soft skills and responsibilities, and then prepare 2–3 real examples that match those requirements.

Build a story bank

Prepare 8–10 short stories from your experience that demonstrate:

• Solving a problem

• Working in a team

• Handling conflict

• Taking ownership

These stories are your proof. Much better than buzzwords.

Step 2: Use the STAR Method (Always)

Remember the STAR method we talked about above? Use it here, too.

Also, think out loud. HR wants to hear how you reason, not just the final answer.

And practice explaining technical things without jargon. HR people are usually non-technical.

Step 3: Common HR Questions (How to Answer)

“Tell me about yourself”

Keep it to ~2 minutes.

Focus on your current role or level, your main tech stack (for example, JavaScript, React, SQL), and where you want to grow next.

Skip personal life unless asked.

Strengths

Pick role-relevant strengths here and back each one with a quick example.

Example:

“I’m strong at ownership. In my last role, I took responsibility for…”

Weaknesses

This is a tough one. So be honest, but smart. Show self-awareness + improvement, and avoid clichés like “I’m a perfectionist”.

Good structure:

• Real weakness

• What you’re doing to improve it

Step 4: Teamwork, Conflict & Feedback

Web development is teamwork-heavy, so expect these.

• Conflicts

  • Don’t blame others

  • Focus on communication and resolution

  • Show maturity and accountability

• Code reviews & feedback

  • Treat feedback as growth

  • Show you don’t take criticism personally

• Mistakes

  • Admit them

  • Explain how you fixed the issue

  • Share what you learned

This signals professionalism and emotional intelligence.

Step 5: Closing the Interview + Salary Questions

Always ask questions

Good examples:

• What does success look like in the first 3 months?

• How does the team collaborate?

• What do you personally enjoy about working here?

Saying “I have no questions” is a bad signal.

Salary expectations

If possible, avoid giving a number too early.

If pushed, give a range, not a single number. And make sure you base it on market research. Also, say it’s negotiable. All this keeps leverage on your side.

Step 6: After the Interview (Don’t Skip This)

Similar strategies here:

• Send a thank-you email within 24 hours

• Thank them for their time

• Reconfirm your interest

Simple, polite, professional.

Practical checkpoint: Technical skills get you noticed. Behavior, communication, and attitude get you hired.

Tip: Before EVERY interview even a first one I always contact HR or recruiter and ask what should I prepare for the interview round. Surprisingly, almost every time I get specific directions.

I always use interview checklist when I prepare for one. It helps you remember all critical points. You can download it here.

9. Salary Negotiation and Job Offers

Congrats — getting an offer means you already won half the battle. Now comes the part where many developers make costly mistakes: accepting too fast or negotiating poorly.

Let’s break this down step by step.

1. When You Receive an Offer: Pause First

When you hear “We’d like to make you an offer”:

• Say thank you

• Show excitement

• Do NOT accept immediately

This is very important.

What to say instead:

• Ask for the offer in writing

• Request 24–48 hours (sometimes up to a week) to review it

This is completely normal and professional. The pause helps you move from emotions to logic.

2. Look at Total Compensation (Not Just Salary)

Many developers only look at base salary, but that’s a mistake.

Check the full package for things like:

• Base salary

• Health insurance (medical, dental, vision)

• Retirement plans (401k, matching, vesting period)

• Equity (stock options / RSUs)

• Bonuses (sign-on or performance)

• Remote / hybrid flexibility

• Equipment budget

• Learning budget

Sometimes a lower salary + great benefits is actually the better deal.

3. Salary Negotiation Rules (Very Important)

Rule #1: Don’t Give the First Number

If possible, avoid saying a salary number first.

Why? Because employers will anchor low, and you lose leverage immediately.

If asked early, say something like:

“Right now I’m focused on finding a strong mutual fit. I’m open to a fair market offer once we’re aligned.”

If You MUST Give a Number

Give a range, not a single number. Your ideal salary should be at the lower end of that range

4. Advanced Negotiation Tips (Most Devs Skip This)

Negotiation Is Expected

About 80%+ of companies expect negotiation. It doesn’t make you difficult – it makes you look confident.

Use Other Offers (If You Have Them)

If you have another offer, be honest and respectful about it.

Example:

“You’re my top choice, but I have another offer that’s slightly higher. Is there room to adjust?”

Negotiate Non-Money Items

If salary is capped, try asking instead for extra vacation days, a sign-on bonus, a learning budget, or a faster salary review (after 6 months).

Managers often have more flexibility here.

5. Final Step: Close Everything Properly

Before accepting:

• Get everything in writing

• Read the contract carefully

• Check:

  • Job title

  • Salary & bonuses

  • Notice period

  • Non-compete clauses

In many countries, verbal acceptance can be legally binding. Don't say “yes” unless you are 100% sure.

If you reject an offer:

• Be polite

• Thank them

• Keep the relationship open

You never know when paths cross again.

Practical checkpoint: Your first offer sets the baseline for your future career. Take your time, stay professional, and don’t be afraid to negotiate.

Real story: In 2021 I received a very nice job offer. I liked it. The CEO said: “Here is the salary range: A to B. What would you like?“. I said let’s go with middle point. I always prefer win-win situations.

Conclusion

Getting a web developer job today is not about luck – it’s about strategy, preparation, and consistency. The market has changed. Competition is higher, expectations are clearer, and companies are more selective than ever. But the good news is that developers who approach the process the right way still get hired, again and again.

In this guide, you’ve seen the full journey: defining your direction, preparing your skills, building a strong portfolio, crafting a clear CV and cover letter, optimizing LinkedIn, applying smart, preparing for technical and HR interviews, and finally negotiating your offer with confidence. Each stage matters, and skipping even one can significantly lower your chances.

Remember: job searching itself is a skill. The more intentional you are, the better your results will be. Track your progress, learn from rejections, improve weak spots, and don’t rush the process. One strong offer is worth more than a hundred rushed applications.

Most importantly, don’t underestimate your value. If you’ve put in the work, you deserve a role that fits your skills, goals, and lifestyle.

I wish you the best of luck on your journey. Stay consistent, stay confident, and go get that job 🚀

p.s. if you still haven’t you can get Dev Job Application Toolkit here: 99cards.dev/toolkit

Let's get one thing straight: AI is here to help, not to replace. Your job, my job, was never just to write code. Writing code was always just a part of it. Our real job is to build software solutions that work. And since an AI, trained on the collective knowledge of millions of developers, can probably write better, cleaner boilerplate than you, you should let it. Your expertise is better used elsewhere.

In this article, I’ll show you exactly how I use AI to get work done faster. We'll walk through building a car rental website, and you'll see how I use AI for:

• Initial planning and research

• Design and even UI Copy

• Writing all the boring boilerplate code

• Improving the code and making it better

Here’s what the website we're building looks like: (Live demo) (Github Repo)

Table of Contents

1. Step 1: Planning and Research (The Brainstorm)

2. Step 2: Design and UI Copy

3. Step 3: Writing the Boilerplate Code

4. Step 4: Making the Code Actually Good

   • What the AI Got Right (and Wrong)

   • Refactoring in Action

5. So, What's the Takeaway?

6. Frequently Asked Questions

Step 1: Planning and Research (The Brainstorm)

So, a client hits me up. They own a car rental business and want a simple website. People need to see the cars and have an easy way to call and rent them. Simple enough.

So what do I do? I don't fire up VS Code. I take this info straight to ChatGPT and ask it for ideas.

Prompt:

You’re a website designer and you have a client that owns a car rental website. They want a simple website that displays the cars they have for rent and an option for people to rent them. How would you go about building this?

Output:

You can see how easy that was. So what did it spit out? Basically a full project brief. It gave me a roadmap suggesting key pages like a Homepage, Car Listings, and a Contact page. It also outlined essential features like a search bar and filtering options, and recommended a modern tech stack like React which was exactly what I was planning to use.

With that sorted, I wanted to see what it might look like, so I had it generate some quick wireframes.

Prompt:

From the above, Generate the wireframes of what the entire website with its pages will look like.

Output:

Now I've got a blueprint. The whole discovery phase, which could take hours or days of back-and-forth, is done in minutes.

Step 2: Design and UI Copy

Okay, I've got a rough idea of the layout. Time to turn these ugly wireframes into a real design. For this, I use AI-powered UI generation tools (you can find a few out there, like https://stitch.withgoogle.com, or even use v0.dev to get ideas).

I just uploaded the wireframes from ChatGPT and told it what I wanted.

Prompt:

Turn these wireframes into a clean, modern design for a car rental website. Make it look trustworthy.

Output:

Now, one thing I love about these tools is that they don't just spit out a pretty picture. They give you the actual code for it.

Here’s a sample of the kind of clean HTML it gave me for a single car card:

<div class="bg-white rounded-lg shadow-md p-4 flex flex-col">
  <img src="/path-to-your-car-image.png" alt="Toyota Camry" class="rounded-md mb-4">
  <h3 class="text-xl font-bold text-gray-800">Toyota Camry</h3>
  <p class="text-lg font-semibold text-blue-600 mt-2">$50/day</p>
  <ul class="mt-4 space-y-2 text-sm text-gray-600">
    <li class="flex items-center">
      <span>4 Seats</span>
    </li>
    <li class="flex items-center">
      <span>Automatic</span>
    </li>
  </ul>
  <button class="mt-auto bg-blue-500 text-white font-bold py-2 px-4 rounded-lg hover:bg-blue-600 transition duration-300">
    Rent Now
  </button>
</div>

You can always play with the full code here.

And just like that, I've got the design of the website and the starter code for it. No Figma, no slicing assets, just straight from an idea to code.

Step 3: Writing the Boilerplate Code

I said earlier that AI can write better code than you, and I stand by it. It was trained on all the code from every public repo, every tutorial, every developer put together. Assuming the collective brain of every developer is better than you alone, the AI has a serious edge – if you can guide it.

For my car rental site, I wanted to use React. So I just copied the HTML code from the design tool and pasted it into Gemini with some very clear instructions.

Prompt:

You are a senior React developer. Convert the following HTML and Tailwind CSS code into a fully functional React application.

Requirements:

1. Use Vite as the build tool.

2. The project must be in TypeScript.

3. Implement the UI components using shadcn/ui where appropriate (for example, Buttons, Cards).

4. Use lucide-react for icons

5. Structure the code into logical components (for example, Navbar, CarCard, Footer).

6. Create a root App.tsx file that assembles these components.Output:

Notice how I was super specific about the tools I wanted? If you want the best output, you have to tell the AI exactly what you want. Don't be vague. Guide it. This means you’ll need to be familiar with and understand the tools needed to create this kind of project.

Overall, it took maybe ten minutes from the time I got the message from the client to the time I had a working React app running on my machine. A website built in ten minutes or less. This was not possible a while back, but with AI helping, you can move insanely fast.

Step 4: Making the Code Actually Good

Look, I know this is far from done. The AI gave me a great start, but it's not a finished product. I still have to plug in a CMS or a database, set up the real logic – you get the idea. This is where the real development starts, and AI is still my co-pilot.

What the AI Got Right (and Wrong)

The AI did a surprisingly good job on the first pass. It correctly scaffolded the Vite + React + TS project, created a components folder, and even used shadcn/ui components where I asked. This saved me at least 30-45 minutes of tedious setup.

But it wasn't perfect. For example, the initial data for the cars was hardcoded directly inside the component. That's a huge no-no for a real app that needs to scale or pull from a database. Also, the components weren't as reusable as I'd like.

This is where your job as a developer comes in – to review, refactor, and architect properly.

Refactoring in Action

I constantly go back to the AI to refine the code. I treat it like a pair programmer. Here's an example. The AI first gave me a CarCard component that looked something like this:

Before Refactoring (AI's First Draft):

// components/CarCard.tsx
import { Button } from "./ui/button";

export const CarCard = () => {
  const carName = "Tesla Model S"; // Data is hardcoded
  const price = 95;

  const handleRentNow = () => {
    console.log("Renting Tesla Model S");
  };

  return (
    <div>
      <h2>{carName}</h2>
      <p>${price}/day</p>
      <Button onClick={handleRentNow}>Rent Now</Button>
    </div>
  );
};

This is fine for a demo, but useless for a real application. So, I guided the AI to refactor it. I'd ask it something like, "Refactor this CarCard component to accept props for car data (name, price, image) and a function for the rent button click."

After Refactoring (My Guided Version):

// components/CarCard.tsx
import { Button } from "./ui/button";

// Define a type for the car's data
export interface CarProps {
  name: string;
  price: number;
  imageUrl: string;
}

interface CarCardProps {
  car: CarProps;
  onRentNow: (carName: string) => void;
}

export const CarCard = ({ car, onRentNow }: CarCardProps) => {
  return (
    <div>
      <img src={car.imageUrl} alt={car.name} />
      <h2>{car.name}</h2>
      <p>${car.price}/day</p>
      <Button onClick={() => onRentNow(car.name)}>Rent Now</Button>
    </div>
  );
};

See the difference? Now it's a reusable, type-safe component that gets its data from outside. It's a back-and-forth conversation. I write some code, the AI cleans it up. The AI writes some code, I fix the logic. It's pair programming on steroids.

So, What's the Takeaway?

The game has changed. AI is a tool, probably the most powerful one we've ever been given. It automates the boring stuff so we can focus on the hard problems – architecture, performance, and user experience.

The developers who ignore this are going to be lapped by the ones who embrace it. It’s about working smarter, not harder.

Frequently Asked Questions

Q: What’s the best AI model to use? ChatGPT or Gemini or something else?

A: Honestly, they're all great at writing code, and it's all a matter of "Garbage in, Garbage out." The results you get are only as good as your prompts. But if I had to choose one right now specifically for writing and refactoring code, I'd probably pick Gemini. Your mileage may vary.

Q: Will I forget how to code if I rely on AI?

A: That's on you. If you just copy and paste without understanding what's happening, then yeah, your skills will get dull. But if you use it to learn, to see different ways of solving a problem, and to check your own work, it'll actually make you a much better developer, faster.

Q: Is it ethical to use AI for client work?

A: Of course. Your client is paying you for a working website, not for your blood, sweat, and tears typing every single bracket. Is it unethical to use a framework like React or pull in a package from npm? No. This is the same thing. It's a tool. Just make sure the final product is solid, because you're the one who is ultimately responsible for it.

Q: What about bugs? Does AI write perfect code?

A: Heck no. It will give you buggy code. It will make things up. Don't trust it blindly. My rule is to treat code from an AI like it came from a talented but very eccentric junior dev. You have to check their work. Run it, test it, and if it breaks, you can even paste the buggy code back into the AI and say, "Hey, fix this." It's surprisingly good at cleaning up its own mess.

If you have any questions, feel free to find me on Twitter at @sprucekhalifa, and don’t forget to follow me for more tips and updates. Happy coding!

A popular Chinese proverb says: “The best time to plant a tree was 20 years ago. The second best time is now.”

The same applies to acquiring new tech skills. No matter if you’re a junior developer or a seasoned software engineer, there is always something you can work on and improve.

But how do you choose this “something” that might help you advance your career in the IT industry? With plenty of online courses and new IT skill sets demanded by employers, you can easily get dizzy.

Don't worry – DevSkiller is coming to the rescue with data-backed insights based on the findings from the 2022 edition of our Top IT Skills Report. We’ve arrived at these insights by analyzing thousands of coding tests sent to candidates from 191 countries through our TalentScore tech screening solution by companies recruiting for IT-related positions.

Based on our proprietary data, we’ve compiled a set of useful tips on what to learn. This is based on what job you hope to get in the future.

Choose wisely and remember that the IT industry is waiting not only for seasoned developers but also for greenhorns. As the data from the DevSkiller platform show, around 40% of technical test invitations are for junior developer roles.

If you want to grow together with the market

You've likely heard that “data is the new oil”. But only a handful of the big tech companies have figured out how to extract this "oil" and process it in order to be able to fuel their businesses.

This has brought about the accelerating demand on the job market for data-related roles like data scientists, data analysts, or data engineers.

If the thought of organizing random numbers in a set of structured tables or charts positively tickles your mind, a data-related role might be the right fit for you.

Just keep in mind that the market of data-related positions is not as structured as the dashboards you might be expected to create. As the market develops and gets more mature, you might be expected to learn new skills which we can’t even imagine right now.

Having said that, the reward for this flexibility and eagerness to learn may be huge.

According to the insights from the latest edition of the DevSkiller report, data science tops the ranking of in-demand IT skills of the future. The popularity of recruitment tasks from this area grew in 2021 by 295% on a yearly basis.

If you want to enter the IT job market ASAP

Another big thing as far as in-demand IT skills of the future go is Python. But this demand isn't the only advantage when it comes to your choice of programming language to learn.

The data we compiled for our Top IT Skills Report show that Python – with a 54% ratio of test invites for junior roles – was the most sought-after technology among developers beginning their careers in the IT industry.

Given the fact that Python is relatively easy to learn in comparison to other programming languages, it might be a perfect choice to speed up your entrance to the IT job market. Just remember that the fastest way is not always the most satisfying one.

If you want to work in a big company

Trying to find your place on the job market may be compared to driving a car. Some people like to drive fast and reach their destination quickly, but others prefer to move forward slowly but securely.

If you’re in the latter group, you should consider learning one of the most mature and popular programming languages like Java or SQL. This can help you land a job in one of the large corporations. This may be not as exciting as working for a cool ever-pivoting startup, but it'll provide you with a certain level of stability and security you might find appealing.

As the data compiled from the DevSkiller TalentScore show us, both Java and SQL are in the top of the ranking of IT skills sought after by hiring companies. Each of those languages was seen in 19% of coding test invites sent by tech recruiters via our platform.

It's worth mentioning that there seems to be a shortage of those skills on the market. From the insights in our report, Java and SQL developers wait the longest to complete their coding tests in comparison to specialists with other tech skills.

One of the reasons behind this trend is that the recruitment pool is shallow and companies are competing for the same limited set of candidates.

In 2021, the average time to submit a Java coding test by a recruited candidate amounted to 4 days and 11 hours while in the case of SQL it was 3 days and 6 hours. The industry average for all languages in 2021 was 2 days and 16 hours.

If you want to unleash your creativity

Do you consider yourself to be a creative person who cares not only about how things work but also how they look? If that’s the case, you should consider pursuing a career as a front-end developer.

Maybe you won’t enjoy as much artistic freedom as a graphic designer, but rest assured that if you supplement your bias towards aesthetics with the practical coding skills, you’ll find a job you enjoy.

If that sounds appealing to you, remember that the front-end development is not just about HTML or any single language anymore. You’ll probably need to be able to surf across at least a couple of technologies during any given project.

Through the findings from our report, the 5 most commonly paired IT skills tested by recruiting companies nowadays are JavaScript and HTML, JavaScript and TypeScript, JavaScript and CSS, JavaScript and Angular, and CSS and HTML.

If you don’t want to code (or only a little bit)

Given the rising popularity of low-code/no-code platforms and tools, you no longer have to become a full blown software engineer in order to land a job in the IT.

Sure, in this industry, you will always be expected to possess a certain level of computer literacy and understand the key concepts of software development. But you no longer have to actually code in order to be an attractive candidate for employers.

The rising popularity of low-code/no-code is reflected in the dynamic growth of the number of tests checking the skills related to Salesforce available on DevSkiller TalentScore. Since 2020, it has grown by a whooping 1300% in response to the needs of our customers, that is hiring companies.

And keep in mind that Salesforce is just one of plenty low-code/no-code platforms used by your potential employers.

If you want to help others enter the IT industry

Last but not least, maybe after careful consideration of your skills and preferences, you’ll decide that you’re more of a people person, and solving technical problems on a daily basis is not for you. Or you might be burned out in your current role and would like to try something new.

Don’t worry, the IT industry is not only about 0s and 1s and there are a number of options available for you to land your dream job that don’t require learning coding skills.

One of them is related to helping others find a well-suited job – that is, becoming a tech recruiter.

If this sounds like a good fit, you can start developing in this direction by acquiring the industry-recognized DevSkiller Tech Recruitment Certification. Even though it may not look very difficult at first glance, our data show that only 61% of users pass our certification exam in the first attempt.

The digital skills gap is working to your advantage

As software has been eating the world for quite some time now, the IT industry has become one of the main drivers of job opportunity growth in the global economy.

In the European Union alone the gap between the supply and demand of IT specialist has been estimated at a minimum of 500,000 vacancies. And this doesn't include all of the IT-related roles like tech recruiters and other positions that require at least some level of digital skills.

So if you're hesitant whether your upskilling or reskilling efforts will pay you off, the answer is: yes. The probability that you'll get a raise or move to a better paid job is close to 100%. The worst-case scenario? You'll simply find joy in learning something new.

Coding is fun, after all.

Finding a remote job as a developer can be tricky. You want to work for a company that recognizes the value of remote workers, and you want to be sure that the company will support and encourage your remote working style.

If you’re a developer looking for an opportunity to work from home, only a handful of jobs can really provide you with great flexibility, a supportive environment, and manageable workloads.

If you're reading this, you probably want a nice list of companies that offer remote work. Unfortunately, most of the lists out there tend to be outdated or are filled with jobs that are not 100% remote.

With that in mind, in this article you will find a list of actual companies that hire remote developers in one way or another. You will also learn what these companies do and how they stack up against each other.

What Are the Benefits of Working Remotely?

Working remotely is an increasingly popular trend. It offers a level of flexibility, autonomy, and freedom not found in other work situations. In addition to that, remote work can also open the door to increased productivity and creativity.

Nicholas Bloom conducted an experiment and found that remote workers worked 9.5 % longer and were 13% more productive than their in-office counterparts. Below, I'll share some of the benefits of working remotely.

1. Working remotely saves time

Employees who work remotely don’t have to spend time commuting to work, and can thus manage their own schedule.

Also, some people perform better at different times of the day. For example, one person may be a morning person, while another is more productive in the evenings.

As long as you meet deadlines, it doesn’t matter what time of day you do your work.

2. You have peace and quiet when working remotely

Offices can be noisy, distracting, and generally disruptive. Sure, they can be productive spaces, but they're often anything but quiet.

Remote work allows you to escape the daily grind and go to a quiet location where you can concentrate on work.

Whether you choose to work from home or not, having peace and quiet during the working day can be the key to greater productivity, more motivation, and less stress.

3. Remote work can bring health and happiness

If you commute every day and work in an office, you might not be living as healthily as you could be. Remote developers are often happier, healthier and much more productive.

A recent report entitled the "State of Remote Engineering" captured sentiments from software developers across a range of topics, including remote work, compensation, burnout, payout, and productivity.

A whopping 75% of the developers surveyed mentioned they want to work remotely at least three days a week.

Photo by ThisIsEngineering from Pexels

The study found that 68% of respondents are able to get more meaningful work done when working remotely or from home. In contrast, only 32% reported they are more productive in an office environment.

Important reasons for this were that working remotely gives people the freedom to make their own decisions and to be responsible for those decisions.

4. Remote work can help give you work-life balance

The key to a good work-life balance is to structure your day effectively and make sure you are spending enough time on both your work and home tasks.

Developers who feel like they have a sense of achievement are more productive. Other benefits include:

1. Taking a break when you need one.
2. Spending more time with family.
3. Not rushing to catch a train or spending time sitting in traffic.

5. Working remotely lets you personalise your office

The freedom to work remotely allows you not only to work when you want, how you want, and wherever you want. It provides you with the ability to establish your own office space and personalise it however you like.

You can create a truly inspirational workspace with the help of your favourite photos, paintings, plants, or anything else you might find that brings you joy.

This is all about making your work area totally yours – a completely inspiring environment. No one can judge what you like or dislike.

What Are the Best Remote Companies for Developers?

The remote work revolution is in full swing, and there’s a lot of online chatter about the best companies for remote work.

In this article, you will find a compiled list of the top 10 companies for developers to work remotely. This list is by no means exhaustive but should give you a good starting point of where to look for your next employer.

1. Intergiro

Screenshot from integiro website

Intergiro is an all-in-one platform that provides multi-currency bank accounts, card issuance, and card acquisition across Europe. Their services enable anyone to embed banking functionality into their website and app, creating opportunities for new and innovative product experiences.

Intergiro provides both hybrid and fully remote options to its employees. They are committed to building a remote-friendly company and make work simpler, more pleasant, and more fulfilling for their people.

Although a remote-first company, the company boasts hubs in luxurious coworking spaces in Sweden, Spain, Portugal, and Poland. The availability of these coworking spaces has allowed Intergiro to attract individuals who prefer to work side-by-side with like-minded colleagues

2. Automattic

Screenshot from Automattic Website

Automattic, Inc. is a software company, with its most famous product inarguably being WordPress. They are based in San Francisco, CA.

Automattic is the parent company of WordPress, WooCommerce, Tumblr, and several other web applications.

Automattic has long had a remote-first working environment that has even been the subject of various articles.

With workers in 96 countries, Automattic emphasises flexibility, autonomy, and an optimal work-life balance with open vacation days, paid sabbaticals every five years, and generous parental leave.

3. Zapier

Screenshot from Zapier website

Zapier is a web application that creates and automates connections between apps. Using Zapier, a user can easily create workflows and implement custom automatizations to smoothen their work

Zapier has been a 100% remote company since its establishment in 2011, and now boasts over 200 teammates in 24+ countries.

The company places a high degree of value on autonomy and employee ownership of their own work, and rewards employees with a flexible vacation policy and a profit-sharing system.

To build team spirit across the distance, the company also holds twice-annual all-company retreats.

4. InVision

Screenshot from Invision website

A software company focused on collaborative design tools, InVision has worked to become a go-to name in remote work since its establishment.

InVision motivates its globe-spanning workforce with a monthly allowance for work and self-care activities, an annual fund for self-development, and generous budgets for new hires to fully outfit their home offices, as well as office refreshment budgets every two years for existing employees.

5. Abstract

screenshot from Abstract website

Abstract is a web application designed for designers and developers that assist with collaboration on web and mobile projects. They currently have over 7,000 design teams signed up for the platform.

With 80% of their workforce being remote, Abstract is a remote-first company, although they are currently based entirely within the United States.

The company shows its investment in employees’ work-life balance by establishing four-day workweeks, along with unlimited paid time off and a range of other benefits, including pet insurance and adjustable work hours for caregivers.

6. Trakstar

Screenshot from Trackstar website

Trakstar is a software suite that empowers companies’ human resources to best manage and track their employees, all the way from the hiring stage through employee retention.

A remote-first company, Trakstar hires globally and provides a number of generous perks to their worldwide employee base.

These benefits include flexible time off for their workers, ample employee development resources for their staff, and bonuses and financial compensation (dependent on the specific country of hire).

7. Doist

Screenshot from Doist website

Doist is a software company specialising in productivity apps and tools, with a goal of providing software solutions that help people accomplish their goals.

Doist works on a remote basis with no limitations on employee locations. To ensure easier onboarding, Doist also assigns a mentor to newly-onboarded employees, and offers the possibility of flying out to the mentor’s location for a week in order to work side by side with a colleague at the beginning of employment.

The company also covers the fee for a coworking space of the employee’s choice, and has a budget for work-related services, personal development, and work-related hardware.

8. Frontastic

Frontastic is a company that provides a platform for e-commerce, brands, and mobile-focused startups to create mobile-first experiences, with a focus on delivering complete platforms for mobile-first e-commerce.

The Frontastic team is remote-first and spread around the world. For team-building, the company offers perks like three company meetups a year and a yearly five-day retreat.

Outside of these meetups, Frontastic offers flexible working hours and a generous working allowance.

9. Stripe

Screenshot from Stripe website

Stripe is a platform that companies use to collect and process payments. It allows business owners to create an app or website with a checkout flow that connects to their Stripe account and processes transactions with customers. This can be used for recurring billing, for example with subscriptions, or for one-time payments.

Stripe was ahead of the curve in implementing both remote and hybrid working models, hiring their first batch of remote-only engineers back in 2013.

The company offers flexible working hours, caregiver leave, and a monthly allowance for employee wellness.

10. Twitch

Screenshot from Twitch website

Twitch is a global leader in live streaming and video game streaming, with more than 5 million active users a month. Headquartered in San Francisco, California, the company has offices in nine countries.

Twitch is remote-friendly, although employees must still be based around one of its offices. It provides commuter benefits, flexible paid time off, and monthly contributions to employee wellness.

Wrapping up

I hope this article has helped you out if you're looking to work remotely as a developer but don't know where to start.

Remote work is a growing trend in the tech industry, and there are a lot of great resources out there to help you get started. In addition, I hope this enables you to find a job that suits your personality and lifestyle.

If you learned something new or enjoyed reading this article, please share it so that others can see it. Until then, see you in the next post!

You can also find me on Twitter @Davis_McDavid.

And you can read more articles like this here.

I have curated a list of 25 sites for remote work. Whether you are looking for part time, full time, or freelance work, these are the best sites to look into.

Here is the complete list. Once you find a website that interests you, click that link and it will jump you down to a more detailed description of that website.

1. Arc
2. We Work Remotely
3. Skip The Drive
4. Power to Fly
5. Remote OK
6. Remotive
7. FlexJobs
8. Dribble
9. AngelList
10. Remote.co
11. JustRemote
12. Virtual Vocations
13. Pangian
14. Working Nomads
15. Jobspresso
16. Outsourcely
17. Landing.Jobs
18. Authentic Jobs
19. Stack Overflow
20. Gun.io
21. Idealist
22. Fiverr
23. Upwork
24. Freelancer
25. freelancermap

Arc

Arc is a site dedicated to remote developer jobs. Arc provides many free resources including a job search by tech stack, a resume guide, salary explorer, virtual events, and interview questions.

You can also browse through Arc's list of Top Remote Companies that are hiring right now.

We Work Remotely

We Work Remotely offers free job postings in frontend, backend, full stack, mobile, design and more. You also have access to their events, forum, and slack group.

Skip The Drive

Skip The Drive offers free job listings in the areas of development, project management, sales and more. This site also offers a list of Micro Job Sites, a Remote Job Savings Calculator, and a Job Application Tracking spreadsheet.

Power to Fly

Power to Fly specializes in connecting candidates from underrepresented backgrounds to potential employers. When you create an account you'll have access to job listings, career events, coaching sessions, mentorship and more.

Remote OK

Remote Ok offers free job listings in development, online teaching, design and more. This site also has a separate page for just freelancers where you can create a profile and have access to thousands of jobs.

Remotive

Remotive offers free job postings in the areas of IT, development, design, QA and more. Remotive also provides career guides, webinars, and paid access to the Remotive community.

FlexJobs

FlexJobs is a subscription site for remote part-time, full time and freelance jobs. If you are skeptical about paying for job postings, then check out their Better Business Bureau rating and reviews.

This is the current pricing list for the FlexJobs subscriptions.

Members have access to their job listings, events, and articles. FlexJobs also offers career coaching, resume reviews, and mock interviews for an additional cost.

Dribble

While Dribble is mainly known as a place for freelance designers to post their work, there is also a section for remote graphic design jobs.

AngelList

AngelList offers software job listings at startup companies. You will need to create an account in order to read the full job descriptions and apply.

Remote.co

Remote.co offers free job postings in the areas of IT, development, design, QA and more. If you upgrade to the premium service, then you have access to more job postings, career coaching, and resume reviews.

JustRemote

JustRemote offers free job postings in the areas of DevOps, development, design and more. They also offer an online resume builder to help you get to the interview stage.

For an added cost, JustRemote has a feature called PowerSearch that provides you with additional job postings that are normally hidden from the general public.

Virtual Vocations

Virtual Vocations is a free service that provides you with remote job listings in development, technical writing, QA, project management and more.

Virtual Vocations also offers a paid subscription service which includes courses, webinars, and career coaching sessions.

Pangian

Pangian offers free remote job listings in the areas of development, IT, sales and more. You will need to create a free account in order to access the job details.

Pangian also offers free career tips and a community forum. For an additional $149.99 (US dollars), you can have access to the one on one resume and CV audit.

Working Nomads

Working Nomads offers free job listings in development, design, DevOps, project management and more.

Jobspresso

Jobspresso offers thousands of free listings in development, design, DevOps, customer service, and more.

Outsourcely

Outsourcely ensures that job candidates are paired with the right company. Create an account and browse through thousands of postings in web development, mobile, design, customer service and more.

Landing.Jobs

Landing.jobs connects independent contractors with remote jobs. Create an account, go through the Landing.jobs evaluation process, and then start applying for remote work.

Authentic Jobs

Authentic jobs offers free listings in web development, mobile, project management, design and more.

Stack Overflow

Stack Overflow is mainly known as a place for tech questions and answers but they also have a jobs section. For remote work, just select the remote options in the search parameters.

Gun.io

Gun.io specializes in connecting developers with software companies. Create an account, apply for jobs, go through interviews and start working.

Idealist

Idealist is a site that posts hundreds of jobs for non-profits and organizations that want to create change in the world. For remote work, make sure to choose that option in the search parameters.

Freelance projects and micro-jobs

Fiverr

Fiverr is site where you can create a list of services and offer them to Fiverr's global audience.

Upwork

Upwork is a place for freelancers to bid on jobs, sell their projects, and connect with recruiters.

Freelancer

Freelancer specializes in connecting clients with freelancers. Freelancers can search through thousands of projects and make bids.

freelancermap

freelancermap specializes in connecting freelancers with clients all around the world. Freelancers can create an account and bid on projects that match their skills and experience.

##

Achieving a big goal like transitioning into a new career can be extremely challenging and overwhelming.

The amount of information isn't the problem. We have access to more information than we ever have. The problem is knowing how to effectively execute on the information available to us.

The more I progress in my life and career, the more convinced I am that the path to success does not lie in setting massive goals, and then cranking every day to reach them.

The path lies in choosing your goals, then designing simple systems built with small habits that will facilitate achieving those goals.

But one crucial component is to not measure your success when you reach your goal, but measure your success each time you successfully execute on your system.

This means that you are in a constant state of success instead of being in a state of failure 99% of the time with brief spurts of success.

This not only is better psychologically but leads to a higher likelihood of you actually achieving your goals.

In this article we'll go over how to apply this philosophy to the goal of getting your first developer job. Although I should note that even if you are already working as a developer, these strategies will still apply to anyone looking to build a more fulfilling, robust career.

This note is important, so I'll reiterate. We are not looking for short-term wins here, we are looking to design a system and build a collection of habits that you will continue throughout the life of your career as a developer.

These habits will allow you to not only land your first job, but as you progress further and further, they will help you grow your network, influence, and skills. The byproduct of this is finding work you enjoy that pays well, and having abundant opportunities at your disposal.

Most of the ideas here have been adapted from Tiny Habits by BJ Fogg, Atomic Habits by James Clear, and my own personal experience getting my first dev job without any experience or education.

I'm currently reading Tiny Habits right now and I really like the focus on simplicity here, so we'll focus a lot on Fogg's technique for this article.

Let's get to it.

Overview of the Tiny Habits Method

Very briefly, let's go over the philosophy and methodology of Tiny Habits. At its core, the system follows the idea that the best way to make consistent, lasting change is to make that change tiny – embarrassingly so.

Fogg argues that motivation is a poor tool to rely on when making lasting change. It fools us into thinking we can make significant change, because significant change is possible for a short time when we feel motivated.

The problem is that motivation doesn't last. So when the motivation wanes, you don't stick to the large, ambitious goal you set for yourself. Then you feel like a failure, so your motivation tanks more, and the cycle repeats itself for most of the big changes you want to make.

Instead, you should create the smallest possible action you can in working towards your goals.

So instead of trying to create a habit of doing 50 pushups per day, set a habit to do two.

Again, the idea rests on the habits being very very small. The point is that it should take almost no effort at all to do it. Then you instill the habit, and gradually increase the amount that you do.

As a general rule, the habit should take less than 30 seconds to complete.

Another crucial concept focuses on celebrating your wins immediately. You want to make the connection in your brains between successfully completing the habit and positive emotions.

It's cheesy, but I do a little mini dance every time I complete mine, a little something like this:

The other key component of creating Tiny Habits is the recipe. Tiny Habit recipes follow this formula:

After I [anchor action], I will [tiny habit].

This anchor action is crucial. This is a task that you already complete and that is already a solid part of your schedule that you anchor your new habit to.

It should be in the same location and have the same context as your new tiny habit.

So here's an example of a bad anchor and tiny habit:

After I take the dog out, I will floss one tooth.

Because the location and context are so different, this is unlikely to stick. Here's a better option:

After I brush my teeth, I will floss one tooth.

Again, I highly recommend you check out Fogg's book, Tiny Habits, for a much more thorough exploration of this method.

For now, let's look at how we can apply this method to launching a successful dev career.

Tasks to Focus On

We want to focus on three main components for building out our dev career:

1. Develop your skills
2. Establish an online presence
3. Start networking

Let's briefly go over these, and then we'll cover how to translate them into the Tiny Habit methodology.

Develop Your Skills

This one is pretty self-explanatory. You need to grow your development skills if you want to be a developer. The key here is to make sure you don't get stuck in tutorial hell forever.

Tutorial hell is appealing because following tutorials and courses does not take nearly as much mental or creative energy as building something from scratch does.

So you fool yourself into thinking you are learning when all you are really doing is copying what someone else did.

But building that out, having it work smoothly, and then seeing the finished product makes your brain feel good, so the habit solidifies and the cycle continues.

Here you want to start building the tiny habit of writing your own code and building your own things so you can replace that feedback loop with a more useful one.

Establish an Online Presence

Building an online presence encompasses a few different things. The most important are social media and your portfolio site. When I say social media I mean Twitter and LinkedIn.

Say what you want about them – and I definitely have my issues – but they are invaluable when trying to start and grow a career.

As with most things, the key to growing on these platforms is to be consistent. So this is a perfect fit for the Tiny Habits framework, too.

Engagement on these platforms is huge, especially at the beginning when your account is still small, so you really want to make sure you are showing up every day.

Start Networking

Finally we have networking. Although there is some networking included in our online presence component because of interacting with other people, the networking we want to focus on here is more direct.

When you are first starting out, it can be very helpful to start reaching out to companies you admire directly, telling them so, and introducing yourself.

This is a bit of a secret weapon because very few people do it, but it's very powerful.

Let's look at how we can create some Tiny Habits around these three main goals. Remember, the goal is to start embedding the habit in your brain. Then you can increase the amount of each of these things over time.

How to Develop Tiny Habits

You'll need to come up with the anchor actions on your own. Anchor actions are specific to each person, because they consist of things you already do as part of your routine.

So I'll give you recommended Tiny Habits, along with my anchors, but ultimately you'll need to come up with your own.

For skill development, I recommend something very simple:

After I take my first sip of coffee, I will write one line of code in my own project.

Remember, the anchor action should be specific to you. I already make coffee before I start working in the morning, so the first sip is my anchor.

Don't discount this because of the simplicity and ease of the task. That's the point. Make it ridiculously easy to start and the snowball will grow as you gradually increase the task.

Now, for online presence:

After I check my email, I will write one thoughtful reply on Twitter.

Again, I'm using what is an existing part of my routine and then anchoring my habit to that.

Finally, for networking:

After I check Twitter, I will write down one person I want to reach out to.

Same concept here.

These are just examples, and I recommend you start with just these three for a few days while you get used to how this works. Then you can gradually start to expand the habits and start to add more for the particular tasks you have.

Please don't overcomplicate this or try to add anything more. The goal is to make it so small and so easy that it feels stupid and pointless to not do it. These will begin to compound as you begin to build that habit and execute on it every day.

And don't forget the celebration! That part is crucial for forming the pathways in your brain that will make executing on these actions sustainable and fun.

Wrapping up

So much of why people struggle to make progress on their goals is because they go too big too fast or struggle with information overload.

This simple system solves both of those problems, but we naturally resist it because it seems too small to make a difference.

In reality, when we go overboard for a day or two, then burn out for a week or two, we are taking one step forward and two steps back. No matter how big the steps are, we aren't making progress.

But when we implement the Tiny Habits method, we might be taking miniature little baby steps, but we're taking them every day and always forward.

Finally, if you would like a step-by-step walkthrough on how to land that first web developer job, I have a free 10-day email course at LaunchYourDevCareer.com. It covers a lot of what we talked about here plus a lot more in order to give you a concrete path to that first job.

Well, the answer isn't a simple yes or no. Turns out, it basically depends on whether you're in academia or not, and possibly where you live. But more on that below.

If you're job hunting, or just want to keep your credentials up to date, you'll want to make sure you have a résumé or a CV on hand.

Let's look at each document in detail. In this article you'll learn what a CV is, how it differs from a résumé (and when that distinction matters), and when you might need each one.

What is a CV?

A CV, or curriculum vitae, actually has two meanings, depending on the field you're in.

But first, what does the Latin "curriculum vitae" actually mean? Well, it means "the course of (one's) life". Which makes it sound like quite an epic document, depending on how much life experience you've had.

CVs in Academia

If you're in academia and/or are applying to an academic position, this makes sense. A CV in this case refers to a detailed document that explains your educational and professional background, any publications you have, research you've done and so on – in great depth.

You'd also use this type of CV if you're applying for large grants or fellowships, for certain jobs in medical and scientific fields, and so on.

CVs in Industry Jobs

On the other hand, in both British and American English, the term CV can be used to reference a short document that catalogues your education, career history, and skills. It's usually no more than a page (front and back at the most) and provides the most important highlights you want your potential employer to know.

Basically, in this case, a CV is what you'd send to a company for whom you want to work as a data scientist, programmer, business development lead, and other jobs like those ("industry" jobs). It would be the first thing the employer likely sees when considering your application, and they'd probably spend about 6 seconds reviewing it.

So, just to summarize:

• In academia, a CV refers to an in-depth personal and professional life summary that includes education, career history, publications, and other professional achievements and awards.
• In other industries – like tech or business – the term CV refers to the short education, career, and skills summary you submit with job applications.

CV vs Résumé – What Are the Main Differences?

The shorter CV might sound familiar – and that's because it's basically interchangeable with a résumé. In the United States and elsewhere, you can use both terms (CV and résumé) to refer to the shorter document you submit with job applications.

So what are the main differences between academic CVs and traditional résumés? Let's take a look at the primary components of each so we can better distinguish between the two documents.

What to include in an academic CV

As we learned above, a CV intended for the academic world includes more detail and generally more information than a résumé. Generally, you'll want to have sections for:

• Your professional qualifications – any certifications you might have
• Your educational background – your degree(s), any theses you've written, other courses you've taken
• Your work experience – jobs you've had, projects you've worked on, internships you've held, teaching positions you've had, research you've conducted
• Your accomplishments – any awards or honors you've received, fellowships or grants you've been awarded, books or papers you've written
• Your activities – you can include things like volunteer work, serious hobbies, side projects
• Any special qualifications you might have

What to include in a résumé/shorter CV

You might have heard that recruiters or employers might spend no more than 6 seconds reviewing your résumé – and while that's not always true, you have to imagine it might be.

So your résumé needs to be focused and to the point, and should only highlight your most recent experience and achievements, and your strongest skills. Here's what to include:

• Your name and contact information – make sure you include an email address, and you can also add your social media handles if you want.
• You can include a summary – a couple sentences that gives an overview of your professional experience thus far (a brief "getting to know you" paragraph).
• Your educational background – where you got your degree (if you have one) and any post-grad work. If you didn't go to college, you can list any bootcamps or online courses you've taken.
• Your work experience – if you've had a number of jobs and have a fair amount of experience, just include the most recent and relevant. If you're new to the job market, include any projects, internships, or other relevant experience.
• Your top skills – if you're applying for a job that requires specific skills, and you have those skills, list them. You can also list general skills that would apply to that position.

This is the primary info you want to include. Your résumé shouldn't be much longer than a page (maybe two if you've had a lot of experience/jobs), but if you have more room you can include honors and awards and side projects.

So in short, academic CVs are much more in-depth, cover more ground, and provide a more complete picture of your entire professional history.

Shorter CVs/résumés, on the other hand, focus on your relevant education and work experience, and the skills you have that are applicable to the job for which you're applying.

Example of a CV

Here's an example of a pretty impressive CV. I'll include a screenshot of the first page here, but it's 10 pages long.

Thank you to Dr. Tuba Yilmaz Abdolsaheb for sharing this example!

Example of a Résumé

And here's an example of a shorter CV/résumé, like what you'd take to an industry job interview. This example is for a data scientist, and the entire thing is one page long.

Thanks to Indeed for the example.

And that's it!

Hopefully now you know the differences between an academic CV and a shorter CV or résumé, and will know which one to choose when you're applying for jobs.

At DevSkiller, we are known for our detailed industry reports that assist IT recruitment professionals with their hiring decisions. And this past year has been the most diverse and data-heavy set of information ever compiled by our team.

Despite the circumstances that 2020 brought us, the show must go on. We have compiled 304,654 coding tests sent to developers in 156 countries to create the 2021 DevSkiller IT skills report.

Whilst it’s easy to point to the big tech multinationals that will indeed profit from a crisis like we’ve had, many other small businesses will have a hard time adapting to the market’s fluctuating demands.

Innovative tech can help alleviate a lot of the unforeseen burdens in this pursuit, but businesses are wary of the risks involved by relying on unfamiliar technologies.

To make it easier to process how our world in tech has changed during the past year, I will provide insights into the dataset and emphasize some of the more relevant findings from the report this year.

1) Java and JavaScript are the most in-demand IT skills for 2021

One of this year's most significant developments is that Java has rejoined JavaScript for the top spot in IT skills. The two popular languages were seen in 43% of test invites.

The remainder of the top 5 are SQL, .NET/C#, and CSS/HTML for the second year running.

With Java once again asserting its relevance, this trend indicates that despite the importance of front-end architecture in software development, many companies seek developers who are skilled in back-end technologies.

As we found in last year's report, the top 5 IT skills are commonly tested with other languages across DevSkiller’s platform. However, it goes to show that more and more companies are searching for developers competent in these IT skills.

2) 75% of companies are looking for JavaScript developers

Interestingly, the top 5 desired IT skills have remained unchanged from last year. There has been a slight shift in their overall percentages, but the list has more or less stayed the same.

This past year, 75% of companies were looking for JavaScript developers. SQL took out second place with 63%, while Java has dropped slightly to 51%. HTML/CSS and .NET/C# have both seen minimal improvements from last year registering 48% and 41%, respectively.

These numbers are also backed up in the Stack Overflow 2020 Developer Survey, where it also holds the top spot. This is enough evidence to suggest that JavaScript remains the go-to front-end IT skill.

We’d like to point out the growing shift towards TypeScript as a replacement for JavaScript. The distinction between the two is not specified in this report as we classify most TypeScript coding test invitations as JavaScript on our platform. In forthcoming years, we'll make a clearer distinction.

For another year in a row, SQL reigns supreme as the most popular database IT skill. While companies are increasingly choosing .NET/C# to solve technical issues, Java still remains the preferred option. The rise in popularity of HTML/CSS points to the ever growing need for skilled web developers.

3) Google Chrome and Windows 10 are the most popular browser and operating system on our platform

Over the past year, we decided to run an analysis on the most popular browsers and operating systems used by candidates on our system.

Rather unsurprisingly, Google Chrome (68.84%) was the preferred browser by a considerable margin. This finding mirrors data from StatCounter Global, which lists Google Chrome as the most popular web browser (63.54%) at the time of publication.

Mozilla Firefox (15.28%) came in second place on our list, followed by Edge-chromium (6.01%) and Safari (3.93%). Our supplementary source, StatCounter, has Safari in second place while Firefox sits at third.

This suggests that developers have different needs that are better met by Firefox - suggesting that developers don’t necessarily follow the same trends as the general public.

Taking the top spot for the most popular operating system was Windows 10, with 54.13% of developers using this operating system. Again unsurprisingly, this was in line with the 2020 Stack Overflow Developer Survey, where almost half of the developers surveyed used Windows as their primary operating system.

Following that was macOS (23.01%), Linux (12.64%), while Windows 7, Windows 8.1, Android OS, and iOS were all used by less than 5% of developers.

4) More candidates are taking coding tests than ever before (69%)

This past year a record 69% of tests were sat by candidates, resulting in our highest uptake rates ever. Last year, only 41% of candidates took the test. If you take into account the fact that companies sent out DevSkiller coding tests to a greater number of candidates than last year, it is an even more impressive feat.

We believe the higher uptake in this year's report is likely due to the COVID-19 pandemic. Candidates who have either been forced into unemployment or are uncertain about their job security are not ignoring their coding invitations.

5) React, MySQL, Spring, ASP.NET, Data Analysis, HTML, Laravel, and Bash are the most popular technologies in their respective tech stacks

Since our tests were created with the tech stack in mind, we are able to see what the most popular IT skills, resources, and technologies are in their respective stacks.

React is the most popular technology used in the JavaScript tech stack, present in 35% of tests.

React leads the way for the second year running as the most popular technology within the JavaScript tech stack.

Just as it did last year, React tops the Hacker News hiring trends extending its streak to 31 consecutive months at the time of publication.

MySQL is used in more than half of SQL tests at 53%.

MySQL has increased in popularity year after year, with a near 16% increase for the database management system in 2020. SQL Server and HSQLDB placed in second and third.

Spring is the most used tool in the Java tech stack with 36% of tests.

Spring is still the most popular tool here but has lost some ground compared to last year (47%). The user-friendliness and functionality of Spring Boot placed the popular framework in second position.

ASP.NET is seen in almost half of all .NET/C# tech stack tests.

The leader from last year once again tops the list for the .NET/C# tech stack with a whopping 45.93%. SQL Server (36.90%) overtook MVC (36.35%) by a narrow margin to come in second place this year.

Data Analysis tops the Python tech stack, being used in 35.22% of tests.

Holding its place for the second year running is the popular open-source web framework Django with 20.96%.

HTML was present in 94% of all CSS tests.

As the two technologies are so interchangeable, it's little surprise that HTML featured so predominantly in the CSS tech stack.

Laravel remains the most popular resource in the PHP tech stack with 26.65% of tests.

Despite dropping slightly from last year, Laravel remains the most popular framework of the PHP tech stack. Symfony was the other clear standout seen in 17.07% of tests.

Bash is the industry leader in the DevOps tech stack, present in 70.61% of tests.

This is the first year that we've included the DevOps tech stack in this report, and it's popularity in recent years has quickly increased. Following Bash was networking (65.31%), and then Docker and System Administration tied at 54.69%.

6) Countries are looking abroad more than ever for their technical hiring needs

The COVID-19 pandemic has caused significant changes in company hiring patterns. As a result, most companies have undergone rapid transformations into remote-friendly or even remote-first workplaces, which has prompted a substantial rise in international hiring.

This year, the UK, Canada, Australia, Indonesia, Denmark, and Chile all saw increases in their international hiring percentages.

7) Australian developers scored the highest on coding tests

In previous years, we used the mean score to determine the highest scoring developers by country.

This year, we have analyzed the 90th percentile — which demonstrates the results that only the top 10% of candidates in a given country scored better than. We made this change because the mean score includes outliers that often influence averages and skew results.

Australia took the top spot for IT skills this past year, with 10% of Australian developers scoring higher than 93.56% on their coding test. Developers from the US came in second (90.91%). Rounding out the top 5 were Sweden (90.35%), Portugal (89%), and Poland (87.50%)

8) The US is driving international recruitment but has only the 5th largest labor market for overseas recruitment

The US is the global leader in international hiring but has slipped to the 5th largest labor market. In 2020, we saw the US drop from second position to fourth, forming part of a continuing downward trend.

These statistics are testament to the improving quality of developers from other markets. Brazil holds its position in the top 5, while developers from Russia and Canada are becoming increasingly popular sources for overseas recruitment.

The other trend we see is that companies are concentrating on allocating IT skills to outsourced-focused countries. This trend is likely to continue for years ahead.

Interestingly, Canada and Brazil are in first and second position for the top countries from which the US recruits its developers. As we noted last year, the proximity and the relative time difference makes them desirable for US companies to source developers from those countries.

What do these IT skills numbers mean for us moving forward?

2020 challenged us in every way possible. The consequences of its impact will undoubtedly take years to recover from, including the tech world.

Despite this sobering reality, The Bureau of Labor Statistics projects an 11% growth in the IT industry over the next ten years. An even greater uplift is forecasted in the field of software development.

We’ve also analyzed the state of the global IT market for 2020 and the outlook for 2021. As reported by CompTia, research consultancy firm IDC projected global IT revenue to be $4.8 trillion for 2020 back in August, however due to the COVID-19 pandemic it failed to reach that mark.

As expected, in 2021 the US will be the largest tech market in the world with 33% of the total revenue or $1.6 trillion. Outside of the US, Western Europe (19%) and China (14%) are the next two largest technology markets projected for 2021.

While all of our data was compiled over the past year, it holds some interesting insights for the year ahead:

• The developer labor market in the US is shrinking — whilst still the global leader for technical hiring, it now is in fifth place in regards to providing professionals with IT skills to the global market.
• Australian developers have staked their claim as some of the best developers in the world.
• JavaScript is not going anywhere, and the legacy technology’s popularity and demand only seems to be rising.
• The pandemic afforded more time for candidates to take and finish their coding tests.
• Familiarity with database languages such as SQL will go a long way and Spring Boot is also slowly rivaling Spring as the most popular resource in the Java tech stack.

These are just some of the findings in the report. Check out the full 2021 DevSkiller IT skills report if you want to get the complete picture of these insights and more.

More than growth or money, I wanted to find where my interests truly were. Not to mention, working to make my own ideas come to life gave me immense joy.

One question that I often encounter with regards to my profession is,

How did you manage to get your first freelancing projects?

Because everyone knows that getting your first gig is arguably the hardest part of freelancing. This blog post and video (at the bottom) is about building a strategy to start your freelancing career.

Why freelancing?

Who doesn’t want to set up a side income if you’ve got the time? Maybe you want to save up for a car or maybe you want to take a break year. That’s where freelancing comes in.

Not to mention, you can become “your own boss”, work from a beach house in shorts, and at the same time, there is no limit to how much you can earn. You possess control of your growth.

So, here you go!

Five Steps to Follow to Get Your First Freelancing Project

As I see it, there are five steps you need to follow that'll help you get your first gig and establish a freelancing career. Here they are:

1. Identify your skill as a service

2. Define your ideal client or market

3. Build your portfolio and profiles

4. Market your services to clients

5. Capture the results/gaps, analyze the output at each step, and attune your approach to keep growing.

Step 1 — Identify your skills as a service

The skills section of your résumé simply lists down your knowledge in terms of technologies and techniques. But you have to identify what you can do with each of those skills in the real world.

Make it explicit so that the client understands what you can do for them.

Your skills could be:

• Web development

• Graphic design

• Digital marketing

• Data Analysis

Your services could be:

• Building high-performance end-to-end websites and web applications.

• Creating beautiful illustrations and digital artworks for websites, videos, and posters.

• Helping individuals and SMEs in promoting their products and services online.

• Crunching data to uncover patterns and answer important business-centric questions to make informed decisions.

You can see the do's and don't's at each step in this infographic:

Most people struggle with taking the first step. They are not sure if they are ready yet. I believe you’ll never be ready. Just start!

Here’s a tweet from Gumroad’s founder, Sahil Lavingia:

For the rest of the article, I am going to focus on web development and data science services, but you can apply these principles to almost any service that you have to offer.

Tips:

• Look for people who have made a successful career out of freelancing. Study and replicate their process.

• Learn to use the right phrasing— tell your potential clients what you do and why you are better than the rest.

Step 2 — Define your ideal client or market

This whole blog post basically tries to answer the question, “how do you land your first client?”

There is no freelancing career without clients, but that doesn’t mean you should reach out or pitch your services to just anyone. This won't do you much good, and instead will add to your frustration.

Since you have your niche from the first step, now do some research on who needs that kind of service.

Examples of a few clients may include:

• Web development — Local stores, fitness instructors, institutes, hotels, creators (hot right now)

• Data Analysis — Data-driven startups/orgs

• Developing ML models and apps (DevOps)— Platform as a Service and Software as a Service organizations.

Who are not ideal clients (at least for a first client):

• Franchise businesses

• MNCs, heavily guarded corporates operating in stealth mode for their clients (ZS, E&Y, Deloitte, and so on)

Pro-tips:

• Look for individually owned businesses for web development.

• For data science projects and opportunities, first make sure you have a good grip on your fundamentals. Use platforms like codementor to help students with their projects.

Step 3— Build your portfolio and profiles

After determining your niche and your target clients, it’s time to set up your shop. In this case that can be your portfolio website (highly recommended) or profiles on platforms like LinkedIn, Upwork, Toptal, or AngelList.

Portfolio website

An important thing to note here is that you want someone to trust you with their business.

How can you make someone trust you?

You can start by telling your professional story. Portfolio websites are one way to do just that.

If you don’t have a story to tell yet, create one by working for yourself. You can build sample websites using commonly used themes available online, or you can propose to work on a project for a prospective client for free.

Most people mistake a portfolio website with an online résumé.

A portfolio website is not for you but for the clients that you want to target. It should showcase your services through:

• Work samples — websites/applications, reports you have created, conference talks (if any), and so on. If you don’t have any samples, create a few! Develop dashboards/websites, host them, and show that you can deliver high-quality work.

• Testimonials/recommendations — ask your former colleagues/bosses/clients to write you a testimonial.
  TIP: if you haven’t worked anywhere before, do 1–2 free projects for prospective clients and then ask them to write a testimonial. I have done 2–3 free projects where the person referred me to another party.

• Write Blogs — this is something that has worked well for me. It is a way to establish your credibility. The blogs should contain relevant and authentic content through which the client can learn something about their business. Start by giving away!

Example ideas for blog posts:

• How to reach a wider audience with a website

• What type of business metrics your Dashboard/Reports should contain

Profiles

Apart from having a website, you should also be socially present on professional platforms like LinkedIn. This will help you look for and connect with prospective clients. It can also give you work ideas, it lets you post updates, and helps you promote yourself.

You can use the same principles we just discussed above when you're developing your social media profiles.

A good profile can increase your odds of getting an opportunity for various reasons:

• It shows how seriously you take your work.

• It can display your work samples and proficiency in skills to offer a service in your niche.

• It can add to your credibility if you have testimonials or recommendations written by an authentic colleague/partner/ex-boss.

Freelancing platforms

_[Upwork profile](https://www.upwork.com/freelancers/~015a6822a75be60fd8?viewMode=1&s=1110580759050571776" data-href="https://www.upwork.com/freelancers/~015a6822a75be60fd8?viewMode=1&s=1110580759050571776" class="markup--anchor markup--figure-anchor" rel="noopener" target="blank)

In addition to LinkedIn, there are a number of platforms that host a complete freelancing ecosystem with clients posting their needs and freelancers bidding to do that work.

A few of the major platforms to look for freelancing projects/work include:

• Upwork

• Toptal

• AngelList (for jobs at startups)

So, how can you be successful as a freelancer on these platforms?

I’d say there is not one but multiple aspects of a profile that you have to get right. Your success relies on the following:

• Your proficiency in the skills you have listed on the platform.

• How well-curated your profile is.

• Your proposal for the job. It tells the client how good of a fit you are for that advertised job.

• Lastly, luck! It plays a very small and rare role if you get the first three aspects right.

Here are a few tips to build an attractive and authentic profile:

• Review projects that you’d be interested in applying for. Note down the keywords and skills that these clients use to describe their needs (skills that you possess, of course). Add these skills (strengths) to your profile that can connect you with the relevant projects. List up to 10 skills.

• Upload a professional picture along with a short and succinct bio that describes your niche/services.

• Highlight your best work in the portfolio.

• List down your certifications if you have any. Add weight to your profile.

• Be consistent with your skills, complete all sections of the profile, be concise and straightforward, and proofread each section.

Step 4 — Pitch to clients (outreach)

It’s time to get down to business. If you can sell your services and show that you're well-suited to the clients’ requirements and budget, you might win the opportunity.

But first, you need to get clients to propose to. This is where you need to work on your visibility and outreach.

There are a number of ways you can do that:

• Reach out to clients on platforms like LinkedIn — this is what worked for my niche!

• Use freelancing platforms —  Upwork (general), Toptal (engineers), codementor (if you’re an expert), and AngelList.

• If you want to go one step ahead, use Google Adwords (advertise your services) or create a Facebook group for selling services in your niche, in your physical location (city/state).

My approach (not necessarily good for your niche!):

• I do a lot of research to find organizations that align well with my niche. I mainly use LinkedIn, Twitter, and Google search (browsing) for this.

• I had categorized the shortlisted companies (~50) based on their domain (fintech, healthcare, Ed-tech) and created a template message, kind of like a cover letter, to go with the projects that they had in the pipeline along with my own ideas.

• Used to send samples of my work in each domain. If there was nothing to show, I’d start a new project in that domain and send them my GitHub repo to tell them what I was working on.

I landed my first freelancing client via Udacity in 2016. It was because I was one of their alumni and they launched a new platform. My proposal suited the client’s needs and I got hired. I consider myself fortunate in that regard.

It got easy after that:

Step 5 — Capture the data, analyse them, and attune your process

You might land your first project in a day, in a month, or in 6-months. Either way, an integral part of the process is to keep improving.

You might fail at your first attempt but use that failure to get better at it.

Capture the data:

• The number of projects/clients you reached out to. How many responded, got interested, rejected, or went ahead.

• Why your proposal got rejected. Request a comment from the client.

• People who are successful in your niche, what are they doing differently?

• What’s new in your niche? How are people operating?

Analyze the data:

• The gap between the requirements of the project and your portfolio — see what’s missing.

• Understand each data point you’ve captured, funnel the type of clients whom you had more chances to convert.

• Create a separate category of clients for whom you have to bridge a gap between their requirements and your expertise.

Attune your process:

• Start working on new projects to attain new skills or master the ones you have enlisted.

• Restructure, polish and attune your profile to the client’s needs.

• Re-write the proposal emphasizing their needs and your services along with your work samples and numbers/statistics (if applicable).

If you are spending 2 hours a day on creating proposals and pitching to clients, then spend at least 3–4 hours on polishing your skill. Your strategy will only work if you have that curiosity to learn and build every day.

Stick to these principles and it’s only a matter of time before you land your first freelancing client.

What are you waiting for? Let’s get started!

You can also watch the video on this topic on my YouTube channel:

If this tutorial was helpful, you should check out my data science and machine learning courses on Wiplane Academy. They are comprehensive yet compact and helps you build a solid foundation of work to showcase.

Okay, so you have decided to start looking for a new job.

Admittedly, this is a process that people are not too fond of, generally speaking.

While I am pretty sure I can't convince you to thoroughly enjoy the job searching process, I can share a method I have used multiple times in my previous job searches that has made the process feel much more organized and productive.

It all starts with a spreadsheet.

Create a ledger of your progress

First, create a new spreadsheet and title it My Job Search Journey.

Next, I suggest you create six-column headers:

COMPANY NAME

A pretty obvious one, but this is a very important piece of information to capture.

No one wants to start an interview and completely space the name of the company they are interviewing for.

POSITION

If you are applying to multiple companies and positions, things can get jumbled up pretty easily.

There are so many different titles in the modern tech landscape.

You want to make sure that you remain mindful of each position you are applying to for now, so you can easily recall this prior to an interview at this company.

LINK TO JOB

Eventually, you are going to attract interest from a company you apply to, awesome!

At first, you are excited, and then suddenly a wave of anxiety falls over you.

You do not recall applying for this position and are completely spacing the pertinent details for the role.

This is why inserting a direct link to the job posting is a prudent move.

Not only does this allow you to quickly recall important details of the company and its mission, but it also gives you great references for talking points during your interview with them.

These references can range from company ethos that you can speak to from personal experience or technology they use that you have also worked with.

DATE APPLIED

At first, this data point might not seem too relevant. But I think it can serve (at least) two purposes.

• First, it helps serve as a metric of how many applications you have submitted in a day, week, or month

This can give you a huge confidence boost, especially on days when you feel that the job search is never-ending. With date data captured, you can look back and reflect on all of the hard work you have put into the search, even before you get interviews.

That alone is hard work and you should be proud of that!

• Second, it can offer insight into how long a standard interview process can take

In my post How to Prepare for a Software Developer Interview, I explain the steps of the interview process.

This process can vary depending on the position and company. But being able to look back at an initial date and figure out where you currently are with a particular company can be another rewarding metric.

The interview process can be long and taxing. But as each day moves past your initial application date you can use this metric to give yourself another internal confidence boost. Wherever you are today is farther than where you were yesterday.

Be proud of that!

APPLICATION STATUS

After several applications paired with several interviews all at different stages, things can get really difficult to keep track of in between the ears.

This is where the Application Status column can really help.

If a company reaches out to you to schedule an interview, start keeping track of the date, time, and type of interview at each step along the way.

This can help keep awareness high for your immediate priorities, as well as a good way to avoid double-booking interviews for yourself.

I also suggest keeping track of applications that you were rejected from in this column.

By keeping track of your successes as well as your failures in the job search, you make it easier to examine your success rate.

If you find that out of one hundred companies, you are only getting five replies, it might be time to examine the things you have control over (like your resume and, if you have one, your cover letter).

All-in-all, having these data points really helps you solidify why you are or are not getting the results you want in your job search.

NOTES

Even if you are applying to jobs full-time, it can be really difficult to keep straight all the details of each job you have an interest in.

The last column, Notes, is essentially a placeholder for miscellaneous thoughts that you have about the company, position, or interview process.

This is also a great place to write reminders for whichever step of the interview you are in.

_For example – _Company ethos: Think of the end-user at all costs. Mention user acceptance meeting experience!__

If you spend a little bit of time to jot down a few notes that you think would be helpful during an interview process for a company, they usually go a long way for you and help you stand out more as a candidate.

The more thorough your preparation and the more thoughtful questions or experiences you discuss, the more favorable you'll appear to the interviewer. And it shows that you have a genuine interest in the position/company.

The Final Product

Next step: crush the interview!

If you have spent time on the job search and tracked your journey, I can not promise you that you will get an interview at each company you apply for. But I can promise you will feel more prepared and organized at each step along the way.

If you have put in the time and landed interviews, congrats! I wish you all the best on your journey.

If you are just beginning the job search process, good luck! You've got this.

Are you new to software development and trying to land an interview? Take a look at my post on Getting an Interview as a Software Developer.

I care about the future of work because I have always been fascinated with how people earn money and the jobs they hold.

I grew up in a family that valued household chores, so I got a job washing cars in my neighborhood when I was nine years old.

Often I am asked (by my parents no less) what the next few years will look like in the job markets. I used to work at Indeed, the employment-related search engine, and spent a lot of time thinking about how people will work together - and in companies - in the future.

Specifically I am asked: What will change?

Alas, I can’t predict the future.

But what I think is an equally interesting question – although one that is all too often overlooked – is what about the future will not change? In other words, what will look the same today as it will next month, or next year?

I believe how companies attract and retain talent will change. But some of the methods used today will remain constant.

I have observed how hundreds of firms attract new workers successfully. And I have boiled down the key learnings from their job postings and hiring pages. From them, I have extracted learnings that are useful if you are looking for a job or if you're a hiring manager looking for workers with technical skills.

I want to share these lessons with you.

#1. Companies will need to offer new and differentiated employee perks and benefits.

When looking at tech-centric job openings at companies today, it is common to see perks like “office dog” or “unlimited cold brew” or “team happy hour”. These keywords appear on many job descriptions as benefits of employment.

But in the era of COVID-19, it is painful to see job postings that are misaligned with how staff spend their time.

I have hired staff that works remotely and know that their needs are in many ways different from traditional office workers.

Welcome packages, a personal budget to optimize a home office, or a food delivery account are probably better aligned with what remote staff want.

Companies must think holistically about their benefits packages and ensure that they are relevant to today’s workforce.

As companies become more in tune with what workers care about, they're changing their hiring policies and interviewing strategies to accommodate remote talent. And the innovative companies will continue to offer differentiated benefits and perks to empower their staff.

An emerging perk that a growing number of firms are offering is in-house technical training and upskilling.

Helping staff develop and grow not only keeps ambitious workers around longer but it deepens the human capital and intellectual property possessed by the firm.

I have one friend who works at a company that is giving staff “time off” to learn how to create e-commerce sites and chatbots.

If you are a builder and creator, can you think of a better retention perk?

#2. Companies will embrace authenticity culture so that workers can bring their whole selves to work.

Mark Zuckerburg, best known for co-founding Facebook, made the hoodie popular among tech workers. While Silicon Valley has long valued a more informal culture, non-tech companies from Main Street to Wall Street are evolving as well.

Fewer people are shopping for suits and ties. Tailored Brands, the parent company of Men’s Warehouse and Jos. A. Bank, filed for Chapter 11, a form of bankruptcy that involves a reorganization of a debtor's business affairs.

When Tim Cook, the American philanthropist and Chief Executive of Apple recently made a press announcement that Apple would produce one million face shields a week, he did so in a cotton t-shirt from his home office.

Such informal attire would have been unrecognizable at Apple in years past.

In order to attract and retain technical workers, companies will need to embrace talent in a holistic manner. From how they dress to how they vote, workers will demand that companies let them bring their whole selves to work.

Many large technology firms - including Indeed, Google, and Facebook to name a few examples - have internal resource groups. Amazingly, these groups - designed to bring people with similar backgrounds together - are all too often not used in job postings or recruitment efforts.

If your firm doesn’t have resource groups, it should consider building them out. If your firm has resource groups, it should consider telling prospective staff about these communities.

If a firm wants to attract and retain technical talent, it will need to embrace authenticity culture. Companies will want to bring their culture to the forefront of why their workforce is unique and exceptional.

#3. Salary and job structure will continue to matter but so will holistic compensation and autonomy.

My parents, and many of their generation, valued jobs that had predictable compensation, simple to understand benefits packages, and structure.

It is well documented that baby boomers spent far more time in jobs and changed roles less frequently than members of today’s workforce. A pension, a once common corporate benefit, is now a rarity.

I don’t see people, or job postings, focusing less on money. Rather, I do see that job seekers want more holistic compensation packages (time off, mental health services) and increased autonomy.

I recently heard a peer state the following about his manager: “She is great because she is entirely hands-off in her approach to how I run my book of business. I give her updates but it’s my product to take to market.”

His freedom to take the actions he deemed in the best interest of the business was a currency that made him value his role more.

Today, innovative firms are attracting and retaining staff by offering childcare stipends, monthly food or health benefits, or pet adoption policies.

One innovative startup is offering its technical workforce access to virtual games. By encouraging staff to play games and understand the mathematical models behind games like solitaire, the firm can help their teams develop new mental capacities in a fun way.

Final Thoughts

The future is yet to be written. Labor markets, like technology, are constantly evolving.

Even though there are more workers than job openings, some sectors of the labor market are seeing red-hot demand. This is particularly true in the fields of cyber-security and Information Technology.

That is why re-conceptualizing how to hire and attract staff is so important: if you can’t predict the future you need to be well equipped for anything the future holds.

The heuristics one will choose to find a great job are unlikely to change. People will want a good salary, a good manager, and a good culture.

What will change is how we work, the mediums we use to communicate, our attire, and the underlying values underpinning work culture.

Companies need to be aware of these changes to retain the best staff and to keep these workers motivated and in their roles.

Cover letters, like résumés, are hard. And most people are bad at them.

This makes sense – you probably only write a cover letter or résumé every few years. It involves selling yourself and your skills, which is something most people struggle with.

On top of this, it's difficult to sort through all the advice on the internet and figure out what's actually worth following.

In this article I'll go over some common reasons why your cover letter probably isn't that great, along with my top 10 ways to improve your cover letter and stand out from the crowd.

Why Your Cover Letter Needs Work

People rarely think that their cover letter is the problem, even if they've been struggling to get interviews. They'll often say something like, "But I've had tons of people review it and they all say it's okay!"

There are a couple of problems with this.

First, you want your cover letter to be better than okay – in order to stand out in an extremely competitive job market, it needs to be stellar.

Second, most people don't know how to write a good cover letter, and therefore they can't help identify the problems with yours.

It's often hard for reviewers to provide constructive criticism for fear of hurting someone's feelings. What you really need someone who has a lot of experience hiring or recruiting in your specific field in order to receive accurate advice.

My Top 10 Tips for Improving your cover letter

As someone who has reviewed a lot of cover letters (good and bad), here's a few of the most important things to keep in mind.

Stop Reusing the Same Cover Letter

You should write a personalized cover letter for jobs you care about.

Cover letters are a way that you can stand out from your competition and show the organization why you're interested in working for them. This is more important to some organizations than others (FAANG typically doesn't care), but a great cover letter will never hurt your chances of being hired.

It can also be a helpful exercise for you – it gives you the chance to think about and articulate why you're interested in working for this company – so when you're asked in an interview, "Why this organization?" you have an answer readily available.

Don't Follow Outdated Templates

You can skip listing your address or your employers at the top.

Instead, treat it like an email, and start the letter simply with "Dear Hiring Manager". Don't worry about hunting down a specific person to address your letter to, unless you already know it.

You also don't need to struggle for creativity for an opening line. Stick to the basics such as "I'm interested in X" or "I'm writing about Y position".

Tell the Company Why You Want to Work for Them

Do you like the company culture and values? Do you think the work they're doing is interesting?

Give them a specific reason that you're interested in working for them at the start.

Also, let them know how you found them. Did you read a company blog about interesting research they're doing? Did you see that they deeply value philanthropy and encourage all employees to get involved in a range of volunteer efforts?

However you found out about them, make sure to include it in your letter.

Interviewing and hiring people is extremely expensive and time-consuming for an organization. Companies would prefer to invest that time and effort into people who are truly interested in working for their organization (and are therefore likely to accept an offer that is made), not any generic company.

If you can show an organization that you're deeply interested in working for them, it will likely increase your chances of being interviewed.

A good litmus test for this is to ask yourself, "if I changed the company's name and the name of the job, could I send this cover letter to a different company?"

If the answer is yes, you need to re-write your cover letter.

Communicate Why They Should Hire You Instead of Another Candidate

Don't just summarize your resume.

They have your resume. They know what it says.

This is a chance for you to tell the potential employer who you are as a person and why you would be a great fit for the job.

Have you received great compliments on your work from past coworkers and bosses? Can you confidently say, "I am the go-to person for all things X"? Mention it here!

For example, are you so passionate about networking that you read the Illustrated TCP/IP guide on the beach? Write about it! Did you spend weekends working on a cool app idea you had? Talk about it!

A lot of this section is context dependent – ideally you should have a sense of the culture of the employer and base the stories you offer on this. But in general, you can treat cover letters as a conversation.

Be Specific

You want to tell the company how you can solve problems they currently face.

Use examples of how you solved problems at your previous job to show how you'll be helpful to this organization.

It's very important to show this with specific examples, rather than simply tell them. This makes your claims more reliable and easier for an employer to picture.

It's much less effective to say, "I am a flexible problem solver, with great attention to detail and an ability to manage complex code pipelines."

Instead, it's much better to write, "In addition to being extremely adaptable, I recently migrated my organization's code release process entirely to AWS, where I was able to implement a continuous CI/CD pipeline. This resulted in the organization moving from 1 release per week to daily releases, with fewer reported problems, and 10% improved developer satisfaction reports. I apply the same level of dedication and focus to all projects I am assigned, from code reviews to major project overhauls."

One of these is significantly more believable, and shows, rather than tells, a prospective employer about your abilities.

Ensure Your Cover Letter Sounds Like You

This doesn't mean that the cover letter should sound exactly the way you talk. But it should still sound like your voice.

If the letter is full of statements such as, "If you are looking for a hard-working, dedicated sales engineer with team spirit," it probably doesn't sound like you.

The people you're sending your cover letter to are real people. Often, they were in your position just a few years ago, and if you're hired they're going to be your coworkers.

Think of them that way, and write the cover letter as though you're describing to a coworker why you're the perfect fit for the position.

Keep It to One Page

Don't make your cover letter longer than a page.

If it's longer than a single page, you've written too much. If you're looking for things to cut - think about the points above.

Was anything you're writing about covered in your resume? Remove it. Are there meaningless phrases like "If you are looking for a hard-working, dedicated sales engineer with team spirit,"? Remove them. Keep it simple and tell a story about why you would be a great fit for this job, on this team, at this company.

Think of this as your 'elevator pitch' where you practice refining your story for an interview. You can use a modified version of this story when you get the dreaded 'tell me about yourself' request in an interview.

Explain Any Inconsistencies

If you've previously only had jobs doing one thing and are now applying for jobs doing something totally different, you need a clear and convincing explanation why you would be good at the job.

Employers often receive hundreds, if not thousands of resumes for a single position. They need a fast, easy way to sort through the resumes in order to decide who they want to give interviews.

If they sense anything wrong, like someone who is over or under qualified or has no experience in the field, they're likely to simply toss it in the "no" pile.

It's your job to convince the employer that you would be great at the job with your application materials. This is particularly relevant if you're attempting to change careers or coming from a self-taught or bootcamp background.

That doesn't mean you can't apply for those jobs (plenty of self-taught developers have successfully changed careers!), but it does make it a little harder.

You need to clearly show to employers why you're qualified with an excellent cover letter and a resume which highlights projects you've done and transferable skills from previous jobs.

Proofread Everything

Read your cover letter. Then read it again.

If you struggle with grammar and spelling, or English isn't your first language, check out Grammarly. It's free and will help you identify changes you should make to your writing.

If you can, ask a friend who got great grades in English to help you out. If your cover letter or resume is difficult to read due to spelling and grammatical mistakes, the focus won't be on your achievements.

Plus, communication is a big part of any job no matter how technical, and your application is a place to showcase your communication skills.

Since you've had essentially unlimited time to write and review your resume, cover letter, and application, it's expected that they will be free from grammatical mistakes or spelling errors.

Send Your Cover Letter The Right Way

When sending your application to a company, your cover letter should be in the body of your application email. Don't send an empty email with two attachments to the hiring manager.

Also, use a professional email address! Something like firstname.lastname@emailprovider.com is fine.

University addresses are also fine, though after you have been out of university for a few years, it's probably a good idea to update it.

Something like fantasydude@yahoo.com is not.

Looking for more advice about how to write the perfect cover letter? Check out these resources:

• The Developer Cover Letter
• Joel on Software: Getting Your Resume Read
• Sorting Resumes
• You Need to Write a Better Cover Letter
• Sample Cover Letter
• Another Sample Cover Letter

There are millions of people seeking a job in Data Science, and the opportunities are limited. So, the important question is how can you stand apart from the pack?

The guide tries to capture everything you need to build a kickass portfolio — so good that they can’t ignore you!

Why Should You Build a Portfolio?

For someone who has received a Master's degree or a Ph.D. from a top tier college, getting a job might not be that difficult. The institute adds credibility to your profile which the employers look for.

For someone who doesn’t have a relevant degree or enough experience, that credibility needs to be established via a stellar portfolio showcasing your potential. The portfolio then works as evidence of your competencies.

There are numerous factors that can enhance your chances of getting noticed by an employer. With a smart strategy and consistent efforts, you’ll be able to crack it.

Let’s build a fool-proof plan right here to work towards landing a job!

Step 1 — Identify Yourself

Hopping from one career portal to another and applying for any job that mentions “Data” isn’t a smart move. It would add to your stress and workload only to learn that they have rejected you.

Narrow Down Your Search\

By Monica Rogati — https://medium.com/hackernoon/the-ai-hierarchy-of-needs-18f111fcc007

The Data Science spectrum in itself is huge. Most people lie in one of the strata of the pyramid shown in the diagram. Only a few can master two or three of the layers.

A data-driven organisation today employs for various positions, and here is a list with the difficulty level of the problems that these professionals solve:

• Data Analysts — Easy to Medium

• Data Engineers — Medium to Hard

• ML Engineers — Medium

• Research/Data Scientists — Hard

• AI Engineers/Deep Learning Practitioners — Very Hard

Obviously, no one individual can pull off all the tasks. The first thing that you got to do is identify the skillsets that you have mastered (or want to master). Based on that skillset, you should shortlist the job description that you'll aim for.

Step 2 — Studying the Job Description

If you spend enough time going through a bunch of job descriptions of various data profiles, you’ll notice that they ask for the experience even if it's for someone fresh out of a college.

The second thing that you should understand is that there are jobs that have more generalist requirements like data analysis. And then there are more focused and dedicated areas of research like a research scientist at a hedge fund, which is very math-heavy.

Here are a few screenshots that I’ve captured from a few big (Facebook, NetFlix) and mid-siz e(h20.ai) organizations look for in a candidate:

Studying them takes us back to the very important and commonly asked question:

How do I compensate for the experience factor if I am fresh out of school_?_

The answer is projects!

Wait! I already knew that…

Here is what you probably didn’t know – these projects can’t be your analysis over MNIST dataset or solving the Titanic dataset classification problem.

So, what kind of projects? Where do I get these projects? What am I required to do?

To answer that, let’s dive into building your portfolio.

Step 3 — Showing Expertise via Projects

Projects are your only substitute for experience.

Chris Albon, when asked about what people should have in their portfolio when they are seeking their first job in an interview with Datacamp, said:

...w_hen someone applies, some of the best things that they can apply with are projects that they’ve done or something like, say, a boot camp or maybe their dissertation research or something like that, where we can take a look and say, oh, cool, like you’ve done some interesting stuff, you’ve worked with some data, some interesting ways._

What should these projects reflect:

There are four major factors that your projects should validate, no matter which profile you apply for:

1. Your firm grip over required competencies

2. The complexity of the problem you have solved or studied — it can either be a novel problem or a commonly asked enterprise-grade problem.

3. Domain expertise — the amount of research you did in order to find the answers to the questions or building data infrastructure.

4. Your will to go that extra mile and make the project stand out — Deploying your project for public use or writing a blog or publishing a video to explain your findings.

Types of Projects to Add to your Portfolio

Keeping in mind the above-mentioned factors, here’s a list of project ideas that will require sincere efforts, but will add weight to your portfolio.

• Working with real data: If you can show someone that you can work with raw data coming from different sources and answer interesting questions about social laws, finance, healthcare, or any scientific experiment, that would be highly regarded.

• Exploring publicly available datasets:

Making use of publicly available datasets, explore the data for several insights, define questions that have never been asked before, dig into journals and research papers to look for related material, and then uncover hidden patterns using statistical models.

An in-depth analysis of a publicly available dataset is again a good place to start off.

• Exploit your curiosity: As a curious data professional, there must be products/services/questions that you find intriguing. Use this curiosity to dig into new problems. For example, a sports fanatic can go about building a dashboard or a data infrastructure that manages the statistics and performance patterns of all the players.

• Contributing to Open Source packages**:** Every organisation holds open-source contributions to machine learning or scientific computing packages in high regard. Developing for Free and Open-Source Software greatly enhances your chances to be recruited. You can try to contribute to packages like sklearn, numpy, and pandas. It shows that you can work with huge and complex codebases and that you know your stuff well.

• Building End-to-End projects: A great way of proving that you are truly a generalist is to build end-to-end projects (more like products). Don’t stop at finding the solution or creating a prototype for a recommendations system or a fintech chatbot. Go the extra mile, deploy it, share it with your peers to use it, collect some analytics. This shows how passionate you are about what you do and to what extent you can go to learn new technologies and methods.

• Skill-specific projects: There are people who are really good at cleaning data or creating insightful plots or automating data pipelines. You should consider developing your own Python packages that could automate those cleaning tasks or given a dataframe the package should create pair plots and all the other possibilities to expedite the EDA process.

List of some really cool portfolios for inspiration:

• https://nycdatascience.com/blog/student-works/improving-a-music-websites-user-experience/

• http://varianceexplained.org/r/trump-tweets/

• https://nycdatascience.com/blog/student-works/forecasting-cryptocurrencies-price-trends/

• https://nycdatascience.com/blog/student-works/web-scraping/covid19s-impact-on-preventable-cancer-risk-in-women-a-call-for-action/

Timeline for the Project

The amount of time you spend on a project gives clues about the complexity, niche, and the volume of work it requires. It should help you justify if the project is portfolio-worthy or not.

How much effort you put into your project to take it to the next level depends on a lot of different factors.

Just to give you something to quantify, if you have picked up a nascent technology to work with, you should spend at least a month building something concrete.

How to add these projects to your portfolio

Once you have a few good projects that you can include in your portfolio, the next step is to package your work in the best possible manner.

Apple is known for its packaging and design. Be sincere about how you package your work before you display it.

Here is how you can add more weight to your projects:

• GitHub URL: If you decide to add a link to your repo, make sure that repo just doesn’t contain a Jupyter notebook, it should have all the other files like requirements.txt, .gitignore, a license if required, and so on. That way you'll be hired as a complete package and not just as a Jupyter notebook expert.

• Blogs: Writing about what you’ve achieved is always a good practice, and for employers it builds the trust in your work and your ability to effectively communicate what you’ve done.

• Deployed applications: If you’ve deployed your ML-powered application, provide the link for the employer to play around with it.

• Dashboards: If you are proud of your analysis, you can go about creating a dashboard out of it. You may use Voila or Dash if you’re working in Python. If you’re a business analytics expert, you can add your Power BI, or Tableau dashboard to showcase your analytics skills.

Step 4 — Social Media Profiles

A good social media profile can help you land your next dream job. GitHub, LinkedIn, Twitter, Kaggle, StackOverflow, and Medium are the major platforms that people use to share their work/sentiments, network, consume information, and advertise.

Organizations and recruiters use these platforms to reach out to their next potential hire.

• GitHub: Having a good GitHub profile with a lot of contributions or stars on your repositories makes you a competitive programmer.

• Kaggle: Participating in Kaggle competitions, creating useful notebooks and datasets can also help you build a good data analyst profile.

An excerpt from Reshama Shaikh’s post To Kaggle or Not says:

It is true, doing one Kaggle competition does not qualify someone to be a data scientist. Neither does taking one class or attending one conference tutorial or analyzing one dataset or reading one book in data science. Working on competition(s) adds to your experience and augments your portfolio. It is a complement to your other projects, not the sole litmus test of one’s data science skillset.

• LinkedIn: I have personally used LinkedIn to land my first job, my first client, and many collaborators. It's a one-stop platform to connect with people who work at your dream companies, interact with them, find jobs, and follow interesting advancements. Do read this complete data science LinkedIn Profile guide to optimize your profile.
  Tip: You should be ready to offer something first before you ask for a favor.

• Twitter: All the big names in the data science space use Twitter quite frequently, and you get to interact with people in your field. You learn about what these people are working on and their sentiments on social issues.
  You can promote your blogs, videos, and other findings with your Twitter. People have got job offers, invitations to conferences, freelancing work, and influencer marketing contracts for their work and good followership on Twitter.

Top Data Scientists to follow on Twitter:

• Andreas Mueller — Sci-kit Learn Developer

• Yann LeCunn — Chief AI Scientist at Facebook

• Dean Abbott — Chief Data Scientist SmarterHQ

• Andrew Ng — Co-Founder of Coursera

There are many others, you can look at my profile and the people I follow on my Twitter profile.

Step 5 — Condensing a Portfolio Into a Single Page Resume

The most important element of your job application is your resume as it decides whether you’re going to be shortlisted for the job or not.

Considering you have every other element in good shape, it’s time to condense that information in an elegant and concise resume.

As you must know, the recruiters don’t spend more than a couple of minutes to skim through your resume, so you need to convey everything you’ve done within a single page.

The most important sections after your name and contact info:

1. Summary: In 1–2 sentences, convey what you have been doing and what you intend to do.

2. Skills: Don’t fill these up with all the random skills that come to mind. Don’t mark yourself on a scale. A single line with all the major competencies should be enough.

3. Projects: This should be the major section for new grads as you don’t have much in your experience section. Be concise about what you’ve achieved, add hyperlinks to your work. Enlist capstone projects, Kaggle competitions, independent research, and projects. This section will be called your portfolio.

4. Coursework: Add relevant coursework only. You can mention your GPA if applicable.

5. Experience (if you have any): Add relevant job history along with the bullet points that speak of the major tasks you accomplished at the organisation.

6. Social Media Links: Don’t forget to add links to your active social media profiles.

Here’s an example of a good resume that was reviewed during Kaggle CareerCon2018:

An example of a good resume presented at Kaggle CareerCon

Call to Action

You probably still have a lot of questions. Where should you look for project ideas? How do you get started? How do you prepare for interviews? And many more.

I have been working on creating projects for each profile based on my experience working as an Instructional Designer for Web and Data Science tracks.

Based on your response to this post, I will create a Discord channel for each profile where I’ll be sharing the projects and the instructions to complete them with the timeline associated with each.

I strongly believe in project-based pedagogy and thus I will be creating a lot of content where project development would be covered. I’d be sharing the resources you can use to learn (some of which I’ll create myself) and complete the projects successfully.

You can look at one of my examples here: COVID-19 Interactive Analysis Dashboard from Jupyter Notebooks.

Here’s the video version of this blog post on my channel Data Science with Harshit:

Data Science with Harshit

With this channel, I am planning to roll out a couple of series covering the entire data science space. Here is why you should be subscribing to the channel:

• These series would cover all the required/demanded quality tutorials on each of the topics and subtopics like Python fundamentals for Data Science.

• Explained Mathematics and derivations of why we do what we do in ML and Deep Learning.

• Podcasts with Data Scientists and Engineers at Google, Microsoft, Amazon, etc, and CEOs of big data-driven companies.

• Projects and instructions to implement the topics learned so far.

If this tutorial was helpful, you should check out my data science and machine learning courses on Wiplane Academy. They are comprehensive yet compact and helps you build a solid foundation of work to showcase.