In this article we summarize the insights we learned from our latest survey on developers problems with Node.js Debugging, Downtimes, Microservices & other pain-points.

In the second part of the article, we attempt to provide help with the greatest Node.js issues we discovered.

Key Survey Results

A survey conducted by RisingStack, the company known for its Node.js Monitoring Solution and Node.js Services shows that 1/3rd of Node.js Developers experience downtimes in production systems at least once a week.

Node.js Survey by RisingStack - Downtimes

The survey also shows that 43% of the developers spend more than 2 hours a week debugging their Node.js Applications, including the 17% who spends more than 5 hours a week fixing errors in production systems.

Node.js Survey by RisingStack - Time spent with Debugging

About the Node.js Survey

The survey was conducted via an online form between 13-27 April. It was completed by 746 developers of which 509 claims to have Node.js applications in Production systems. The survey focuses solely on their problems, and this report is based on their answers.

The participants of the survey are subscribers of RisingStack’s Node.js Blog, who were asked to participate through email.

The Greatest Pain-Points of Node.js Development

The survey provides valuable insights into the problems Node developers face on a daily basis since we asked them to describe what’s the greatest challenge they face with their applications.

The biggest hurdle that developers who use Node.js face is debugging their applications (18% of all respondents). According to the data, nothing comes close to the seriousness of debugging microservices and bugs in production.

Node.js Survey by RisingStack - Top Node.js Problems Developers Face

Click here to Open High-Res version

The second tier of errors contains categories like memory issues (mainly memory leaks), difficulties of scaling & monitoring Node.js apps and getting deployments right (especially in high-scale production systems). There are also problems with Async programming, error handling, and managing dependencies. Each of these problems were pinpointed as the most severe by 6-8% of developers.

The third tier of problems are still major ones. Developers mention Microservices (communication, integration, management), callbacks, security (including authentication issues) and downtimes (handling downtimes and restarts) a lot. They also face troubles keeping up with the fast-changing Node.js environment, improving the performance of their apps, and Tracing issues.

The last tier of problems named by the respondents of this survey were relatively minor. They include the usage of promises, the lack of standards, the hardship of project structuring, testing & threading. Developers also mention the blocked event-loop, learning Node.js, logging, and configuration as their biggest challenges with Node.

How do Microservices Affect Node.js Systems?

Another interesting insight can be gained from the survey if we compare people who have a microservices-based application to those who said they don’t:

  • There’s a slight increase in hours spent with debugging among those developers who are building a microservices architecture with Node compared to those who work on monoliths. 44,4% spends more than two hours with debugging per week, compared to 41,2%.

  • There’s a significant difference in avoiding downtimes if we compare developers with Microservices architectures to the ones we don’t. It looks like that 29,3% of Microservices developers never experience downtimes, compared to 25,6% of developers who do not build a distributed application.

Node.js Survey by RisingStack - Microservices vs no Microservices

Understanding the Data

Although the data we collected is not representative, it underpins the experience we gained during our consulting & training projects at RisingStack.

Building a microservices architecture in an unprepared company can bring enormous complexity on an engineering level and on the management level as well. We see that there are several costly mistakes which developers constantly make, which can easily lead to chaos.

We recommend breaking down monolithic applications intro microservices in a lot of cases, but it’s undeniable that finding and fixing bugs in a distributed system is much harder thanks to the myriad of services throwing errors all the time.

Experiencing fewer downtimes with microservices is one of the main benefits of the technology since the parts of an app can fail individually (and often unnoticed), keeping larger systems intact.

How to Overcome the Greatest Obstacles with Node.js

If the data we collected resonates with your Node.js development experience, you might need help to solve your issues.

Below we collected some of the best resources you can use to tackle the most common difficulties with Node.js:

⬢ Node.js Debugging

⬢ Node.js Memory Leaks & Issues

⬢ Scaling up Your Application

⬢ Monitoring Node.js Apps

⬢ Help with Deployment

⬢ Asynchronous Programming in Node.js

⬢ Node.js Error Handling

Professional help with Node.js

In case you need an agile team who can take ownership of your Node.js projects and help you scale your application, check out our Node.js Consulting & Development Services!

We can help you with:

  • Digital Transformation Projects
  • Architectural Consulting
  • Training and Education
  • Outsourced Development
  • Co-development

Technologies we love to use:

  • Node.js
  • Containers & Cloud
  • Microservices
  • Docker
  • Kubernetes
  • AWS and Google Cloud

Key Findings of the Node.js Survey

  • 29,27% of Node.js developers experience downtimes in production systems at least once a week, 54,02% at least once a month.

  • 27,50% of Node developers responding to the survey never experience downtimes.

  • 42,82% of the respondents spend more than 2 hours a week with debugging their Node.js applications, including the 17,09% who spends more than 5 hours.

  • The developers building a microservices architecture with Node spend more time with debugging. The advantage of microservices + Node manifests in the form of fewer downtimes.