How to screen Node.js developer skills

February 17, 2021
Node.js developer skills

In the current tech climate, Node.js is one of the most popular backend technologies used by developers. It is crucial that you verify the Node.js developer skills of your candidate in order to make a high quality hire.

There are many reasons why Node.js is popular among those in the industry. Sometimes referred to as just ‘Node’, this runtime environment promotes speedy and scalable software development. It also uses JavaScript, the lingua franca of the World Wide Web to power its broad features. It’s no surprise why so many companies are doing their best to scout for top-tier Node.js developer skills.

Reports from Indeed indicate that the number of job searches for Node.js rose by 57% from the previous year, demonstrating it’s growing demand. This special piece of tech is used by a whole host of tech-giants and multinational companies alike including Netflix, Uber, LinkedIn, NASA, PayPal, Microsoft and Walmart.

In today’s article, DevSkiller will cover the ins-and-outs of Node.js, the most important things an IT recruiter should be aware of and our best strategies to hire a quality Node.js developer.

1. What is Node.js?

Technically speaking, Node.js is an open-source, cross-platform, JavaScript runtime environment that executes JavaScript code outside a web browser.

Breaking it down a little bit, Node.js allows developers to use JavaScript to write commands for server-side scripting (back-end scripting). Essentially, this means Node.js helps run scripts server-side to produce dynamic web page content before the page is sent to the user’s web browser.

The first stable version of Node.js (0.10.0, the first one used in business) was released in 2013, though the project began a few years earlier. Ryan Dahl’s goal, the creator of Node.js, was to create real-time websites with push capability, “inspired by applications like Gmail”. In Node.js, he gave developers a tool for working in the non-blocking, event-driven I/O paradigm.

1.1. What is Node.js used for and what problems does it solve?

As most client side applications including web pages and web applications use code written in JavaScript, the advantage of also writing server-side script in Javascript is enormous. And that’s where Node.js comes into play.

Node.js is popular primarily because of the fact that it represents a “JavaScript everywhere” paradigm, unifying web-application development around a single programming language, rather than different languages for server and client-side scripts.

This unification across the stack which incorporates the language and data format (JSON), allows businesses to optimally reuse developer resources.

Using Node.js allows a full-stack developer to transition with ease; and as a result, is in direct competition with other popular scripting languages and frameworks such as Java, .NET, Python, PHP, Ruby, and C#.

The platform facilitates web applications with two-way connections, so both the client and server can commence communication, allowing them to exchange data freely. This advantage is in clear contrast to the typical web request/response paradigm, whereby the client always initiates communication.

Node.js is a platform that fills a particular need. It’s very light-weight which means scalable and high-performing systems can be written with not a lot of code. Node.js, however, isn’t ideal for CPU-intensive operations because of its single-threaded implementation.

Where Node stands out from the pack is in building fast, scalable network applications, as it’s capable of handling a huge number of simultaneous connections with high throughput, which equates to high scalability.

1.2. Is it similar to any other languages or frameworks?

Node.js will always be very closely linked to the JavaScript language due to it being its server-side runtime platform.  As Node.js implements the ECMAScript specification, a global JavaScript standard meant to ensure the interoperability of web pages across different web browsers; we can informally say that Node.js is effectively Javascript.

In some ways, we can say Node is similar to PHP, Python, and Ruby (being a dynamically-typed scripting language), though it’s way more advanced in terms of functional programming capabilities.

There are several other products on the market that work as fine alternatives to Node.js. These include Elixir, Perl, ASP.NET, Ceylon, and Rebol.

1.3. What are its main advantages or features?

2. What is important for an IT Recruiter to know about Node.js?

What’s important to look for when hiring developers with Node.js experience? Besides the usual architecture design, logic, collaborative, and communication skills you’d require when hiring any developer, there are some things that are unique to Node developers.

2.1. How often does the tech stack change?

As Node.js runs on Javascript you will often hear people say that, “there is a new JavaScript framework each week”, but that primarily relates to the front-end architecture. The back-end is generally a lot more stable. Of course, new tools are added all the time; however, pertaining to the most popular add-ons used in Node.JS — including Express, Meteor, Hapi, NestJS, koa etc – it’s more of an evolution than revolution.

What’s more, the JavaScript language itself has been improving steadily since 2015, when ES6 (also known as ES2015) was released. The reason is because prior to 2015, each JS version was introduced extremely periodically (such as every 3-5 years) but since 2015, a new version is released each year. Overall, the tech stack has undergone quite a smooth evolution.

2.2. Are there many resources/tools/technologies available?

What’s really great about Node.js is the thousands of modules available for any purpose, as well as the vibrant community behind the platform. Scores of blogs, tutorials, videos, conferences and books exist on the topic designed to make developers’ lives easier.

Tools like Webpack, a handy JavaScript module bundler used to simplify front-end development really help simplify Node.js. Or Mocha.js, which enables Node developers to test both in-console and in the browser.

More information on tools and resources for Node can be found on sites such as Smashing and Brainhub.

2.3. What tools and techniques should a Node.js developer be familiar with?

There are two things that should be distinguished here: the knowledge of Node.js itself and the general back-end programming-related issues. Node.js, being the server-side JavaScript comprises of:

  • The scripting language, and
  • Built-in Node.js modules, which manage file systems, processes, events, HTTP, etc

This breadth of knowledge is not a big barrier for front-end developers, who wish to migrate from browser work to the server.

However, there are also back-end related concepts, which are more or less the same for all backend technologies, including Java, .Net, PHP, Python, Ruby, Golang, and, of course, Node.js. Such topics include:

  • Databases, persistence
  • Session management
  • Architecture: monoliths, microservices
  • Scaling (RAM/CPU resources consumption)
  • Cloud and infrastructure
  • and many, many more, often depending on the specificity of the project.

All-in-all, these are the concepts which node.js developers should be familiar with.

The specifics of Node.js developer skills is clearly non-negotiable. But without back-end knowledge, developers could write systems that aren’t resilient, unscalable, or not fault tolerant (which could result in systems that work well for ~50 users but break for ~5000 or ~50000 users).

2.4. What type of experience is important to look for in a Node.js developer?

Without a doubt, commercial experience with Node.js is the most important factor to consider here. Working on business-related projects and delivering stable software are the benchmarks for the platform. Scientific and academic experience for React is almost irrelevant.

Open source experience should also be discerned as an additional benefit since Node.js is one of the most open-source friendly platforms that exist.

3. How to verify Node.js developer skills in the screening phase?

If you’re hiring for Node.js developer skills, there’s more than one way to skin a cat, or so to speak. Adam Polak, The Software House’s Head of Node.js, contends that transitioning from a different technology can ostensibly be a viable option.

“Node.js is a relatively new technology, so there are not many experienced devs who use it. That’s why we should not limit ourselves just to current Node.js users, but also take a look at skilled devs who can transition quickly. PHP, Java, and .NET developers are often willing to learn new technologies.”

3.1. What to take into account when screening a resume?

  • Developers should be familiar with back-end programming issues, patterns, problems, and solutions.
  • Experience in developing and shipping Node.js-based applications.
  • Database design and performance analysis.
  • QA-related skills (i.e, designing testing scenarios, and implementing those tests).
  • Experience with cloud infrastructure, e.g. how to enable deploys to AWS/Azure/GCP cloud infrastructure.
  • Anything that doesn’t prove the knowledge about the tech stack, but provides business value, such as: application maintenance, bug fixing, performance tuning, etc.
  • A balance of knowledge between syntax (how to write code) and back-end related issues (what to write).
  • Developers that demonstrate an understanding of platform specificity (what problems can arise, and the right ways to solve them).
  • Don’t expect that candidates will know your tech stack back to front. Assume that if a developer has proven success in one stack, they can perform to a high standard in another tech stack.

3.2. What glossary terms are important to know in Node.js (including frameworks, libraries and language versions)?

AbriviationsNode = Node.js JS = JavaScript. ES = ECMAScript (ECMAScript is the name of the standard, JavaScript is its implementation – formally. But in practice, people call it JavaScript when they should call it ECMAScript (the spec), however, the majority of developers don’t care.)
JavaScript / ECMAScriptAsynchronous programming: events, promises, async/await, rxjs Object-Oriented Programming: JS data structures, prototypal inheritance, ES6 classes Functional Programming: higher-order functions, closures Cross-cutting mechanisms: coercion (typecasting)
WebServicesHTTP protocol, WebSocket protocol HTTP: Fetch, Axios, Request, WebSockets: Socket.IO
Node.js toolingFrameworks: Express, Koa, Nest.js, Fastify Transpilers: Babel, TypeScript, Flow Bundlers: Webpack, Parcel, Snowpack Popular packages: NVM, Chokidar
TestingTypes: unit tests, functional tests, integration tests, E2E tests Tools (frameworks & libraries): Karma, Jasmine, Selenium, Jest, Mocha, Sinon, Chai (and many others) Misc: pyramid of tests (way more unit tests than e2e), snapshot testing, regression testing, mocking
DatabasesSQL, MySQL, MSSQL NoSQL: MongoDB, CouchDB, and many others ORMs (object-relational mappers)
DesignMonoliths, microservices, CQRS Design Patterns: facade, factory, builder, composite, mediator, state machine, state, chain of responsibility… and many, many more Concerns: scalability, monitoring, logging, deployments, continuous integration/deployment, cloud infrastructure

3.3. Which versions are completely different? Which versions are similar to each other?

ES6 is ECMAScript v6 (released in 2015), it was a major breakthrough that people relate to, meaning the new JavaScript (before that people consider the old JS).

Node.js versions are shipped mainly with better support for recent ECMAScript (JavaScript) versions, they are improved incrementally, but not revolutionary.

4. Technical screening of Node.js developer skills during a phone/video interview

4.1. Questions that you should ask about a Node.js developer’s experience. Why should you ask each of those questions?

  • Have you been involved in automatic testing your previous applications? What do you think you’ve done well and what would you change today?
    • Testing is an essential element of software development. Developers are given the tools to innovate and it’s up to them whether they use them efficiently. In regards to testing, it’s important that:
      • Tests are small and run quickly. Developers are less eager to continuously run tests which takes a lot of time.
      • Each test should explicitly check one variable (unless it’s E2E which tests, as the name suggests, is end-to-end). If a feature is broken, it’s better to have one test failing instead of hundreds of tests failing.
      • Tests should not cover elements that are checked by other tools, etc. Data structures can be validated by JSON schema validators, type checkers (TypeScript, Flow, …) etc.
      • Proper coverage by way of testing should give developers trust in the code they create (i.e, if the tests pass, the code is working properly). A developer who hasn’t maintained tests might not feel the need to create them and not realize how appropriate testing helps in the long run.
  • Have you been working with microservices and/or distributed systems?
    • If your company’s products handle a massive scale (of users, requests, etc.) and require high availability, then often this leads to distributed systems, where only a piece of the system is being scaled. All-in-all, a distributed system has its own patterns and anti-patterns which take a long time to learn. If you need to ship your app to the cloud (AWS/Azure/GCP, …) then a Node.js developer with distributed systems would be extremely valuable.
  • Have you been working on real-time applications? If so, what business processes did the system implement? What was the difficulty in the system, technology-wise?
    • One of the most important concerns to deal with in big-business systems is real-time data. Implementing apps where data changes every second bring with it its own quirks, problems, common mistakes, solutions, patterns, and architecture etc. If your system handles data that changes frequently (e.g. postal service tracking, or processing financial data, which, due to the nature of finances, is also extremely dynamic) you should definitely ask this question to see whether the candidate understands the context.

4.2. Questions that you should ask about a Node.js developer’s knowledge and opinions. Why should you ask each of those questions?

  • What are Node.js streams, what does it mean to stream data – and why is that important?
    • Streaming data is a certain way to exchange the data between the server and the client. In most systems, a complete request is sent; and a corresponding, a complete response is received, but that’s not the case with streams. In streams, the answer is returned in multiple chunks (streamed in real-time, piece by piece). It’s extremely important because it affects low-level system performance. Often, a client can start to process chunks (pieces) of the response without having the whole response. This is more difficult, but it reduces the time of unnecessary waiting. An experienced node.js developer should be experienced with using node streams.
  • Why should package-lock.json be committed to the repository and what does it contain?
    • Pretty much every developer knows that a package.json file, the main file of a node project, should be committed and tracked by a versioning system (e.g. git). But not everybody knows about package-lock.json and it’s placed in npm. While package.json explicitly lists all dependencies which we directly use, package-lock.json includes the entire tree of dependencies. Versions of all packages are explicitly listed and, when the application is built on a build machine, those exact versions would be taken into account. Why? Because if we get an error on a build machine, we need to know the exact versions in order to reproduce the error on local machines. Thanks to committing package-lock.json to the repo, it’s easy.
  • There’s a common saying in programming, that “there are 2 difficult things in programming: 1. Naming things, and 2. Cache invalidation”. Please explain what is cache invalidation and why it is considered difficult.
    • Caching is remembering calculations for later so that whenever the same question is asked again, we already have the right answer. Cache invalidation is when we know that the basis for the calculation has changed and so the remembered result is wrong. Since it relates to the old basis, we know that this piece of cached information should be cleared (invalidated). In big systems, where the price of an order can depend on multiple factors, some of them change and some don’t. It’s difficult not to miss a certain path (a change should be followed by a cache invalidation) or not to do it over eagerly. In most of the systems, cache invalidation has to be programmed explicitly.

4.3. Behavioral questions that you should ask a Node.js developer. Why should you ask each of those questions?

  • Imagine you join a developer team which maintains a stable product, but is rather poorly written. Delivering new functions and improving business value takes more time than expected. How would you try to help the team when you join them?
    • What’s important here is how the candidate tries to help. Whether the candidate would strive to explain how something should be done properly (e.g. like a teacher, and what has already been done was wrong) or rather try to listen to the teammates as to why did they perform in such a manner and meet them where they are. Basically, a technical expert who forces decisions by claiming their own knowledge is not a good team player.
  • Have you ever found yourself in a situation where you were aware you had introduced a bug that later made the production system crash (either the whole platform or a single functionality)? If so, what did you learn from it?
    • To some extent, this question checks honesty. Junior developers might not have had a chance to release a severe bug, but senior developers definitely have. The perfect programmer does not exist, i.e, someone who has made zero mistakes. So the question beckons if the consequences of a mistake were painful for the candidate. Also, learning from mistakes is extremely important in the long run as developers need to build habits that will eliminate possibilities to introduce bugs. Especially when it comes to back-end applications. After all, we can’t be better next time if we don’t analyze why we found ourselves in a critical situation now.
  • What do you consider your greatest achievement?
    • This question is deliberately left open because it allows the developer to choose from distinct areas such as providing business value, exemplifying teamwork, and cooperation, as well as technical expertise. So it’s interesting to observe what the candidate considers important for them. In fact, a balance between all 3 would be most appreciated. You might be rightly skeptical about a candidate if they value technical expertise only since this is what you should expect later on when working for your company.

5. Technical screening of Node.js developer skills using an online coding test

Hiring a great Node.js developer can pose a significant challenge, especially if you’re doing all the dirty work yourself. For projects that require a long-term commitment and budget, you need a software development company with a solid recruitment process.

5.1. Which online test for Node.js developer skills should you choose?

When looking for the right Node.js developer skills test you should make sure it matches the following criteria:

  • The test reflects the quality of professional work being carried out
  • The duration is not too long, one to two hours max
  • The test can be sent automatically and is straight-forward in nature
  • The difficulty level matches the candidate’s abilities
  • The test goes beyond checking whether the solution works – it checks the quality of the code and how well it works in edge cases
  • It’s as close to the natural programming environment as possible and allows the candidate to access relevant resources
  • It provides the candidate the opportunity to use all the libraries, frameworks, and other tools they regularly come across

5.2. DevSkiller ready-to-use online Node.js developer skills tests

DevSkiller coding tests use our RealLifeTesting™ methodology to mirror the actual coding environment that your candidate works in. Rather than using obscure algorithms, DevSkiller tests require candidates to build applications or features. They are graded completely automatically and can be taken anywhere in the world. At the same time, the candidate has access to all of the resources that they would normally use including libraries, frameworks, StackOverflow, and even Google.

Companies use DevSkiller to test candidates using their own codebase from anywhere in the world. To make it easy, DevSkiller also offers a number of pre-made data science skills tests like the ones here:

Share post

It’s more than just newsletter

Receive useful insights right into your inbox and learn more about tech hiring.

Verify & develop coding skills seamlessly.

See DevSkiller products in action.

Security certifications & compliance. We make sure your data is safe and secure.