arxiv: 2604.15916 · v1 · submitted 2026-04-17 · 💻 cs.DC

Recognition: unknown

New Kids: An Architecture and Performance Investigation of Second-Generation Serverless Platforms

Trever Schirmer , Aris Wiegand , Lucca di Benedetto , Linus Gustafsson , Natalie Carl , Tobias Pfandzelter , David Bermbach

Authors on Pith no claims yet

Pith reviewed 2026-05-10 08:10 UTC · model grok-4.3

classification 💻 cs.DC

keywords serverless computingsecond-generation platformslightweight isolatesedge deploymentcold startswarm latencymicrobenchmarksplatform architecture

0 comments

The pith

A second generation of serverless platforms has emerged that uses lightweight isolates and edge deployment instead of containers and central servers.

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper aims to show that serverless computing has evolved beyond its first-generation container-based centralized model. It identifies a new set of platforms that rely on lightweight execution isolates and distributed edge locations. This shift matters because it dramatically improves request latencies and minimizes the impact of cold starts, allowing applications to run more responsively but at the cost of a more restricted execution environment. The authors support this by examining seven public platforms and conducting extensive microbenchmarking across millions of function invocations.

Core claim

Next to the traditional serverless platforms based on containerized centralized execution, a second generation has emerged that leverages lightweight isolates and edge deployment. This reduces warm request latency from around 40 ms to 10 ms and makes cold starts negligible, although it constrains the available execution environment. The claim is backed by architectural analysis of seven platforms and performance data from over 38 million function calls.

What carries the argument

The generational classification of serverless platforms according to their execution model: first-generation uses containers in centralized setups, while second-generation employs lightweight isolates deployed at the edge.

Load-bearing premise

The seven examined platforms accurately represent a distinct emerging generation rather than just variations within the existing landscape.

What would settle it

A survey of additional serverless platforms showing no consistent use of lightweight isolates and edge deployment, or benchmarks where warm latencies remain at 40 ms levels across the identified second-generation candidates.

Figures

Figures reproduced from arXiv: 2604.15916 by Aris Wiegand, David Bermbach, Linus Gustafsson, Lucca di Benedetto, Natalie Carl, Tobias Pfandzelter, Trever Schirmer.

**Figure 1.** Figure 1: AWS Lambda architecture and request workflow. Within a region, requests are load-balanced to an availability zone. [PITH_FULL_IMAGE:figures/full_fig_p004_1.png] view at source ↗

**Figure 2.** Figure 2: On-Demand data loading implementation in AWS Lambda that allows lazily downloading only the chunks of function [PITH_FULL_IMAGE:figures/full_fig_p005_2.png] view at source ↗

**Figure 3.** Figure 3: Cloud Run Architecture. Requests and management calls are terminated at a per-region front end service, which load [PITH_FULL_IMAGE:figures/full_fig_p006_3.png] view at source ↗

**Figure 4.** Figure 4: Cloudflare Workers Architecture. Requests are terminated at every edge location by an inbound HTTP proxy. They [PITH_FULL_IMAGE:figures/full_fig_p008_4.png] view at source ↗

**Figure 5.** Figure 5: Fly.io Architecture. In every region, a proxy terminates requests. This proxy searches for an idle or underutilized [PITH_FULL_IMAGE:figures/full_fig_p009_5.png] view at source ↗

**Figure 6.** Figure 6: Warm start performance. The left ECDF shows two distinct clusters that both have similar latency distributions: edgeoriented- (DD, CW) with 𝜇≈10𝑚𝑠, and regional platforms (OCF, CRF, Lambda) with 𝜇≈40𝑚𝑠. In the ECDF, the slowest 5% are not shown. The bar chart on the right visualizes the relative frequency of cold starts per day in the warm start experiment. While most platforms have a low unexpected cold … view at source ↗

**Figure 7.** Figure 7: Cold start performance. The ECDF on the left shows that the two latency clusters observed during warm start experiment are less pronounced for cold starts, with higher spread across providers. The box plot on the right displays the cold factor 𝜇cold 𝜇warm : Fly consistently shows the highest penalty for cold starts, whereas Deno Deploy and Cloudflare exhibit near-zero cold factors, indicating minimal over… view at source ↗

**Figure 8.** Figure 8: Global latency performance across providers. The violin plot on the left show that regional providers exhibit wider, multimodal latency distributions reflecting the varying geographical distances between clients and deployed functions, while edge-oriented providers remain tightly concentrated near zero. The scatter plot on the right confirms a strong distance–latency correlation for regional providers, wit… view at source ↗

**Figure 9.** Figure 9: IO consistency. The plot shows the deviation from the overall median IO consistency for providers supporting file system interactions, depending on time of day. OCF and Fly, both using OCI images, consistently achieve the lowest absolute IO latencies, but OCF has the highest variance. Lambda (running on Firecracker) has average absolute values with very low variance, and CRF exhibits the highest IO latenci… view at source ↗

**Figure 10.** Figure 10: Cold starts and latency in the elasticity experiment. The left plot shows the median per-second latency in every second of the experiment. Latency is highest at the beginning due to cold-start execution and decreases as the platform transitions to serving requests predominantly from warm instances. The right plot shows the median number of cold starts experienced during a day the experiment ran (96 exper… view at source ↗

**Figure 11.** Figure 11: Transfer latency performance. Again, a clear clustering between regional platforms and edge-oriented platforms emerges. The daily median latency plot on the left shows that the performance is relatively consistent for the duration of the experiment, with the regional platforms hovering around 600 ms and the edge-oriented platforms around 30 ms. CRF is the only highly variable platform. The correlation plo… view at source ↗

read the original abstract

With the ever-increasing usage of serverless computing in both industry and academia, it is essential to understand the mechanisms that power the underlying platforms. As serverless is more than ten years old, there are different platforms with vastly different approaches. We show that, next to the traditional and popular platforms, a second generation of serverless platform has emerged. While first-generation platforms are based on containerized, centralized execution, the new generation leverages lightweight isolates and edge deployment. This evolution reduces warm request latency from approximately 40 ms to around 10 ms and reduces cold starts to an afterthought, but limits the execution environment. In this paper, we gather and analyze all publicly available information to provide detailed insights into the underlying architecture of seven platforms and then run a microbenchmark-based evaluation totaling more than 38 million function calls to gain a deeper understanding their performance.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Desk Editor's Note private letter to a colleague

The paper gives concrete latency numbers showing newer serverless platforms cut warm starts to ~10 ms, but the claim that these form a distinct second generation with generalizable results rests on thin selection and controls.

read the letter

The main thing to know is that this work measures a real performance shift: platforms using lightweight isolates and edge deployment deliver warm-request latencies around 10 ms and make cold starts negligible, versus roughly 40 ms on traditional containerized setups. They support this with public architecture details on seven platforms plus a microbenchmark campaign of over 38 million calls. That scale of consistent testing across platforms is the strongest part of the paper and supplies practical data that cloud users can check against their own workloads. The classification into first- and second-generation platforms is a reasonable way to organize the observations, and the authors are clear that the newer approach trades off execution-environment flexibility. The soft spots are exactly where the stress-test note flags them. The seven platforms are treated as representative of an emerging generation, yet the paper does not lay out explicit inclusion criteria or show why other platforms were excluded. Without visible controls for language runtime, function size, or deployment scale in the summary, it is hard to tell whether the latency drop is systematic or an artifact of the chosen test harness and implementations. The abstract supplies no error bars, workload definitions, or statistical details, so the central claims cannot be fully evaluated from the high-level description alone. If the full text adds those elements and discusses limitations, the work improves; otherwise the generalizability remains an open question. This paper is for distributed-systems researchers and practitioners who need up-to-date performance baselines on current serverless options. It is not foundational theory but supplies usable numbers for platform selection. It deserves peer review because the experiment volume is substantial and the topic is timely, even though revisions will be needed to strengthen the methods section and the generational framing.

Referee Report

2 major / 2 minor

Summary. The paper claims that serverless computing has evolved beyond first-generation platforms (containerized, centralized execution) to a second generation that leverages lightweight isolates and edge deployment. Analysis of seven platforms via public documentation, followed by microbenchmarks totaling more than 38 million function calls, shows this shift reduces warm-request latency from approximately 40 ms to around 10 ms, renders cold starts negligible, and imposes limits on the execution environment.

Significance. If the architectural classification and performance deltas hold under broader scrutiny, the work supplies a timely empirical map of serverless platform evolution that could inform both platform selection and future design. The scale of the benchmark campaign (38 M calls) is a clear strength, providing concrete latency and cold-start data within the chosen test conditions and workloads.

major comments (2)

[§3] §3 (Architecture Survey): the claim that the seven platforms constitute a coherent 'second generation' rests on public documentation alone; no explicit inclusion criteria, boundary definitions, or argument for representativeness are supplied, leaving open whether the observed latency reduction is a class property or an artifact of the selected set.
[§5] §5 (Microbenchmark Evaluation): the reported warm-latency drop (40 ms to ~10 ms) and negligible cold starts are presented without error bars, workload definitions, controls for language runtime, function size, or invocation scale; these omissions make it impossible to determine whether the differences are systematic or contingent on the particular harness and implementations used.

minor comments (2)

Figure captions and axis labels in the performance plots could be expanded to include exact invocation counts and platform versions tested.
[§3] A short table summarizing the seven platforms' key architectural features (isolate type, edge presence, supported languages) would improve readability of the survey section.

Simulated Author's Rebuttal

2 responses · 0 unresolved

We thank the referee for the constructive feedback. We address each major comment below and will incorporate revisions to improve clarity and rigor without altering the core claims or results.

read point-by-point responses

Referee: [§3] §3 (Architecture Survey): the claim that the seven platforms constitute a coherent 'second generation' rests on public documentation alone; no explicit inclusion criteria, boundary definitions, or argument for representativeness are supplied, leaving open whether the observed latency reduction is a class property or an artifact of the selected set.

Authors: We agree that the manuscript would be strengthened by explicit criteria. In the revision we will insert a new subsection at the start of §3 that states the inclusion criteria (platforms using lightweight isolates such as WebAssembly or Firecracker together with edge deployment), supplies boundary definitions, and argues for representativeness by reference to market adoption and architectural divergence from container-based centralized designs. This will make clear that the latency and cold-start improvements are presented as properties of the architectural class rather than solely of the sampled platforms. revision: yes
Referee: [§5] §5 (Microbenchmark Evaluation): the reported warm-latency drop (40 ms to ~10 ms) and negligible cold starts are presented without error bars, workload definitions, controls for language runtime, function size, or invocation scale; these omissions make it impossible to determine whether the differences are systematic or contingent on the particular harness and implementations used.

Authors: We acknowledge that additional methodological detail is required. The revised §5 will report standard-deviation error bars for all latency figures, define the workloads (function sizes, languages, and invocation patterns), and document controls for runtime environment and scale. The 38 million calls were collected under repeated, controlled conditions; these additions will allow readers to assess systematicity while preserving the reported performance deltas. revision: yes

Circularity Check

0 steps flagged

Empirical architecture survey and benchmark study with no derivation chain or self-referential predictions

full rationale

The paper performs an architecture survey of seven publicly documented serverless platforms based on public information, followed by a microbenchmark evaluation of over 38 million function calls. No mathematical derivations, equations, fitted parameters, or predictions appear in the provided abstract or description. The classification of platforms into first- and second-generation is presented as an empirical observation of differences (containerized centralized execution vs. lightweight isolates and edge deployment), not a self-definition or reduction to prior results by construction. No self-citations are invoked as load-bearing for uniqueness theorems or ansatzes. The work is self-contained as a descriptive and experimental study; the central claims rest on the collected documentation and benchmark data rather than any circular reduction.

Axiom & Free-Parameter Ledger

0 free parameters · 0 axioms · 0 invented entities

This is an empirical systems paper with no mathematical model, fitted parameters, or postulated entities. The generational classification rests on observed platform characteristics rather than axioms or derivations.

pith-pipeline@v0.9.0 · 5465 in / 1015 out tokens · 27897 ms · 2026-05-10T08:10:02.806938+00:00 · methodology

discussion (0)

Reference graph

Works this paper leans on

95 extracted references · 30 canonical work pages

[1]

Alexandru Agache, Marc Brooker, Alexandra Iordache, Anthony Liguori, Rolf Neugebauer, Phil Piwonka, and Diana-Maria Popa. 2020. Firecracker: Light- weight Virtualization for Serverless Applications. 419–434. https://www. usenix.org/conference/nsdi20/presentation/agache

2020
[2]

2014.A WS EC2 Nitro

Amazon Web Services, Inc. 2014.A WS EC2 Nitro. Retrieved 2026-02-16 from https://aws.amazon.com/ec2/nitro/

2014
[3]

2014.A WS Lambda

Amazon Web Services, Inc. 2014.A WS Lambda. Retrieved 2026-02-16 from https://aws.amazon.com/lambda/

2014
[4]

2026.ch_placer.go

FnProject Authors. 2026.ch_placer.go. FnProject Authors. Re- trieved 2026-02-16 from https://github.com/fnproject/fn/blob/ a402c5ea513db03cb555627fab65ecc94e69204f/api/runnerpool/ch_placer.go

2026
[5]

Selfie and the basics,

Ioana Baldini, Perry Cheng, Stephen J. Fink, Nick Mitchell, Vinod Muthusamy, Rodric Rabbah, Philippe Suter, and Olivier Tardieu. 2017. The serverless trilemma: function composition for serverless computing. InProceedings of the 2017 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software. ACM, Vancouver...

work page doi:10.1145/3133850.3133855 2017
[6]

2020.Cloud Run is a Knative

Ahmet Alp Balkan. 2020.Cloud Run is a Knative. Retrieved 2026-02-16 from https://ahmet.im/blog/cloud-run-is-a-knative/

2020
[7]

2017.Cloud Service Benchmark- ing: Measuring Quality of Cloud Services from a Client Perspective

David Bermbach, Erik Wittern, and Stefan Tai. 2017.Cloud Service Benchmark- ing: Measuring Quality of Cloud Services from a Client Perspective. Springer, Cham, Switzerland

2017
[8]

Marc Brooker, Adrian Costin Catangiu, Mike Danilov, Alexander Graf, Colm MacCárthaigh, and Andrei Sandu. 2021. Restoring Uniqueness in MicroVM Snapshots.CoRRabs/2102.12892 (2021). arXiv:2102.12892 https://arxiv.org/ abs/2102.12892

work page arXiv 2021
[9]

Marc Brooker, Mike Danilov, Chris Greenwood, and Phil Piwonka. 2023. On- demand Container Loading in AWS Lambda. In2023 USENIX Annual Techni- cal Conference (USENIX ATC 23). USENIX Association, 315–328. https://www. usenix.org/conference/atc23/presentation/brooker

2023
[10]

Meiklejohn

Sebastian Burckhardt, Chris Gillum, David Justo, Konstantinos Kallas, Connor McMahon, and Christopher S. Meiklejohn. 2021. Durable functions: semantics for stateful serverless.Proceedings of the ACM on Programming Languages5, OOPSLA (Oct. 2021), 1–27. https://doi.org/10.1145/3485510 New Kids

work page doi:10.1145/3485510 2021
[11]

2024.A lightweight WebAssembly runtime that is fast, se- cure, and standards-compliant

bytecodealliance. 2024.A lightweight WebAssembly runtime that is fast, se- cure, and standards-compliant. Retrieved 2026-02-16 from https://github.com/ bytecodealliance/wasmtime

2024
[12]

Hsieh, Deborah A

Fay Chang, Jeffrey Dean, Sanjay Ghemawat, Wilson C. Hsieh, Deborah A. Wal- lach, Mike Burrows, Tushar Chandra, Andrew Fikes, and Robert E. Gruber. 2008. Bigtable: A Distributed Storage System for Structured Data.ACM Transactions on Computer Systems26, 2 (June 2008), 1–26. https://doi.org/10.1145/1365815. 1365816

work page doi:10.1145/1365815 2008
[13]

Ryan Chard, Yadu Babuji, Zhuozhao Li, Tyler Skluzacek, Anna Woodard, Ben Blaiszik, Ian Foster, and Kyle Chard. 2020. funcX: A Federated Function Serving Fabric for Science.Proceedings of the 29th International Symposium on High- Performance Parallel and Distributed Computing(June 2020), 65–76. https://doi. org/10.1145/3369583.3392683 arXiv: 2005.04215

work page doi:10.1145/3369583.3392683 2020
[14]

Qiong Chen, Jianmin Qian, Yulin Che, Ziqi Lin, Jianfeng Wang, Jie Zhou, Licheng Song, Yi Liang, Jie Wu, Wei Zheng, Wei Liu, Linfeng Li, Fangming Liu, and Kun Tan. 2024. YuanRong: A Production General-purpose Server- less System for Distributed Applications in the Cloud. InProceedings of the ACM SIGCOMM 2024 Conference. ACM, Sydney NSW Australia, 843–859. ...

work page doi:10.1145/3651890.3672216 2024
[15]

2024.About Execution Environments

Google Cloud. 2024.About Execution Environments. Retrieved 2026-02-16 from https://cloud.google.com/run/docs/about-execution-environments

2024
[16]

2024.About Instance Autoscaling

Google Cloud. 2024.About Instance Autoscaling. Retrieved 2026-02-16 from https://cloud.google.com/run/docs/about-instance-autoscaling

2024
[17]

2024.Cloud Functions Locations

Google Cloud. 2024.Cloud Functions Locations. Retrieved 2026-02-16 from https://cloud.google.com/functions/docs/locations

2024
[18]

2024.Cloud Run Locations

Google Cloud. 2024.Cloud Run Locations. Retrieved 2026-02-16 from https: //cloud.google.com/run/docs/locations

2024
[19]

2024.Google Infrastructure Security Design Overview

Google Cloud. 2024.Google Infrastructure Security Design Overview. Retrieved 2026-02-16 from https://cloud.google.com/docs/security/infrastructure/design# google-frontend-service

2024
[20]

2024.Introducing Container Image Streaming in GKE

Google Cloud. 2024.Introducing Container Image Streaming in GKE. Re- trieved 2026-02-16 from https://cloud.google.com/blog/products/containers- kubernetes/introducing-container-image-streaming-in-gke?hl=en

2024
[21]

2024.Migrating a Knative serving service to Cloud Run

Google Cloud. 2024.Migrating a Knative serving service to Cloud Run. Retrieved 2026-02-16 from https://cloud.google.com/kubernetes-engine/ enterprise/knative-serving/docs/migrate/cloud-run

2024
[22]

2024.Start Containers Quickly

Google Cloud. 2024.Start Containers Quickly. Retrieved 2026-02-16 from https: //cloud.google.com/run/docs/tips/general#start_containers_quickly

2024
[23]

2024.Security Model

Cloudflare. 2024.Security Model. Retrieved 2026-02-16 from https://developers. cloudflare.com/workers/reference/security-model

2024
[24]

2024.Smart Placement

Cloudflare. 2024.Smart Placement. Retrieved 2026-02-16 from https:// developers.cloudflare.com/workers/configuration/smart-placement

2024
[25]

2025.Limits

Inc Cloudflare. 2025.Limits. Retrieved 2026-02-16 from https://developers. cloudflare.com/workers/platform/limits/#memory

2025
[26]

2020.Cloudflare Workers

Cloudflare, Inc. 2020.Cloudflare Workers. Retrieved 2026-02-16 from https: //workers.cloudflare.com/

2020
[27]

Marcin Copik, Grzegorz Kwasniewski, Maciej Besta, Michal Podstawski, and Torsten Hoefler. 2021. SeBS: a serverless benchmark suite for function-as-a- service computing. InProceedings of the 22nd International Middleware Con- ference. ACM, Québec city Canada, 64–78. https://doi.org/10.1145/3464298. 3476133

work page doi:10.1145/3464298 2021
[28]

Corbett, Jeffrey Dean, Michael Epstein, Andrew Fikes, Christopher Frost, J

James C. Corbett, Jeffrey Dean, Michael Epstein, Andrew Fikes, Christopher Frost, J. J. Furman, Sanjay Ghemawat, Andrey Gubarev, Christopher Heiser, Pe- ter Hochschild, Wilson Hsieh, Sebastian Kanthak, Eugene Kogan, Hongyi Li, Alexander Lloyd, Sergey Melnik, David Mwaura, David Nagle, Sean Quinlan, Rajesh Rao, Lindsay Rolig, Yasushi Saito, Michal Szymania...

work page doi:10.1145/2491245 2013
[29]

Lazar Cvetković, François Costa, Mihajlo Djokic, Michal Friedman, and Ana Klimovic. 2024. Dirigent: Lightweight Serverless Orchestration. InProceedings of the ACM SIGOPS 30th Symposium on Operating Systems Principles (SOSP ’24). Association for Computing Machinery, New York, NY, USA, 369–384. https: //doi.org/10.1145/3694715.3695966

work page doi:10.1145/3694715.3695966 2024
[30]

Lazar Cvetković, Rodrigo Fonseca, and Ana Klimovic. 2023. Understanding the Neglected Cost of Serverless Cluster Management. InProceedings of the 4th Workshop on Resource Disaggregation and Serverless. ACM, Koblenz Germany, 22–28. https://doi.org/10.1145/3605181.3626286

work page doi:10.1145/3605181.3626286 2023
[31]

2022.JavaScript Containers

Ryan Dahl. 2022.JavaScript Containers. Retrieved 2026-02-16 from https://web. archive.org/web/20241208235619/https://tinyclouds.org/javascript_containers/

work page arXiv 2022
[32]

2024.A WS Lambda Under the Hood

Mike Danilov. 2024.A WS Lambda Under the Hood. Retrieved 2026-02-16 from https://www.infoq.com/presentations/aws-lambda-arch/

2024
[33]

Ramzi Debab and Walid Khaled Hidouci. 2021. Containers Runtimes War: A Comparative Study. InProceedings of the Future Technologies Conference (FTC) 2020, Volume 2, Kohei Arai, Supriya Kapoor, and Rahul Bhatia (Eds.). Springer International Publishing, Cham, 135–161. https://doi.org/10.1007/978-3-030- 63089-8_9

work page doi:10.1007/978-3-030- 2021
[34]

2024.Deno Deploy Regions

Deno. 2024.Deno Deploy Regions. Retrieved 2026-02-16 from https://docs.deno. com/deploy/manual/regions/

2024
[35]

2024.How we built a secure, performant, multi-tenant cloud platform to run untrusted code

Deno. 2024.How we built a secure, performant, multi-tenant cloud platform to run untrusted code. Retrieved 2026-02-16 from https://deno.com/blog/build-secure- performant-cloud-platform

2024
[36]

2021.Deno Deploy

Deno Land, Inc. 2021.Deno Deploy. Retrieved 2026-02-16 from https://deno. com/deploy

2021
[37]

2026.denoland/deno

Deno Land, Inc. 2026.denoland/deno. Retrieved 2026-02-16 from https://github. com/denoland/deno

2026
[38]

Dong Du, Tianyi Yu, Yubin Xia, Binyu Zang, Guanglu Yan, Chenggang Qin, Qix- uan Wu, and Haibo Chen. 2020. Catalyzer: Sub-millisecond Startup for Server- less Computing with Initialization-less Booting. InProceedings of the Twenty- Fifth International Conference on Architectural Support for Programming Lan- guages and Operating Systems(Lausanne, Switzerlan...

work page doi:10.1145/3373376.3378512 2020
[39]

Simon Eismann, Diego Elias Costa, Lizhi Liao, Cor-Paul Bezemer, Weiyi Shang, André van Hoorn, and Samuel Kounev. 2022. A case study on the stability of performance tests for serverless applications.Journal of Systems and Software 189 (July 2022), 111294. https://doi.org/10.1016/j.jss.2022.111294

work page doi:10.1016/j.jss.2022.111294 2022
[40]

Simon Eismann, Joel Scheuner, Erwin Van Eyk, Maximilian Schwinger, Jo- hannes Grohmann, Nikolas Herbst, Cristina Abad, and Alexandru Iosup. 2021. The State of Serverless Applications: Collection, Characterization, and Com- munity Consensus.IEEE Transactions on Software Engineering(2021), 1–1. https://doi.org/10.1109/TSE.2021.3113940

work page doi:10.1109/tse.2021.3113940 2021
[41]

2024.Unofficial SDKs on the Compute platform

Fastly. 2024.Unofficial SDKs on the Compute platform. Retrieved 2026-02-16 from https://www.fastly.com/documentation/guides/compute

2024
[42]

2019.Edge Compute

Fastly, Inc. 2019.Edge Compute. Retrieved 2026-02-16 from https://www.fastly. com/products/edge-compute

2019
[43]

2020.Fly.io

Fly.io. 2020.Fly.io. Retrieved 2026-02-16 from https://fly.io/

2020
[44]

2022.Fly Machines: An API for Fast-Booting VMs

Fly.io. 2022.Fly Machines: An API for Fast-Booting VMs. Retrieved 2026-02-16 from https://fly.io/blog/fly-machines/

2022
[45]

2022.Reliability: It’s Not Great

Fly.io. 2022.Reliability: It’s Not Great. Retrieved 2026-02-16 from https: //community.fly.io/t/reliability-its-not-great/11253

2022
[46]

2023.Carving the Scheduler Out of Our Orchestrator

Fly.io. 2023.Carving the Scheduler Out of Our Orchestrator. Retrieved 2026-02-16 from https://fly.io/blog/carving-the-scheduler-out-of-our-orchestrator/

2023
[47]

2023.Docker Without Docker

Fly.io. 2023.Docker Without Docker. Retrieved 2026-02-16 from https://fly.io/ blog/docker-without-docker/

2023
[48]

2023.Global registry: now in production

Fly.io. 2023.Global registry: now in production. Retrieved 2026-02-16 from https://community.fly.io/t/global-registry-now-in-production/13723

2023
[49]

2024.Load Balancing

Fly.io. 2024.Load Balancing. Retrieved 2026-02-16 from https://fly.io/docs/ reference/load-balancing/

2024
[50]

2024.New feature in preview: suspend/resume for Machines

Fly.io. 2024.New feature in preview: suspend/resume for Machines. Retrieved 2026-02-16 from https://community.fly.io/t/new-feature-in-preview-suspend- resume-for-machines/20672

2024
[51]

2024.Regions Fly Documentation

Fly.io. 2024.Regions Fly Documentation. Retrieved 2026-02-16 from https://fly. io/docs/reference/regions/

2024
[52]

2026.CPU Performance

Fly.io. 2026.CPU Performance. Retrieved 2026-02-16 from https://fly.io/docs/ machines/cpu-performance/

2026
[53]

2026.Fly.io Infra Log

Fly.io. 2026.Fly.io Infra Log. Retrieved 2026-02-16 from https://fly.io/infra-log/

2026
[54]

2026.Fly.io Resource Pricing

Fly.io. 2026.Fly.io Resource Pricing. Retrieved 2026-02-16 from https://fly.io/ docs/about/pricing/

2026
[55]

2026.Framework launch scanners

Fly.io. 2026.Framework launch scanners. Retrieved 2026-02-16 from https://fly. io/docs/launch/create/#framework-launch-scanners

2026
[56]

2017.Google Cloud Run Functions

Google LLC. 2017.Google Cloud Run Functions. Retrieved 2026-02-16 from https://cloud.google.com/functions

2017
[57]

2024.gVisor

gVisor Authors. 2024.gVisor. Retrieved 2026-02-16 from https://gvisor.dev/

2024
[58]

Cloud programming sim- plified: A Berkeley view on serverless computing,

Eric Jonas, Johann Schleier-Smith, Vikram Sreekanti, Chia-Che Tsai, Anurag Khandelwal, Qifan Pu, Vaishaal Shankar, Joao Carreira, Karl Krauth, Neeraja Yadwadkar, Joseph E. Gonzalez, Raluca Ada Popa, Ion Stoica, and David A. Pat- terson. 2019. Cloud Programming Simplified: A Berkeley View on Serverless Computing.arXiv:1902.03383 [cs](2019). arXiv: 1902.03383

work page arXiv 2019
[59]

Abad, Alexandru Iosup, Ian Foster, Prashant Shenoy, Omer Rana, and Andrew A

Samuel Kounev, Nikolas Herbst, Cristina L. Abad, Alexandru Iosup, Ian Foster, Prashant Shenoy, Omer Rana, and Andrew A. Chien. 2023. Serverless Comput- ing: What It Is, and What It Is Not?Commun. ACM66, 9 (Sept. 2023), 80–92. https://doi.org/10.1145/3587249

work page doi:10.1145/3587249 2023
[60]

2024.Grafana Cloud services regional availability

Grafana Labs. 2024.Grafana Cloud services regional availability. Re- trieved 2026-02-16 from https://grafana.com/docs/grafana-cloud/account- management/regional-availability/

2024
[61]

Philipp Leitner, Erik Wittern, Josef Spillner, and Waldemar Hummer. 2019. A mixed-method empirical study of Function-as-a-Service software development in industrial practice.Journal of Systems and Software149 (March 2019), 340–

2019
[62]

https://doi.org/10.1016/j.jss.2018.12.013

work page doi:10.1016/j.jss.2018.12.013 2018
[63]

Kulkarni, K

Junfeng Li, Sameer G. Kulkarni, K. K. Ramakrishnan, and Dan Li. 2019. Under- standing Open Source Serverless Platforms: Design Considerations and Perfor- mance. InProceedings of the 5th International Workshop on Serverless Computing. ACM, Davis CA USA, 37–42. https://doi.org/10.1145/3366623.3368139 T. Schirmer et al

work page doi:10.1145/3366623.3368139 2019
[64]

Zijun Li, Linsong Guo, Jiagan Cheng, Quan Chen, Bingsheng He, and Minyi Guo. 2022. The Serverless Computing Survey: A Technical Primer for Design Architecture.Comput. Surveys54, 10s (Jan. 2022), 1–34. https://doi.org/10.1145/ 3508360

2022
[65]

Changyuan Lin, Gigi, Ma, and Mohammad Shahrad. 2025. Getting to the Bottom of Serverless Billing. arXiv:2506.01283 (June 2025). https://doi.org/10.48550/ arXiv.2506.01283 arXiv:2506.01283 [cs]

work page arXiv 2025
[66]

Changyuan Lin and Hamzeh Khazaei. 2021. Modeling and Optimization of Per- formance and Cost of Serverless Applications.IEEE Transactions on Parallel and Distributed Systems32, 3 (2021), 615–632. https://doi.org/10.1109/TPDS.2020. 3028841

work page doi:10.1109/tpds.2020 2021
[67]

Theo Lynn, Pierangelo Rosati, Arnaud Lejeune, and Vincent Emeakaroha. 2017. A Preliminary Review of Enterprise Serverless Cloud Computing (Function- as-a-Service) Platforms. In2017 IEEE International Conference on Cloud Com- puting Technology and Science (CloudCom). 162–169. https://doi.org/10.1109/ CloudCom.2017.15

2017
[68]

2022.Fly Machines: An API for Fast-Booting VMs

Kurt Mackey. 2022.Fly Machines: An API for Fast-Booting VMs. Retrieved 2026- 02-16 from https://fly.io/blog/fly-machines/

2022
[69]

Johannes Manner. 2023. A Structured Literature Review Approach to Define Serverless Computing and Function as a Service. In2023 IEEE 16th International Conference on Cloud Computing (CLOUD). 516–522. https://doi.org/10.1109/ CLOUD60044.2023.00068

work page arXiv 2023
[70]

2024.Intro to Serverless Functions

Netlify. 2024.Intro to Serverless Functions. Retrieved 2026-02-16 from https: //www.netlify.com/blog/intro-to-serverless-functions/

2024
[71]

2024.Functions

Oracle. 2024.Functions. Retrieved 2026-02-16 from https://docs.oracle.com/en- us/iaas/Content/Functions/home.htm

2024
[72]

2019.Oracle Cloud Infrastructure Functions

Oracle Corporation. 2019.Oracle Cloud Infrastructure Functions. Retrieved 2026- 02-16 from https://www.oracle.com/cloud/cloud-native/functions/

2019
[73]

Tobias Pfandzelter and David Bermbach. 2020. tinyFaaS: A Lightweight FaaS Platform for Edge Environments. InProceedings of the Second IEEE International Conference on Fog Computing(Sydney, NSW, Australia)(ICFC 2020). IEEE, New York, NY, USA, 17–24. https://doi.org/10.1109/ICFC49376.2020.00011

work page doi:10.1109/icfc49376.2020.00011 2020
[74]

2022.A Foolish Consistency: Consul at Fly.io

Thomas Ptacek. 2022.A Foolish Consistency: Consul at Fly.io. Retrieved 2026- 02-16 from https://fly.io/blog/a-foolish-consistency/

2022
[75]

2022.Our User-Mode WireGuard Year

Thomas Ptacek. 2022.Our User-Mode WireGuard Year. Retrieved 2026-02-16 from https://fly.io/blog/our-user-mode-wireguard-year/

2022
[76]

David K. Rensin. 2015.Kubernetes - Scheduling the Future at Cloud Scale. 1005 Gravenstein Highway North Sebastopol, CA 95472

2015
[77]

Trever Schirmer and David Bermbach. 2025. Towards a Testbed for Scalable FaaS Platforms. InProceedings of the 13th IEEE International Conference on Cloud Engineering(Rennes, France)(IC2E ’25). IEEE, New York, NY, USA, 71–72. https: //doi.org/10.1109/IC2E65552.2025.00017

work page doi:10.1109/ic2e65552.2025.00017 2025
[78]

Trever Schirmer, Nils Japke, Sofia Greten, Tobias Pfandzelter, and David Bermbach. 2023. The Night Shift: Understanding Performance Variability of Cloud Serverless Platforms. InProceedings of the 1st Workshop on SErverless Sys- tems, Applications and MEthodologies(Rome, Italy)(SESAME ’23). ACM, New York, NY, USA. https://doi.org/10.1145/3592533.3592808

work page doi:10.1145/3592533.3592808 2023
[79]

Larissa Schmid, Marcin Copik, Alexandru Calotoiu, Laurin Brandner, Anne Kozi- olek, and Torsten Hoefler. 2025. SeBS-Flow: Benchmarking Serverless Cloud Function Workflows. InProceedings of the Twentieth European Conference on Computer Systems. ACM, Rotterdam Netherlands, 902–920. https://doi.org/10. 1145/3689031.3717465

work page arXiv 2025
[80]

2024.A WS Lambda Runtimes

Amazon Web Services. 2024.A WS Lambda Runtimes. Retrieved 2026-02-16 from https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html

2024

Showing first 80 references.