Learn How to Code
  • Welcome
  • Foundations
    • Introduction
      • Becoming a web developer
      • Motivation and mindset
      • Join a supportive community
      • How does the web work?
    • Requirements
      • Prerequisites
      • Text editors
      • Command line basics
      • Setting up Git
      • Setting up Node
    • Git
      • Git basics
      • Project: Practicing Git
    • Frontend
      • HTML and CSS
      • Developer Tools
      • Project: Create a web page
    • JavaScript
      • Strings and Conditionals
      • Using Developer Tools
      • Functions
      • Problem solving
      • Project: Rock paper scissors
      • Writing clean code
      • Arrays and Loops
      • The DOM
      • Project: Etch-A-Sketch
      • Objects and More Arrays
      • Project: Calculator
    • Backend
      • Frameworks
    • Next steps
  • Deep dives
    • Computer Science
      • Pseudocode and algorithms
      • Recursion and algorithms
        • Project: Fibs and sorting
        • More on algorithms
        • Big O
        • Project: Practicing Big O
      • Data structures
        • Maps, Stacks and Queues
        • Project: Stacks and Queues
        • Nodes, Linked Lists and Trees
        • Project: Linked Lists
        • Project: Trees
        • Next steps
    • Databases
      • Databases and SQL
      • Project: SQL Zoo
    • Design / UX
      • Fonts and typography
      • Grids
      • Project: Teardown
      • Responsive design
      • Project: Mobile friendly
      • CSS frameworks
      • Project: Bootstrapping
    • HTML / CSS
      • HTML Basics
        • Linking
        • Images and media
        • Project: Embedding media
        • HTML5
        • Tables
        • Lists
        • Forms
        • Project: Make a form
      • CSS Basics
        • Box model
        • Floats and positioning
        • Flexbox
        • Grids
        • Project: Breaking news
        • Best practices
        • Backgrounds and gradients
        • Project: One more thing
        • CSS3
        • Preprocessors
        • Project: Your own framework
      • Next steps
    • JavaScript
      • Refresher
      • Organization
      • Objects and constructors
      • Project: Library
      • Factory functions and module patterns
      • Project: Tic Tac Toe
      • Classes
      • ES6 Modules
      • Project: Restaurant
      • Object Oriented Programming
      • Project: Todo list
      • Linting
      • Menus and sliders
      • Forms
      • ES6 features
      • JSON
      • Callbacks and promises
      • Using APIs
      • Async and Await
      • Project: Weather
      • Testing
      • Project: Testing 1-2-3
      • Advanced Testing
      • Project: Battleship
      • Backends
      • Project: Where's Waldo?
      • Project: All-Star
      • Next steps
    • NodeJS
      • Project: Going to school
      • Project: Passing the test
      • Express
        • Templates and middleware
        • CRUD and MVC
        • Project: Message board
        • Routes
        • Displaying data
        • Forms and deployment
        • Project: Inventory
      • Authentication
      • Security
      • Project: Clubhouse
      • APIs
      • Securing an API
      • Project: Blog
      • Testing
      • Testing with a database
      • Project: Social network
    • React
      • Props and State
      • Render lists and handle inputs
      • Project: CV
      • Lifecycle methods
      • Hooks
      • Project: Memory card
      • Router
      • Project: Shopping cart
      • Advanced concepts
    • Ruby
      • Installation
      • Data types
      • Variables
      • Input and Output
      • Conditionals
      • Loops
      • Arrays
      • Hashes
      • Methods
      • Enumerables
      • More enumerables
      • Nested collections
      • Blocks
      • Pattern matching
      • Debugging
      • Project: Caesar cipher
      • Project: Substrings
      • Project: Stock picker
      • Project: Bubble sort
      • Object oriented programming
      • Project: Tic Tac Toe
      • Project: Mastermind
      • Serialization
      • Project: Event manager
      • Project: Hangman
      • Computer Science
        • Recursion
        • Project: Merge Sort
        • Data structures and algorithms
        • Project: Linked Lists
        • Project: Binary Search Trees
        • Project: Knight Travails
      • Testing
      • RSpec
      • Project: Four in a row
      • Git
      • Project: Open Source
      • Project: Chess
      • Next steps
    • Ruby on Rails
      • Using Heroku
      • Installing Rails
      • Basics
        • Routing
        • Controllers
        • Views
        • Asset pipeline
        • Deployment
        • Project: Blog
      • Active Record
        • Project: Upvote
      • Forms
        • Cookies, sessions, and authentication
        • Project: Password
      • Advanced forms and Active Record
        • Associations
        • Project: Private Events
        • Callbacks
        • Menus, helpers and nested forms
        • Project: Ticket agent
      • APIs
        • External APIs
        • Project: Animals
        • Project: Photo widget
      • Mailers
        • Project: Confirmation
      • Advanced topics
        • Action Cable
      • Project: Social network
      • Next steps
  • Getting hired
    • Preparing to find a job
      • Plan a strategy
      • What companies want
      • Get yourself together
      • How to prepare
      • Project: Make your website
    • Applying and interviewing
      • Qualifying leads
      • Project: Make your resume
      • Applying for jobs
      • Preparing for an interview
      • Handling an offer
      • Final words
  • Maintained by
    • wbnns
  • License
    • CC BY-NC-SA 4.0 © 2022
Powered by GitBook
On this page
  • A structured approach
  • Get good
  • Craft a narrative
  • Build a portfolio
  • Clean up your web presence (and have one)
  • Get out in the community and collect information
  1. Getting hired
  2. Preparing to find a job

How to prepare

You may be uncomfortable "selling yourself" but that's exactly what you'll have to do.

PreviousGet yourself togetherNextProject: Make your website

Last updated 4 years ago

A structured approach

Taking a structured approach to getting hired means starting early and getting some important things out of the way first.

Get good

Navigating this process can be a beast but don't let it distract you from building your skills, which ultimately will determine if you get the job or not. This course assumes you've already made it through the other courses and have accomplished enough in their completion to elevate you to competence. If not, you've got to ruthlessly address your weak points (even if it's the tricky stuff like algorithms and data structures) in order to be qualified for the kinds of positions you're applying to.

Craft a narrative

You may be uncomfortable "selling yourself" but that's exactly what you'll have to do. Luckily, that doesn't mean acting like a used car salesman; it's more subtle than you think. It really means crafting a story about who you are, how you got to where you are, and why you'll keep growing. Everyone can tell a story. So put some effort into crafting a compelling narrative that stitches together your background (especially if you come from a non-traditional background) into a compelling and unavoidable wave of capability and drive.

Build a portfolio

All along the way, you should keep building things. The work you've done will be crucial to demonstrating your technical skill and getting hired. Employers want to see that you can build and ship code and that you make good decisions when confronted with engineering trade-offs. All of this stems from conversations about your portfolio of work.

The portfolio is also important for another thing that isn't mentioned much -- social proof. If you've been a part of larger or group projects, that's almost like showing that you've worked somewhere before. It makes the employer comfortable that other people have worked with you before so they can too.

Your portfolio as a developer is GitHub. You may have a personal website but GitHub is still the authoritative repository of your technical ability. Ignore it at your peril.

Clean up your web presence (and have one)

Google yourself in an incognito window (to avoid Google's smart algorithm). What comes up? Do the links fit into your personal narrative? Whoever is looking to hire you will certainly Google you. Make sure that what they find matches what you want them to find. If you've got a ridiculously common name, you may have a harder time building your web presence but it's also harder to have the wrong web presence.

The most important part of your web presence to fix up is your GitHub profile. Make sure your projects are organized and their README files contain a description and a link to where it is live so anyone looking at the project can quickly see your brilliance.

Next, try to be discoverable. If I'm trying to get in touch with you or find your work on the web, can I? Do you have a personal website? Are you on Twitter? You don't need to go crazy with social media, but sometimes just having enough of a profile to be a "real" person and give people the opportunity to get in touch with you can go a long way.

Use LinkedIn if you're not allergic to it. Again, this is about getting your personal narrative out there in the way YOU choose and not relying on Google to get it right. LinkedIn is fast replacing the resume anyway.

Other sites, like Brand Yourself below, will describe a bit better how to take on your web presence, but just make sure your narrative is being told the way you want it to.

Get out in the community and collect information

Find and meet other developers. That doesn't mean "power networking" but it does mean genuine human connection. Your network of people DOES matter in a BIG way. For now, it's probably just for answering questions and harvesting advice but your next job will probably be found through the people you know and some who you meet while you're gathering this advice. People like giving advice and like investing themselves emotionally in other people with growth curves.

That's best to do in person 1-on-1, where you can ask your dumb questions, but there are plenty of communities as well, e.g. Meetups, Stack Overflow, Quora, local user groups... Be a part of them and don't be afraid to ask questions. That's a great way to build relationships.

You'll probably have a million questions but the relevant ones here are about understanding what exactly different jobs are and what they're looking for. The easiest way to find out is ask developers what they do. It's much faster than trolling through blog posts trying to figure out the process. Buy lunches and coffees if you must. Set a goal of talking to 5 real human beings about your job search.

Another way to get this information is to check out a whole bunch of job postings. You'll quickly start seeing similarities between them. Yeah, it's shit work, but it must be done.

Another facet of this is related to your web presence -- don't be afraid to produce content like blogging or answering questions on Quora. They don't need to be explicitly technical, but should showcase your ability to think critically and write well. Both of these play well with future employers.

is an essential classic that relates to business and networking but is applicable to all facets of the social world around you. It's a must-read for everyone (and it's an easy read).

How to Explain Your Career Transition by Dorie Clark
A Programmer's Portfolio by Jeff Atwood
The Power of a Programming Portfolio by GrokCode
Your GitHub Portfolio by Forbes
Brand Yourself helps you... brand... yourself. Basic services are free.
Control Your Online Reputation from Monster
How Important Is It for a Programmer to Have an Online Presence? on Stack Exchange
How to Build Your Digital Presence as a Software Developer
How to Win Friends and Influence People