As your business or department grows, you will inevitably hit a point (over and over) where the people working for you cannot sustainably accomplish the tasks you set for them at the rate your plans require. When it comes to Node.js development, a significant factor in that situation can be the fallout of inefficiency that comes with not following best practices and a general lack of awareness of the Node.js paradigm and ecosystem.
Watch for these signs to know when you should hire a Node.js expert, before things have gotten stressful—if they haven't already.
Clear Sign No. 1: “Just Restart Node” Is Part of Your Weekly (Or Daily!) Parlance
If you restart your Node instance whenever something isn’t working, and you do this because this actually tends to fix things, that’s a problem. That isn’t going to fly when your Node app is in production. Plus, as your source tree grows and evolves, this will only get worse than when it was first built. If nobody on your team has been able to figure out why this is, it’s time to get outside help. Doubly so if everyone has become resigned enough to this job to stop thinking about it.
Clear Sign No. 2: “Reclone, Re-install, and Rebuild” Is Your Fallback Solution
Even more insidiously, if you find that you have to reclone your repo, run
npm install, and build your project from scratch to get your project behaving properly again, it’s a problem. It may not cause you nearly the level of in-production headache as the previous sign, but it certainly indicates that your team could use a skill boost when it comes to Node projects.
The more fallback strategies you have that smell like this one, the more your development environment depends on unreliable black boxes and arcane magic.
You need someone to open these boxes up and shed light on them. If your own developers can’t depend on your project to behave consistently, your end-users will likely have a similar experience, if not worse. By not getting help, you’re forcing yourself to either admit that you have no idea what’s happening with one of your product’s core technologies, or worse, lie about it to them.
Better to just get proper help with your Node.js development!
Clear Sign No. 3: There’s Nobody Left Who Knows the Intentions behind Architecture-level Decisions
It’s normal nowadays for people to come and go from projects for all manner of reasons. Because of this, it’s not always easy to tell what level of quality you can expect to find in the code or design someone leaves behind. Worse yet, unless priority was given to planning and documentation, there may be important project decisions whose rationale are no longer part of your team’s knowledge pool.
Sometimes, that’s OK. Other times, problems arise, and your team has to choose between staying with what was decided, or taking things in a new direction.
For example, maybe your original developer decided to use a particular database back-end, knowing how to scale it in a certain direction when the time came. That time is now. If your current team doesn’t know how to do that, they may not even know whether the scenario they are facing was planned for or overlooked. You may go off hiring a database specialist to solve the problem, when really, your data should be persisted with some other technology.
At this point, a Node.js specialist is still a generalist enough, and should have enough experience with different projects to be able to suss out the intentions (or lack thereof) of the original decisions on your project.
This time it might be good to get them to document their reasoning.
Clear Sign No. 4: The Main Debugging Tool Used by Your Team Is Still
Don’t get me wrong: It’s good to know how to use more basic tools in case you are ever stuck having to use them. But they should also give you an appreciation for more advanced tools, which you should then take advantage of where possible.
console.log() is like that. Great for learning Node.js programming, and perhaps for a one-off, quick-n-dirty debugging session. If its use has become habitual within your team, we predict that either your Node.js app has output that’s difficult to filter, or has so little output that anyone on your team who is debugging is constantly adding and removing
console.log() statements ad-hoc. Not great.
A Node.js consulting specialist will know the benefits of using the debug module, which makes it easy to filter output by category, to tailor output to how you need it in the moment. They’ll also know that any IDE worth its salt will have a Node.js-compatible debugger, with all of the typical nice features like breakpoints, variable inspection, watches, and so on.
They’ll know that even if you don’t use such an IDE that it’s possible to use Node.js’ built-in command-line tools to accomplish the same thing, and how you can hook your app’s back-end up to Chrome/Chromium’s GUI debugger if you want to go that route instead.
It’s not just that debugging is overly tedious and inefficient with
console.log(). Some classes of bugs are all but impossible to tease out without more sophisticated techniques.
For example, memory leaks may be occurring in your Node.js application without you even being aware of it. Your development runs of the Node.js back-end may be short enough or shielded enough from view that you haven’t had the chance to notice yet. In production, though, your clients certainly will, regardless of who is hosting the back-end.
Clear Sign No. 5: No One on Your Team Has Heard of Yarn
This is a pretty good sign that your team’s knowledge of the Node.js ecosystem and best practices has become outdated. That can be OK in some cases—maybe your main dependency versions are locked down, for whatever reason, so this happens to work for you. But new tools can offer enough substantial benefits that might have been previously lacking in your team’s workflow.
Yarn, an alternative package manager to the previously de facto
npm, at the very least can boost your package install time with virtually no setup.
Maybe you don’t decide to use it in the end. That’s OK: It’s not for everyone. But its popularity in the Node.js space means that if nobody on your team has heard of it, your team could use some knowledge cross-pollination to stay sharp and effective.
Clear Sign No. 6: Your Team Is Unknowingly Developing on Different Versions of Node.js
Another very concrete sign you can check for is any discrepancy between your various team members’ output of
node --version. First of all, this can easily be a source of WOMM (“Works on my machine!”) syndrome, as your app’s back-end behavior can be affected regardless of whether you tend to use cutting-edge features or not.
Second of all, a Node.js consulting specialist should not only coach your team on best practices, but also be fairly current with Node.js core changes. He or she would be much more likely to have such changes on their radar when your team is troubleshooting, and have a solid opinion on when to upgrade and when to work around bugs in Node.js itself, saving your team from pulling their hair out.
If you really need multiple Node.js versions installed, a Node.js expert would teach you how to use tools like
nvm, as with
Clear Sign No. 7: Your Back-end Team Has No Test Suite
If regressions are a common occurrence, or your team spends an undue amount of time manually testing features in a way that would be easy to automate, it’s time for a test suite. A Node.js specialist will know what it takes to set one up and also what sorts of processes are worth testing.
They’ll be able to work with Mocha or Jasmine—or whatever it is your team prefers—to get you the practical balance your team needs to make changes with confidence: the most prevention (every ounce of which is worth a pound of cure, remember) for the time invested writing the test suite in the first place.
Not everybody needs Node.js consulting for their team, but if you notice any of the signs in this article, it’s high time you gave it some serious consideration. Teams and projects grow and evolve with time, and some outside help from a Node.js expert can inject some life back into your project, helping improve your team’s tools and workflow. This, in turn, helps improve both the quality of your product and the quality of life for your team members. Everybody wins!