With 98% of Fortune 500 companies and 96% of IoT startups incorporating Node.js in their technology stack, we have no doubt its ecosystem will grow even faster than it did in the previous years.
With so many exciting things going on, here are five things we believe will be hot in Node.js community in 2019:
1. Serverless solutions
In short, serverless is a system in which you are not concerned with the maintenance of the servers your applications are running on. The focus of the team is limited to software only, eliminating all the hardware related issues and malfunctions as they are outsourced to third party providers with guaranteed service uptime. We believe serverless allows quick and relatively cheap idea validation, especially valuable in highly competitive sectors and for companies which have embraced the agile mentality or failing fast, but winning big.
Here are a couple of ways in which choosing a serverless approach/solution could benefit your business:
No upfront infrastructure planning - it’s all provided.
Easier pivoting - the solution dictates the usage of small reusable services, which prevents rewriting and enforces code quality.
Increased infrastructure return rate and more precise cost projections - with serverless, you pay only for what resources you actually use.
Variable costs and infinite scalability - there is no need to scale machines any longer, the service scales as it grows, costs are calculated on a subsecond metering basis (for example $0.0000002 per request or 0.2$ per 1M requests and $0.00001667 for GB-SECOND). For a sample, refer to this pricing page.
Componentized development - possibility of reusing core features of applications, such as authorization or payment processing.
Increased service stability, easier maintenance and testing - the way serverless applications are written results in simpler and more testable units.
Shifting resources from DevOps to development.
Here is what Coca-cola did with Serverless an IoT for example - they started gathering reports on sales from vending machines across the globe instantaneously, eliminating the need to keep the servers running at all times. They’ve managed to cut down operational cost from 13000$ down to 4500$ a year on a simple service - a 65% savings - and this number covers just the direct architecture fees for Amazon EC2 instances.
What we use inhouse: AWS Lambda, Google Cloud Platform, Serverless Framework, Cloudia and AWS SAM.
2. Node.js Microservices and orchestrators
Microservices can be seen as an alternative to the serverless movement, as what they bring to the table is similar to the benefits of a serverless approach. Microservices written in Node.js shine especially in large scale products and proven solutions that want to improve maintainability and eliminate the technical debt of their current stack.
Among others, the microservice pattern allows for:
Independent development - multiple teams can work on separate parts of an application simultaneously
Independent scalability - only the parts of the application that are under heavy load will scale to multiple instances, thus limiting the scaling cost. For example, if most of your users use the video streaming part of your application daily, it would automatically “cluster up” to match the traffic needs.
Independent deployment - they run separately, which allows for faster and more decoupled deployments. You can choose which features to release independently instead of releasing one major update.
Reusability - they can be used by multiple applications and limit logic replication.
Resilience - failure of a part of the system does not bring down the whole system.
Free technology choice - granted that the communication means are agreed upon, there is no reason for avoiding cross-technology microservice communication. You can have some components running Node.js (we suggest most) communicate with others written in virtually any other technology stack.
Their efficient use requires an “orchestrator”. At Netguru, we use Kubernetes to ensure the microservices we build in Node.js run smoothly and scale properly. Kubernetes also monitors our Node.js microservices and ensures their continuous availability. It also prevents the drawbacks microservices can result in, such as complicated deployment processes, putting monitoring in place, auto-placements, auto-restarts, auto-replications, and auto-healings.
These days it is virtually impossible to talk about microservices without mentioning Netflix - they use ~1000 different ones to serve ~15% of their global downstream volume. The subtitles are for examples served by a service that is entirely independent of the video streaming one, meaning if it breaks for some reason, the core Netflix service provider is still functional. It makes graceful degradation easier, often hiding the underlying errors entirely from the end users.
Other notable mentions: Uber, WeChat, Walmart, Spotify, Amazon.
Employing GraphQL in your application allows for the use of multiple data sources (for example third party REST APIs) in an efficient manner. It simplifies the workflow on multiple platforms, and the development of new features - it can provide sample placeholder structures while features are still being developed.
Using GraphQL results in lowering data overfetch - the consumers of your product can get exactly what they need - which is especially important considering ~50% of all web traffic comes from mobile devices. This in turn provides additional security layers for your application and lowers the risk of protected data exposure (adding an extra layer of security in terms of GDPR compliance).
GraphQL is also a great connector for when you want to switch from a legacy technology to something more modern, as it does not require the underlying dependencies to be written in one stack. Let’s say you want to move away from your legacy code. Thanks to GraphQL, you don’t need to rewrite your whole product from scratch, but simply reuse the existing services you are happy with and connect them to something more modern through GraphQL.
To an extent it can be used as an alternative to database model modification - it allows operations on abstract structures stitched together by the GraphQL engine, making it easier to expand the models that were previously set in stone until the next database migration.
Kiwi.com uses multiple data sources to provide us with the most cost-effective travel options. Under the hood they do that thanks to implementing GraphQL to fetch the data from multiple other search engines, such as SkyScanner and InterRail. Kiwi.com then provides its users with a clear and coherent presentation layer thanks to the uniform data model that GQL enables.
Other notable mentions: Facebook, PayPal, Shopify.
4. Cloud computing
Some of the solutions discussed above already fall into that category, but there is plenty more that hides under the term. Node.js can help you either build an entirely new product or use the existing ones to enhance your application. Cloud computing allows for the most varied service models - Platform as a Service (AWS), Software as a Service (Prisma, Google Apps) , Infrastructure as a Service (Amazon EC2), Content as a Service (Contentful, Prismic) or Function as a Service (Netlify authentication).
Most cloud computing solutions benefit from all that serverless brings to the table:
It’s relatively easy to do cost projection and anticipate its growth.
Scalability - virtually endless without the need to invest in hardware.
Security and privacy - which is usually handled by the cloud providers you choose to use for your apps.
Besides that, technology sharks are open-sourcing some of their cloud architecture solutions - one of the most recent Node.js related releases is cloudnativejs.io by IBM. We shouldn’t forget all the already available cloud solutions offered by the tech giants, such as speech-to-text or IBM Watson, either.
Notable Mentions: Google Apps, Prisma, Contentful, Prismic, Storyblok, Spotify, Adobe.
5. Real-time web app provisioning
Node.js performs especially well under heavy load and is hence a perfect solution for almost any real-time web project. There is a plethora of applications that require real-time communication, from chat bots, instant communication apps, tele-conferencing software, and cloud-based personal assistants, all the way to data stream processing, all of which Node will continue to shine in. There is plenty of not-so-obvious solutions that may replace mundane procedures or act as reminders - we use an inhouse-built bot to remind us of calendar events, hanging code reviews, and to elicit feedback.
Most of us use some sort of real-time app on a daily basis without even realizing it. Be it a food delivery app displaying the location of our coveted meal (Uber Eats), Google Docs and other online collaboration tools, all the way to online stock tickers and cryptocurrency price trackers. Don’t forget the numerous messenger apps and video communication tools, like Skype or Google Hangouts, that let us keep in touch wherever we are. A notable example here is Figma - an online design collaboration tool that manages to compete with the big players despite its relatively short tenure.
All of those need some backend processing and data serving platform - Node.js is a great solution for both of those needs with its outstanding support for the WebSockets protocol.
Regardless of which of the above will actually prove right, we are positive Node.js in 2019 will mean cheaper, more resilient, extremely scalable, and independent services. There is no doubt that Node will also be a part of the stacks yet to emerge considering its footprint on the global developer community and the rich ecosystem it allowed for, namely the Node Package Manager. You will not find an architecture/platform provider who does not offer out-of-the-box support for Node.js projects today.
This piece was created as a result of a conversation between Daniel Jadczak, Michal Hartwich, Artur Figiel, and Paweł Drożański.
More posts by this author