Hire the Top 3% of Freelance Node.js Developers

The JavaScript language has been regularly changing since its invention in 1995. It has evolved from “vanilla” JavaScript into several different platforms, runtimes, libraries, and frameworks.

A decade ago, if someone said they were a JavaScript developer, most likely they would be considered a front-end developer. But in May 2009, Ryan Dahl introduced Node.js, a JavaScript runtime environment that can execute code outside of the browser. In its first five years, recruiters would ask: How can we hire Node.js developers?

Since then, Node.js has become a primary JavaScript tool in the world of back-end development. Now more than ever, given the substantial growth in the number of developers, a more relevant question for recruiters is, How can we find a great Node.js developer?

So let’s jump into the recruitment process and figure out the details.

Steps to Hire Node.js Developers for Web Development

Recruitment processes vary across companies and projects, but at a high level, we can outline some common parts.

More often than not, the developer hiring process consists of two generic parts: a soft skills review, usually carried out by a recruiter, and a tech skills review, done by a technical interviewer.

Soft Skills Review

This step’s goal is to get to know the candidate’s personality and check their communication skills, critical thinking, problem-solving abilities, and teamwork habits. It’s also a chance to gain insight into some other position-related traits. During this step, the interviewer would usually:

1. Check if the candidate’s and company’s values align: Whether they fit project requirements and goals, are a good team player, goal-oriented, etc. This is the most basic step, but a very important one in the soft skills review.
2. Ask the candidate’s salary expectations and describe the company’s advantages and benefits.
3. If a position requires leadership or some more advanced skills, the recruiter verifies them as well.

In some cases, companies will pre-filter candidates’ technical or domain knowledge with overly basic questions. This is to save going through a more detailed technical skills review in the case of candidates showing more obvious knowledge deficits, helping to streamline the hiring process.

Based on the soft skills review, the recruiter can sort out those candidates who don’t fit project requirements, so there isn’t a need to further validate technical skills.

Technical Skills Review

Having successfully passed the soft skills part, the candidate gets to demonstrate their professional web development knowledge and expertise. Such interviews are usually conducted by senior or higher-level engineers, like tech leads, solution architects, etc.

Depending on task complexity and project role, recruiters may be looking for different levels of expertise, from junior to senior Node.js developer or even team lead. It has always been challenging to distinguish between developer levels, as there aren’t any particular rules on how to do so; understandably, they vary across companies and teams. Moreover, most front-end engineers know basic things of Node.js because the language is the same, and you don’t need to have a lot of experience with Node.js to start with a simple HTTP server, implement a straightforward script, or use Node.js in some third-party libraries.

Nevertheless, some criteria on how to classify developers by levels have been formed over the years. We’ll focus on senior-level engineers and explore key aspects of hiring great Node.js developers in the next section.

Node.js Development: What an Experienced Node.js Developer Should Know

When a company is looking for a senior Node.js developer—whether part-time or full-time—it usually means that either the project has a complex structure, or they seek expertise to lay out a robust and scalable architecture for a new project—both scenarios require in-depth knowledge and experience in the field. Here are some points that can be considered a “must-have” for any such developer.

The Node.js Platform, In-depth

Beyond, for example, the typical Node.js web server, experienced Node.js developers should have in-depth knowledge of how Node.js works under the hood, its key concepts, and its advanced built-in tools.

First of all, developers should understand the Google V8 engine, the single-thread approach, and the event loop—primary things of the platform. Also, engineers should be aware that Node.js is not a framework—a common mistake—it’s a runtime that executes JavaScript code outside of the browser.

Second of all, mature Node.js developers should have experience with built-in modules. It’s not necessary to have comprehensive knowledge of all of them, but they need to be able to describe their intent, use cases, and when it is suitable to use various ones. Listed in the table below are the most commonly used modules.

Module	Description
HTTP/HTTPS	Allows transferring data through HTTP/HTTPS. Provides a lot of different features of the protocol that are commonly used to start a Node.js app as an HTTP server.
Path	Provides a lot of convenient and useful functionality that helps to interact with file systems. Helpful when manipulation of directories/files is required.
Events	Node.js is event-driven, and the Events module provides a way to work with events. It can be used to handle asynchronous operations using the emit and subscribe approach.
Streams	Helps to work with streaming data in Node.js. A useful and efficient way to handle read/write operations, network communication, and other information exchange.
Child Processes	Allows creating child processes in Node.js. It's helpful when tasks need to be executed in separate threads or to be able to take advantage of a multi-core system with Node.js.

There are quite a lot of built-in tools and APIs which developers use during their work, and having experience with using many of them lays a good foundation for a developer to be able to pick the right tool for a job.

And last but not least, developers should always keep an eye on Node.js releases as there can be crucial changes, deprecations, and updates that can affect their applications. Also, there may be new tools or APIs in new Node.js versions, so it’s good when developers keep their Node.js versions up to date on their projects.

A good sign is if developers keep long-term support (LTS) versions during their work, especially if they run applications in production, and understand how the releases workflow of Node.js itself looks. Every major Node.js version has three statuses: current, active, and maintenance.

The current release status continues for six months. After that, the odd-numbered version support is dropped, and the even-numbered version enters the active LTS period for the next 18 months. When the LTS period is over, the even-numbered version enters the maintenance period for another 12 months.

Therefore, developers can be sure they’ll get stable support for 30 months after the introduction of an even-numbered Node.js version.

Understanding Node.js release cadence greatly helps developers in making decisions about which version of Node.js to use and when it is the proper time to update. This, in turn, affects the security and maintainability of Node.js applications.

Databases

Nowadays, it’s quite rare to find a server-side development—especially with a Node.js server—that doesn’t involve storing data in a database. It can be mere key-value storage like Redis, a realtime database like Firebase, or a more robust and powerful database system: perhaps the document-oriented MongoDB, or a member of the SQL family like Microsoft SQL Server, PostgreSQL, or MySQL.

Even junior Node.js developers will have used databases during their work, but mature Node.js engineers should have experience with a couple of them and should be able to distinguish between different types of databases.

Moreover, senior engineers should be:

1. Familiar with various families of the database, understanding the differences between relational and non-relational databases. They should be able to decide which one suits a project’s purposes best.
2. Capable of setting up a database structure and relations between documents or tables.
3. Able to use the advanced features of a database management system (DBMS). In the SQL family, this would be views, stored procedures, etc.; in document-oriented ones like MongoDB, advanced features include aggregate functions and data destructuring.
4. Able to use object-relational mapping (ORM) tools from npm, like Mongoose (for MongoDB), Typeorm or Sequelize (for SQL related databases) in the proper cases.

Third-party Modules

As with any other platform/language, there are various libraries, tools, helpers, and frameworks that developers can use in Node.js projects. The npm registry provides tons of open-source dependencies that can help during app development. Experienced Node.js developers should be able to use them in the appropriate cases.

At the same time, they need to use them rationally and safely. So before adding a new NPM package to their dependencies, the developer should verify whether there are native JavaScript or Node.js features they can use for the same purpose. If a package is required, the developer should ascertain if it’s safe to use by checking its vulnerabilities.

DevOps

Senior Node.js programmers should be able to work with development operations as it’s a must-have for every project. Even if you have a DevOps specialist, dedicated Node.js developers will be able to work closely with them and fill in for them should the need arise. Developers must know how to configure several environments like development, staging, and production, as well as CI/CD pipelines, to be able to deliver new features or bug fixes continuously.

Also, they need to know about monolithic systems, containers, serverless solutions, and understand differences between them, so they can choose the proper approaches for a particular project.

A big plus is experience with cloud solutions like Amazon Web Services, Google Cloud Platform, Microsoft Azure, and others. A Node.js developer is especially valuable if they can start a project from scratch and end up with a reliable and scalable application in the cloud.

---

These are the major must-haves—every seasoned Node.js developer should be comfortably experienced with them. Let’s go one level deeper and walk through interview questions for senior Node.js engineers.

Interview Questions

Interview questions for Node.js engineers fall into three categories:

1. General questions: Here, the interviewer should verify common tech knowledge for senior engineers.
2. JavaScript questions: Node.js is a JavaScript runtime environment, so developers should have a deep understanding of the JavaScript programming language itself. We maintain a community-driven list of interview questions that can be used here.
3. Node.js questions: Subjects related to the platform itself.

We’ll focus here on platform-related questions for senior developers that can help determine whether a candidate is a great Node.js engineer.

Q: What are three ways to handle asynchronous operations in Node.js? Describe their pros and cons.

There are three primary, built-in approaches for handling async operations: callbacks, promises, and async/await.

Callbacks are the oldest method. It’s best to avoid them, as they have a couple of anti-patterns, like callback hell (also known as the “Pyramid of Doom”). However, they are quite widely used in old projects and libraries.

Promises are a native feature of ECMAScript 6 (ES6, sometimes called ES2015)—supported fully since Node.js 6.17, and partially as far back as Node.js 0.12. They have additional methods that make them more powerful and flexible than callbacks.

Async/await is the newest native approach to deal with asynchronous operations. It’s the best one from a code structure perspective but doesn’t have such a wide range of built-in features as promises do.

Developers should definitely understand and use promises and async/await. It’s even better if they’re experienced with other tools for handling async operations, like bluebird and observables; if they’re being hired for an existing project that uses these extensively, this may be more of a requirement than a nice-to-have.

Red flag: The developer still defaults to callbacks and doesn’t know (or care) about promises and async/await.

Q: How should Node.js developers handle errors in asynchronous functions?

As a follow-up to the answers of the previous question, each approach to asynchronous code has its own way of handling errors.

To handle errors using callbacks, there is the quite well-known error-first convention:

fetchUsers(url, (err, data) => {

  if (err) {

    // handle error 

  } else {

    // operate upon data

  }

});

The idea is that an error is always passed as the first argument of a callback function so it can be handled in a consistent way.

In contrast, promises have a special catch handler to process errors:

fetchUsers(url)

  .then(data => {

    // operate upon data

  })

  .catch(err => {

    // handle error 

  });

To handle errors when using async/await, developers can use a simple try-catch block:

async main() {

  try {

    const data = await fetchUsers(url);

    // operate upon data

  } catch (err) {

    // handle error 

  }

}

Node.js developer candidates should be able to describe the examples above.

Red flags: The developer has little or no experience with handling errors from callbacks, promises, and async/await. (That said, since callbacks aren’t recommended anyway, knowledge of callback error handling would be less important for a greenfield project.)

Q: What are some Node.js frameworks for building web applications? Describe their pros and cons.

Frameworks are almost always a necessity with Node.js. It is quite unlikely for engineers to use pure Node.js built-ins to build web servers, as there are widespread and robust solutions for that, and it simply doesn’t make sense to reinvent the wheel.

Express.js is one of the most popular Node.js frameworks for web applications. Its long-term support is quite good, and it has a lot of commonly needed routing and middleware features, extending Node.js functionality to make it more flexible and powerful.

Nest.js is essentially an upgrade to Express.js that uses TypeScript, a modern language that’s a strict syntactical superset of JavaScript. It provides developers with the ability to write better, more structured, and less error-prone code.

Hapi.js, Koa.js, Meteor, and Sails.js are other web application frameworks for Node.js a candidate might mention.

In the table below, some pros and cons of each of them are listed.

Framework	Advantages	Disadvantages
Express.js	Simple, flexible, scalable Wide functionality Easy to learn Easy to customize Used by a broad audience Well-documented Performant	Does not use TypeScript Difficult to maintain
Nest.js	Uses TypeScript Built on top of Express.js Has a well-structured architecture, similar to the Angular framework Used by a broad audience Has built-in modules for popular technologies like GraphQL, microservices, and WebSockets	Relatively new, so some functionality from Express.js is not in place
Hapi.js	Plugin system, allowing for easier maintenance Profound control of request handling	Does not use TypeScript Small audience Performance is lacking
Koa.js	Good user experience Lightweight Clean and readable async code	Does not use TypeScript Small audience No built-in middleware

Red flag: A Node.js developer with weak or absent knowledge of web application frameworks. A definite exception here would be if they have strong knowledge in one particular framework—particularly Express.js, since it’s practically a de-facto standard and even the foundation of some of the other frameworks.

Q: What are the two main ways to scale an application? Is there anything specifically to Node.js in how you would approach them?

This question helps determine whether a developer has experience with building large applications. Node.js apps can be scaled horizontally and vertically.

Horizontal: Node.js can be cloned and distributed across multiple servers, or across CPU nodes within one server. There are solutions in a place like PM2 that help to distribute load across nodes within a server, or AWS Load Balancer to help with multi-server scaling.

Vertical: This means CPU and memory can be increased on the same node/server—nothing Node.js-specific.

Red flag: The developer doesn’t have knowledge of, or experience in, scaling.

Q: How do developers test a Node.js application?

There are three main types of testing: unit, integration, and end-to-end.

• Unit testing means testing individual units/components of an application. It’s the lowest level of testing, the purpose of which is to verify if small pieces of code work properly in isolation.
• Integration testing is the next level of testing, which intends to make sure that separate modules work together accurately.
• End-to-end testing is the highest level of the testing hierarchy, which verifies that both client and server work properly together.

Quite often, developers need to use stubs and spies to mock third-party modules or API calls. They are crucial during testing as they prevent accessing real data, and simplify testing itself.

There are different packages for Node.js that help with testing, including Mocha, Chai, and Jest. Developers should be familiar with at least one—preferably with the one (hopefully) already in use, in the case of an existing project.

At the very least, a candidate should understand the difference between testing types.

Red flag: The developer has no experience with unit, integration, or end-to-end testing.

Q: How can Node.js developers make sure that project dependencies are secure?

A Node.js app may become insecure because of the npm packages in use. There are a few rules developers should follow to keep an application safe:

1. Check packages themselves. It’s worth validating the package’s author, its GitHub stars, opened/closed issues comparison, weekly downloads, number of releases, etc.
2. Use the npm audit command. It allows getting a list of packages’ known vulnerabilities. Running npm audit fix would automatically install compatible updates to vulnerable dependencies. It also executes by default during npm install.
3. Use npm outdated to verify if any installed packages are obsolete.

Dedicated Node.js developers will take care of vulnerabilities by staying on top of such issues continuously as part of the development process.

Red flag: The developer blanketly ignores or doesn’t care about vulnerability warning messages.

Q: What are global objects in Node.js? Describe them.

Node.js has two types of global objects: global and pseudo-global.

Global objects are those which are available in the global scope. There are also built-in objects that are accessible in the global scope as well—those that are part of the JavaScript language itself.

The most-used global objects are:

1. console, a Node.js module used to print to stdout and stderr
2. global, a global namespace object. In browsers, the top-level scope is the global scope, but Node.js is different. A method/variable should be put in the global object to be accessible in every module.
3. process, a Node.js module allowing interaction with Node.js’ running process
4. Built-in functions, like setTimeout(), setImmediate(), and setInterval()

By contrast, pseudo-global objects exist in the module scope. Pseudo-globals include:

1. __dirname, the directory name of the current module
2. __filename, the file name of the current module
3. module, exports, and module.exports, which are part of Node.js module system
4. require(), a built-in function which allows the import of other modules

Red flag: The developer has no experience with, or does not understand the differences between, types of globals.

How to Hire Node.js Developers Most Effectively

The process of hiring a great Node.js developer is more than just interviewing with platform-related questions. It implies validating both technical and soft skills.

Out of all of the important topics that the soft skills review covers, a fundamental first step before searching is asking oneself, “Why am I looking for a skilled Node.js developer in the first place?” Be it igniting the existing development team with extra developer power, or mentoring peers and leading a technical transformation and excellence process, or kick-starting an MVP—answering this question greatly helps to define the values, traits, and experience of the ideal candidate.

Notwithstanding the goals of the soft skills review, the technical part comes into play at all times. Node.js development is an expertise that has some standard sets of tooling, patterns, and integral parts that are used over and over. The more experience a Node.js developer has using them for solving various problems and combining them in different ways, the more valuable such a developer becomes for development teams.

There’s definite value in the simple process of going through the fundamental topics of modern Node.js development flow, such as databases, third-party tools, DevOps, and the Node.js platform itself. Hearing answers to some pivotal development-, JavaScript-, and Node.js-specific questions can shed light on whether the developer is indeed as experienced and skilled as will be required for the goals that will be put before them.