node.js Hosting: Compare Hosting
Oops! No Hosting Plans Match Your Search
You've selected a combination of features that none of the web hosts we profile offer. We suggest you remove your last filter or reset & start again.
Ask Our Experts
Need help with your hosting? Tell us exactly what you are looking for and we’ll do our very best to help. Please allow one working day for a response.
Please fill in all fields.
Thanks! Your request has been sent. We'll reply within 24 hours.
Recommended Host for node.js
What is Node.js?
Node.js is an event-driven runtime environment and development framework. It can be used to build server-side web applications, and its architecture allows for massive scalability.
In most conventional web server environments, requests are handled as single, discreet events: A request is made to the server, the server does something, and a response is sent back. This makes it difficult to get ongoing feedback about any kind of process (like a file-upload progress bar), or to do any kind of push notification.
The usual way these sorts of things were done was essentially a hack: send a series of frequent requests over and over to check on progress of fetch new notification.
Node.js was invented to provide a different way of handling client-server I/O (input/output).
But it is a fully-featured programming language and can be used in other contexts as well.
The inventor of Node.js discovered that its I/O handling capabilities (or lack of them, actually), and some of its other characteristics, made it ideal for writing an environment capable of asynchronous, event-driven I/O.
Event Driven Architecture
Event driven architecture is a way of orchestrating the way software components interact with each other and their environment.
In a conventional, non-event-driven approach, if you want one action to cause another action, you usually would have to write an explicit connection between those two actions. This had to be done inside the causal agent.
That is: if I want A to trigger B, I have to add some code to A.
Event-driven architecture abstracts this to an environment that contains triggers and listeners. You can add event triggers to any action (even if you don't know yet that it will be meaningful later) and add listeners to components (even if there is nothing yet to trigger them). Listeners wait for triggers, and launch some action when a trigger happens.
Node.js took advantage of this built-in characteristic to create an event-driven development framework for creating applications.
Non-Blocking I/O and Single Threading
In Node.JS, I/O operations don't block other I/O operations, allowing multiple connections to be made simultaneously without disrupting each other. All connections operate in a single thread, so there is no performance drag from context-shifting between multiple concurrent processes.
Because of these characteristics, Node.js is highly useful for real-time, highly concurrent applications, such as gaming.
Reasons to use Node.js
- It is very fast
- Node Package Manager
- Plugins are great. Libraries are great. You know what isn't great? Installing things. Also, dependency management. The Node.js Package Manager (npm) solves those problems by creating a rich, easy-to-use installation and deployment ecosystem. Each project can use specific versions of packages, without creating conflict with other applications that might need a different version. It handles installation, updating, and dependencies.
- Full stack, one language
- Real time computing
- The event loop and its support for multiple, concurrent connections makes Node.js perfect for real-time interaction between multiple clients. This makes it a good choice for applications like gaming, chat, and command-and-control.
Reasons Not to Use Node.js
Node.js is not a "cure-all" development framework. There are certainly some applications where it isn't the best option.
- Heavy data computation and processing
- Node.js is really fast at handling I/O, but it only does one thing at a time. Throwing output at various connections and taking in requests is relatively fast, and the event loop lets Node.js switch between them much faster than if they were separate processes. So the speed is gained by never trying to do two things at once.
- The problem with that is that if any single thing does take a long time, everything else has to wait. So doing computational heavy-lifting isn't a great idea. (Although "” this could be handled by outsourcing the computation to another process or machine, turning it into an asynchronous I/O operation.)
- Relational Database Application
- Unlike Ruby on Rails and several PHP frameworks (Laravel, CodeIgniter, Symfony), Node.js does not have fully mature support (yet) for relational database (SQL) interaction. You can do it, but it's easier in other environments. (Also, there isn't much to be gained by using the Node.js concurrency model in a transactional database setting.)
Node.js is still relatively new, so most web hosts don't support it yet. On the other hand, it's also very trendy, so there are a number of specialized web hosting providers that are well-optimized for Node.js applications. Be sure to compare hosting options in detail before committing to one.
node.js Hosting Frequently Asked Questions
What is Node.js?
What is a runtime environment?
A runtime environment provides an application with all of the resources it needs to operate. For instance, in order to run on a machine an application will need access to the directories and files on the machine, hardware resources such as RAM and CPU, and software resources such as system utilities and software libraries.
What is a real-time web application?
A real-time web application is a website that is interactive and updated based on real-time input from one or more users. For example, an online chat system is a real-time web application. It is interactive and updated continuously based on real-time input from multiple chat users. Node.js is an ideal platform for building real-time web applications.
Why is Node.js a good choice for real-time web applications?
Node.js processes requests using an event-driven model. What that means is that Node.js handles a single event and sends it off to perform an action, then while it's waiting for the results of that action it can go ahead and handle additional events. That might not sound like a big deal, but in the traditional thread-based model once a server receives a request it doesn't do anything else until that request has been completely handled.
This means that Node.js can handle lots of requests far more efficiently than a thread-based model. That's just what you want and need if you have an application that takes in input from multiple users simultaneously and adjusts the experience of every user based on the collective input of multiple users.
What is non-blocking I/O?
Sometimes you'll hear someone refer to the fact that inputs and outputs (I/O) in Node.js are non-blocking. This is basically another way of saying that Node.js is event-based. What this means is that when Node.js receives input it can process that input and produce output without blocking other inputs and outputs from being handled concurrently.
Let's look at an example. Node.js receives input A, processes it, and fires off a function. While it's waiting on the results, input B shows up. Node.js goes ahead and processes input B while it waits on the results for input A. If the results from input A are ready before input B has finished processing, the results from input A will wait in line until Node.js is ready for them. Node.js finishes processing input B, fires off a function for input B, then grabs the results from input A and sends them off as output A back to the source that sent in input A.
It is this non-blocking I/O handling that allows Node.js to handle a very large number of inputs and outputs very efficiently.
Can I build a content-management system with Node.js?
Yes, you can. However, there may be better options available for the task. The real power of Node.js is it's ability to handle loads of inputs and outputs in a non-blocking fashion. A content-management application usually manages cacheable web pages, and non-blocking I/O generally isn't important to accomplish that task.
What type of database can you use with Node.js?
You can use any type of database with Node.js as long as you can find a package with the necessary drivers to let Node.js interact with the database system. Thankfully, there are free packages available from NPM for most popular database systems.
What is NPM?
What are NPM packages?
How much does Node.js cost?
Node.js is free and open-source. It shouldn't add a dollar to your hosting bill.
Can I use Node.js with shared hosting?
To use Node.js you'll need shell access to the server (SSH) and the ability to set up Node.js to listen for requests received over port 80. A private environment is usually required to run Node.js unless your hosting provider explicitly supports Node.js in a shared environment. So you'll probably want a VPS, dedicated server, or private cloud server. Finally, while Node.js can run on any operating system, most Node.js installations run on Linux.