Personalize your experience

If you build architectures using serverless services from one cloud provider, the cost of switching to another vendor would certainly be a concern.An alternative is a "multi-cloud" strategy where applications are developed in a way that is agnostic to the vendor being used. However this may be less cost-effective than a single vendor approach. If portability is a priority, you may prefer using containers instead of serverless. You can also look at services such as AWS Fargate [link to product] that combine containers with serverless features.

Amazon CloudFront is a fast content delivery network (CDN) service that securely delivers data, videos, applications, and APIs.

Although the pricing model is a little bit different, depending on the way PaaS vendors bill their service, the main difference is the scalability:
- Applications run on serverless scale up and down automatically, without any intervention or planning. The additional servers are allocated by the cloud provider when needed
- With PaaS, the developer will have to forecast the capacity to allow a proper capacity scaling.

In a serverless architecture, the code is only initiated when it is needed. After a series of steps are performed, the function can execute the answer to the initial event. In some cases, explained in detail by Mike Roberts in this article, this may cause additional latency.
Depending on the type of application, it is not necessarily an issue but must be taken into consideration.

Due to limitations imposed by cloud providers, serverless functions have a maximum time allowed to respond to an event.
This means that serverless is not well-suited for long-running processes, that will be better performed in a traditional environment.
There are also cost considerations since cloud providers bill for the time code is running. If you want to run an application that has predictable workloads, serverless is not a good fit.

Both containers and serverless are a type of architectures where the application is split into components that run as independent microservices. The main advantage of containers is that they offer more control over the environment, as well as more choices for the languages and libraries that can be used. It makes it easy to migrate a legacy application to the cloud, with a close replication of the original environment.

Real-time data processing work best with the following features:
- Variable, high-volume compute power
- Easy integration with third-party services and many different data sources
- Use of direct synchronous and asynchronous API calls
- Event-driven architecture
Companies wanting to use cloud turned to solutions like Apache Spark or Storm to process data in near real-time.
However, those solutions require planning for scalability, and to perform tasks such as patching and deploying on their own.
Serverless offers the advantage of removing the burden of scaling and maintaining the underlying infrastructure.
More in
‍https://www.dataversity.net/real-time-data-processing-serverless-computing/#
‍and https://d1.awsstatic.com/whitepapers/Serverless_Streaming_Architecture_Best_Practices.pdf
‍Serverless architectures are well-suited for stream processing workloads which are often event-driven and have spiky or variable compute requirements.

Heroku is a cloud PaaS (Platform as a Service) that doesn't propose serverless services.
Go further with https://www.serverless.com/learn/comparisons/