FaaS: Functions as a Service

• Functions as a Service (FaaS) is an event-driven cloud computing model characterized by stateless function execution, automatic scaling, and granular invocation based on external triggers.
• FaaS platforms, such as AWS Lambda and Google Cloud Functions, employ in-process, external, and sandboxed execution modalities to balance performance, isolation, and language support.
• FaaS enhances resource efficiency and application agility through innovative state management, integration across edge, fog, and cloud environments, and advanced scheduling techniques.

Function-as-a-Service (FaaS) is an event-driven cloud computing model in which individual, stateless functions are executed in response to external triggers, with underlying resource management and scaling performed automatically by the FaaS platform. FaaS is an architectural cornerstone of the broader serverless computing paradigm and has become integral to the design of modern distributed, scalable, and modular applications. The FaaS programming model is characterized by the deployment of language-level functions as microservices, with typical invocations being triggered by HTTP(S) requests, message queues, file changes, or scheduled events. Unlike traditional monolithic or even microservices approaches, FaaS brings execution granularity to the function level and abstracts away explicit server provisioning, maintenance, and capacity planning.

1. Architectural Design Principles and Modalities

The core principles underlying FaaS revolve around stateless execution, isolated runtime environments, dynamic scaling, and billing based on actual computational resource usage. Canonical commercial systems such as AWS Lambda, Google Cloud Functions, and Azure Functions typify these attributes, but noteworthy open-source implementations and research prototypes also address a spectrum of requirements and operational contexts.

Execution modalities in FaaS may be divided as follows:

• In-Process Execution: Native functions (e.g., Python 3 in Snafu) are executed directly within the host process, minimizing invocation overhead and maximizing performance.
• External (Out-of-Process) Execution: Functions can be run in separate interpreter processes (e.g., supporting Python 2 via 2to3 translation, or invoking Java methods using external shells), ensuring broader language compatibility and enhanced isolation.
• Sandboxing Mechanisms: Container-based virtualization (Docker, Kubernetes), microVMs (Firecracker), and lightweight high-level runtimes (WebAssembly/Wasm) are commonly employed to enforce process isolation, resource limits, and security. The trade-off between startup latency and isolation level is platform-dependent; for example, Docker-based sandboxes may incur over 78% overhead for strong security, whereas lightweight options such as Greengrass containers in AWS IoT offer lower (3.8–4.2%) runtime overhead at the expense of weaker isolation (Jin et al., 2023).
• Scheduling and Orchestration: FaaS platforms manage automatic scaling and load balancing, with advanced schedulers employing knowledge of function composition, environment warming, and execution affinity (e.g., container warming-aware routing in funcX (Li et al., 2022), affinity-aware policies in aAPP (Palma et al., 19 Jul 2024)).

The architecture is modular, with controller components (for management, scheduling, and authentication) distinct from worker or execution endpoints, as exemplified by funcX’s separation of cloud-hosted management and distributed execution agents (Li et al., 2022).

2. Programming Model and Trigger Mechanisms

FaaS systems offer a range of trigger interfaces and programming abstractions:

• Single-Event Triggers: Traditional FaaS invocations are associated with a single event (HTTP request, file update, message) per function invocation. This model is simple but may induce inefficiency when complex event aggregations are required, as functions must then implement custom state management and filtering (Carl et al., 27 May 2025).
• Multi-Event Triggers: Recent research introduces multi-event triggers (METs), enabling specification of complex function invocation rules over collections or combinations of events. Rules can use logical constructs (AND, OR) and counts (e.g., every 6th temperature reading AND every 6th wind event) expressed as:

  <rule> ::= <count>:<type> | <condition>(<rule>,<rule>) <condition> ::= AND | OR

  This abstraction allows the FaaS runtime to buffer events and invoke functions only when full trigger conditions are met, reducing the number of redundant (state update) invocations, system latency, and resource usage (Carl et al., 27 May 2025).
• Advanced Orchestration and Contextual Triggers: In fog and edge computing contexts, triggers may derive from data-centric or system-centric contexts (e.g., Fog Function model), integrating events with data management and enabling content-based discovery and orchestration (Cheng et al., 2019).

3. Performance, Efficiency, and Scheduling

Analysis of FaaS runtime efficiency reveals substantial design space in execution strategy, state management, and scheduling:

• Execution Performance: In-process execution modes (as in Snafu) can yield calls per second (cps) rates up to 377% higher than AWS Lambda, especially when avoiding features such as isolation, logging, and authentication (Spillner, 2017). Performance degrades with increased isolation but remains competitive.
• Economic Efficiency: The utility metric $$\text{Utility} = \frac{\text{cpm}}{\text{ppm} \times 10^6}$$, where cpm = calls per month and ppm = price per month, quantifies cost-performance trade-offs. Snafu’s unauthenticated in-process mode achieved a utility of 40.39 compared to Lambda’s 5.02 in high-frequency workloads (Spillner, 2017).
• Latency and Cold Starts: Container cold start latency is a notable challenge, particularly on HPC systems or resource-limited edge devices. Techniques such as container warming, executor-side batching, and dependency-aware prefetching of execution environments demonstrably reduce response latency (Li et al., 2022, Zuk et al., 2020). For example, funcX’s container warming-aware routing reduces completion time for 3,000 functions by up to 61% (Li et al., 2022).
• Resource-Aware and Affinity Scheduling: Advanced scheduling can leverage function composition, affinity, and knowledge of resource locality. The aAPP language provides declarative affinity/anti-affinity constraints to ensure co-location or avoidance of function assignments, yielding reduced latency and contention (Palma et al., 19 Jul 2024). Dependency-aware scheduling heuristics reduce average response latency by up to 2$\times$, especially when setup times are non-trivial (Zuk et al., 2020).

4. State Management and Data Integration

The statelessness of conventional FaaS represents both a strength and a limitation. Numerous edge, IoT, and data-centric applications demand efficient state handling:

• External State Services: In classic models, persistent state is maintained in external storage systems (databases, object stores). This simplifies stateless scaling but increases latency and outbound traffic, especially at the edge (Puliafito et al., 2021, Cicconetti et al., 2022).
• Stateful FaaS Patterns: Several models generalize FaaS to support persistent or session state:
  • Dual-Mode Execution: Functions alternate between remote-state (shared, stateless containers synchronizing state externally) and local-state (dedicated containers with persistent memory), dynamically trading off resource usage and latency (Puliafito et al., 2021).
  • Integrated KV Store Replication: Enoki directly integrates a replicated key-value store at each FaaS node, providing transparent, low-latency state access and consistency across the edge-cloud continuum (Pfandzelter et al., 2023). Microbenchmarks show a local read/write operation reduces per-function latency by ~200ms compared to cloud-based storage for multiple state operations.
  • Client-Carried State (In-Client Model): The function’s state is piggybacked by the client in each invocation, maintaining statelessness at the FaaS layer but enabling continuity and multi-tenancy (Cicconetti et al., 2022).
  • DBMS-Integrated FaaS: Apiary compiles functions to DBMS stored procedures, co-locating data and logic to eliminate inter-component communication overhead and support transactional semantics (ACID, serializability, exactly-once execution) (Kraft et al., 2022).

The table below summarizes stateful FaaS execution models:

Model	State Location	Latency	Complexity
External	Cloud DB	High	Low (stateless)
In-Edge	Edge Node	Medium	Data distrib. agent
In-Function	Func. Cntr.	Low	Container mgmt/migr.
In-Client	Client	Low	Increased net. load

• Implications: Local-state and integrated KV approaches substantially reduce tail latencies and are critical for applications such as real-time ML for autonomous vehicles and factories (Puliafito et al., 2021, Pfandzelter et al., 2023).

5. Edge, Fog, and Heterogeneous Environments

FaaS models have been extended to encompass edge, fog, and heterogeneous multi-cloud deployments:

• Fog Function Model: Introduces data-centric triggers and context-driven orchestration (system, data, usage), supporting dynamic service composition and migration across IoT/fog/cloud tiers; performance evaluations show a 95% reduction in data traffic over centralized cloud FaaS and latency improvements up to 30% over edge-only deployments (Cheng et al., 2019).
• Edge FaaS Frameworks: Platforms such as EdgeFaaS and FunLess virtualize heterogeneous resources (IoT, edge, cloud), providing flexible function and storage management, privacy-oriented scheduling, and deployment without resource-heavy orchestrators (Jin et al., 2022, Palma et al., 31 May 2024). FunLess uniquely supports fully functional FaaS deployment on resource-constrained devices (e.g., Raspberry Pi 3B+), leveraging a Wasm-based runtime for minimal footprint and rapid cold starts.
• Decentralized FaaS: DeFaaS employs blockchain-based management and decentralized API gateways across federated cloud backends, facilitating discovery, invocation, and load balancing without vendor lock-in or single-point-of-failure risks; smart contracts manage API permissioning and dual-token OAuth2.0 authentication (Karanjai et al., 11 Apr 2024).
• Function Delivery Networks: FDNs generalize FaaS scheduling across heterogeneous clusters (HPC, cloud, edge), incorporating energy efficiency and SLO constraints into global orchestration; for example, shifting function scheduling to edge targets reduced energy usage by 17$\times$ versus high-end platforms (Jindal et al., 2021).

6. Practical Applications, Challenges, and Evaluation

Extensive evaluation and use-case-driven analysis are critical to advancing FaaS:

• Scientific and Data-Intensive Workflows: Platforms like funcX underpin serverless supercomputing, decomposing scientific workflows into portable Python functions that are reassembled, scheduled, and executed on clouds, clusters, or supercomputers (Chard et al., 2019). Applications range from online metadata extraction, machine learning inference, high-throughput imaging, to real-time experiment steering.
• Industrial IoT and Federated Learning: Workflow pipelines in edge FaaS frameworks automate sensor-driven analytics (e.g., distributed video analysis, collaborative federated learning) while optimizing data locality and privacy constraints (Jin et al., 2022).
• Event Processing and Workflow Optimization: The introduction of multi-event triggers for FaaS significantly reduces the event-to-invocation latency (by 62.5%) and supports extreme throughput (>300,000 req/s per node) in incident detection and similar applications, outperforming manual state tracking (Carl et al., 27 May 2025).
• Benchmarks and Performance Metrics: Key metrics in FaaS evaluation include calls per second (cps), average/percentile response latency ($P_{90}$), throughput in requests per second, cold start time, and cost/performance utility (see formulas in (Spillner, 2017, Li et al., 2022, Carl et al., 27 May 2025)).

7. Technical Innovations and Future Directions

Modern FaaS research advances the state-of-the-art on several fronts:

• Lightweight Isolation and Pay-As-You-Use Models: Adoption of WebAssembly and other lightweight runtimes reduces cold start times by up to 10$\times$ and enables fine-grained billing per CPU cycle (Long et al., 2020). FunLess’s design validates production-level FaaS on edge devices unattainable by container-centric approaches (Palma et al., 31 May 2024).
• Declarative Policy and Affinity Languages: The emergence of domain-specific declarative languages (aAPP) for specifying per-function scheduling, resource, and affinity/anti-affinity policies offers granular control and measurable performance improvement in complex compositions (Palma et al., 19 Jul 2024).
• Integrated Security and Accountability: S-FaaS uses Intel SGX enclaves to guarantee computation correctness, resource accountability, and secure attestation down to sub-second and fine-grained memory usage, with less than 6.3% overhead (Alder et al., 2018).
• Stateful FaaS and Direct Data Integration: The tight coupling of function execution and data management (as with Apiary’s in-DBMS functions or Enoki’s local replica-driven stores) offers strong transactional guarantees and significant throughput gains (2–68$\times$ in microservice benchmarks) (Kraft et al., 2022, Pfandzelter et al., 2023).

Future research directions include automating dynamic container management, extending affinity scheduling to multi-controller deployments, integrating decentralized and federated resource pools (volunteer, edge, multi-cloud), and enhancing standardized orchestration and debugging across heterogeneous infrastructures (Chard et al., 2019, Karanjai et al., 11 Apr 2024, Palma et al., 19 Jul 2024).

---

FaaS represents a foundational paradigm in modern distributed systems, characterized by fine-grained abstraction, high elasticity, modularity, extensive language and runtime diversity, and a rapidly evolving research and deployment landscape encompassing cloud, edge, and scientific domains. The breadth of architectural, scheduling, data, and state integration techniques continues to expand, moving FaaS closer to the requirements of latency-sensitive, data-intensive, and resilient next-generation applications.