#OpenSource #React #NodeJs #GraphQL #Headless #Serverless
Here’s a secret: Serverless is the future of development not because of how great of a technology it is.
Here’s another secret: The previous statement is wrong.
Let me explain.
This reading has a pre-requirement. You need to understand the difference between FaaS and serverless. In case you don’t, google it; there are plenty of articles that cover this topic.
Let’s dive in. In 2017 the serverless market was worth around 3bn USD, and the market research shows it’s going to go up to 20bn USD by 2025. We are in for a ride. A new wave of solutions will hit the market and radically change the way we build and operate our websites and applications — for the better.
Yes, there are still many pitfalls and performance bottlenecks using serverless, not to mention security which is a topic in and of itself that still needs to be figured out. Many naysayers will fire off those arguments, but one thing the whole industry knows is that serverless is inevitable; it’s going to own the market. And those issues, they’re going to be resolved over time.
The time is right to start talking to your teams and embracing the serverless way of doing things. Being a pioneer today will put you ahead of the competition. Last time such a market shift happened was with the introduction of smartphones — and we all know the impact that one had and still has.
In my opinion, currently, the biggest challenge with adopting serverless today is
All this is being addressed as we speak.
Let’s go back to those first two statements at the top.
The first one addresses the fact that this is not about technology. And it’s not; it’s about the cost or, to put it better, the tax we as engineers pay with each patch, with each ssh login, each yum update, each load balancer we install, each nginx config we create, each node/python/java installation we do, each container we create, each network config we do… and so much more.
With serverless, this tax pretty much goes away. Serverless frees up a significant portion of human resources, and that resource is expensive. As an added benefit, it shortens the development time and makes iteration cyclical faster. There is also another benefit, although it might not always be there: it reduces the cost of infrastructure and makes the spend more efficient.
The second “secret” is about the fact that the first one is wrong, and it is wrong. It is wrong because serverless is not a technology. Serverless is a way of building things by not relying on servers or having solutions that require you to maintain your infrastructure.
Serverless is a mindset shift and not a technology
- Paul Johnston
You might think that this will be a long and painful process, but actually many enterprises that did that journey proved it's not. Moving to serverless is a simple process if you plan it correctly.
Approaching serverless with a microservices architecture opens a migration path where the smallest pieces of logic are moved, one at a time.
No matter if your application is currently a monolith, it's not hard to extrapolate smaller pieces from it and move it to a lambda function or something similar. This approach provides a controlled and a low-risk migration path.
There are certain big changes an organisation will need to make. The first one will be on the operations team, a team that monitors the rollout of your changes.
With a monolithic structures, there are less rollouts than when you have 100s of microservices, where several of them get deployed at a much faster pace.
In this situation, the operations team can either scale in number of people to handle the new deployment requests, or there is a mind-shift in how we deploy things. Things that are high-risk should be covered by operations team, but things that are low-risk, and with microservices there will be a lot of these, maybe the development teams should take care of that.
Similar to the approach of breaking your monolithic code into many smaller services, the development teams should follow the same approach.
Besides breaking those team into smaller units, you should also think about breaking technology barriers. There is no longer the need that all services are written in a single language, let the team decided what is the best language for a specific service.
The change in the technology can also have a positive effect on hiring, as you can tap into several different pools of available talent, not just a single one.
To wrap this up, so is serverless the future of development?
Definitely and 100% YES.
I believe we are only starting to unravel what serverless will become.
You can watch and reap the benefits or you can be more engaging and contribute. Writing blogs and educating others, contributing to serverless projects, this will only bring us closer to the serverless future.
I hope you’ve enjoyed this read. My name is Sven and I am the co-founder of Webiny Serverless CMS.
At Webiny, we are all about serverless. We’ve been paying the "tax" for many years and decided to build and provide a solution to the whole community to help them ease their transition into the serverless mindset.
Webiny is open-sourced, powered by Node.js and React, and has a GraphQL API. You can use it to build serverless apps, websites, and APIs. It comes with several ready-made apps like Page Builder, Headless CMS (coming soon) and a few others.
Serverless IS the future, and if you haven’t taken the first steps in that direction, the time is now.