On November 13, 2014, AWS announced a compute service that ran code without anyone provisioning a server. That moment gave the industry its clearest working example of Function as a Service (FaaS) — a cloud model where developers deploy individual functions, the provider runs them on demand, scales them automatically, and bills per invocation and execution time. Nearly a decade later, the definition still trips people up, because vendors, academics, and job postings each shade it slightly differently.
This article pins down what FaaS actually means, how it differs from neighboring ideas like serverless and containers, where the term came from, and what to watch for when you adopt it. If you have ever wondered whether your Lambda function, your Cloud Run service, or your Knative cluster really counts as FaaS, the answer is usually “it depends on which of four criteria you count.”
The core definition, stripped to essentials
At its heart, FaaS is an execution model with a small set of defining traits. A developer writes a function — a discrete piece of logic triggered by an event — and hands it to a platform. The platform decides where it runs, how many copies exist at any moment, and when to shut them down. The developer never sees a virtual machine, never patches an operating system, and never picks an instance size.
Four properties show up in almost every serious definition:
- Event-driven execution. Functions fire in response to something: an HTTP request, a file upload, a queue message, a scheduled timer.
- Provider-managed scaling. Scaling happens automatically, often from zero instances to thousands and back again.
- Per-invocation billing. You pay for execution time and request counts rather than for idle capacity.
- No server management. Infrastructure concerns are abstracted away entirely, though not eliminated.
Where sources disagree is on how strict those criteria must be. Some definitions insist that true FaaS requires statelessness — each invocation starts fresh with no memory of the last. Others treat any managed function runtime as FaaS, even if it keeps warm instances alive between calls. That ambiguity is not a flaw in your understanding; it is a genuine gap in the industry’s vocabulary.
Where the term came from and why it matters
The phrase “Function as a Service” is widely attributed to a 2014 blog post by Mike Roberts of Symphonia titled “Serverless Architectures,” later revised and hosted alongside Martin Fowler’s writing. The exact original publication date is hard to pin down, so treat the attribution as common but not airtight.
What is well established is the commercial timeline. AWS Lambda was announced at re:Invent on November 13, 2014, and reached general availability in April 2015. Microsoft Azure Functions and Google’s function offering followed, and IBM built its service on the open-source Apache OpenWhisk project. The naming has churned since — Google has folded its function product into Cloud Run functions, and IBM’s offering has changed status more than once — so always check current product names before you write an architecture document.
Here is the awkward part: there is no ISO or NIST standard that normatively defines FaaS. The most-cited cloud definition, NIST SP 800-145 from September 2011, predates the term entirely and covers only IaaS, PaaS, and SaaS. FaaS is generally treated as a refinement of PaaS or as a component of the broader serverless category. That means any claim about an “official definition” should be attributed to a specific vendor or paper, not to a standards body.
FaaS versus serverless versus containers
The single most common mistake is using serverless and FaaS as synonyms. They are not. Serverless is the umbrella term covering FaaS plus managed backend services — object storage, message queues, databases, identity. FaaS is one subset of that umbrella.
| Model | What you manage | Scaling | Billing | Typical use |
|---|---|---|---|---|
| FaaS | Function code and config | Automatic, often to zero | Per invocation and duration | Event handlers, APIs, glue logic |
| Containers (CaaS) | Image, runtime, some orchestration | Manual or autoscaled | Per node or per pod-hour | Long-running services, custom runtimes |
| PaaS | App code and dependencies | Platform-managed | Per instance or dyno | Web apps with steady traffic |
| IaaS | OS, runtime, everything above | You configure it | Per VM-hour | Full control workloads |
A useful rule of thumb: if you are paying for idle time, it is not FaaS. If you are patching a kernel, it is definitely not FaaS.
How FaaS behaves in practice
The theoretical definition is tidy. Real deployments are messier, and the gap between the two is where teams get burned.
Cold starts are real. When a function has not run recently, the platform must spin up a fresh execution environment. That delay can range from milliseconds to several seconds depending on runtime, memory settings, and whether dependencies are large. A Java function with a heavy framework can feel sluggish next to a lean Node.js handler. Practical fixes include keeping packages small, avoiding unnecessary initialization work outside the handler, and using provisioned concurrency where the provider offers it.
Statelessness is a design constraint, not a suggestion. Because any invocation might land on a fresh environment, anything you need to remember must live in an external store. Teams that treat a global variable as a cache often discover, painfully, that it vanishes. The same applies to database connections: opening a new connection on every invocation exhausts pool limits fast. Connection pooling services and reusing clients outside the handler body are the standard remedies.
Timeouts and payload limits bite quietly. Every FaaS platform caps execution duration and request size. Workloads that fit comfortably in a container may simply not fit. Batch jobs, long video transcodes, and heavy machine-learning inference are usually better served elsewhere.
Observability gets harder, not easier. Distributed functions mean distributed logs. Without structured logging and tracing from day one, debugging a failure that spans five functions becomes an afternoon lost. Instrument early.
Local development is imperfect. Emulators approximate the runtime but rarely match it exactly. The teams that struggle least are the ones that deploy to a real staging environment early and often rather than trusting a local simulation.
If you are also wrestling with background processes on the machines your developers use, the same principle applies: know what is actually running. A guide on what an antimalware service executable is explains one such process, and there is a separate walkthrough on how to fix antimalware service executable high CPU usage when it misbehaves. (Function as a service)
The statelessness debate, explained
Academic surveys of serverless computing published roughly between 2018 and 2021 typically define FaaS as event-driven, stateless-by-default execution with provider-managed scaling. That “by default” is doing a lot of work. In practice, many platforms keep environments warm and reuse them, so state can persist — you just cannot rely on it.
This creates a definitional fork. The strict reading says a platform is only FaaS if invocations are genuinely isolated. The loose reading says any managed function runtime qualifies. Neither is wrong; they answer different questions. If you are evaluating vendors, the loose definition is more useful. If you are designing for correctness, the strict one is safer.
Where FaaS fits well, and where it does not
FaaS shines in specific shapes of work. API backends with spiky or unpredictable traffic benefit enormously, because you pay nothing when nobody calls. Event processing — resizing an image the moment it lands in storage, fanning out a queue message, reacting to a database change — is close to ideal. Scheduled jobs and lightweight glue between services are also natural fits.
It fits poorly when latency must be rock-steady, when execution runs long, when workloads are CPU-heavy and continuous, or when the team needs deep control over the runtime. Container platforms remain the better answer there.
Cost deserves a skeptical eye too. Per-invocation billing looks cheap until high-volume, long-running functions quietly outspend a small always-on instance. Model your actual traffic pattern before committing. The same discipline applies to any subscription decision — whether you are sizing cloud spend or comparing options at a Range Rover dealer near me, the total cost of ownership beats the headline number every time.
Open-source options and vendor lock-in
Apache OpenWhisk, an Apache Software Foundation project, and Knative, a Kubernetes-based platform, are the most commonly cited open-source routes to FaaS-style execution. Both let you run function workloads on infrastructure you control, which matters if regulatory or data-residency rules prevent a fully managed service.
Lock-in is the perennial worry. Function code itself is usually portable; the surrounding bindings are not. Event sources, identity integration, and deployment tooling are where migration costs hide. Teams that keep business logic in plain functions with thin provider-specific wrappers migrate far more easily than those that lean on proprietary features throughout.
A short checklist before you adopt
- Confirm your workload’s maximum runtime fits within platform limits.
- Measure cold-start impact against your latency budget.
- Design every function to be stateless from the first commit.
- Add structured logging and tracing before launch, not after.
- Model cost at realistic volume, including egress and invocation counts.
- Keep provider-specific code isolated behind a thin interface.
Practical experience across teams tends to converge on one lesson: FaaS rewards small, single-purpose functions and punishes anything that tries to be a mini-application. The teams that succeed treat the constraint as a design guide rather than an obstacle. The same holds for tooling decisions generally — whether you are choosing a best VPN service for remote engineers or picking a runtime, fitness for purpose beats feature count.
Conclusion
Function as a Service describes a cloud execution model where individual functions run on demand, scale automatically, and bill per invocation — with no server management by the developer. The definition is stable in its core and fuzzy at the edges, largely because no standards body has ever codified it and vendors keep reshaping their products. Treat FaaS as a subset of serverless, hold it to the four criteria of event-driven execution, managed scaling, per-invocation billing, and zero server administration, and you will rarely go wrong. The model rewards disciplined, stateless, single-purpose code. It punishes anything that assumes a warm machine will always be waiting.
Frequently asked questions
What is Function as a Service in simple terms?
It is a cloud model where you upload a single function and the provider runs it only when triggered, scaling automatically and charging only for the time it executes. You never provision or manage a server.
Is FaaS the same thing as serverless?
No. Serverless is the broader category that includes FaaS plus managed storage, queues, databases, and other backend services. FaaS is one piece of the serverless puzzle.
Does FaaS always require stateless functions?
Most definitions say stateless by default, meaning each invocation should assume no memory of the previous one. Platforms often reuse warm environments, but relying on that persistence is unsafe and a common source of bugs.
What is a cold start in FaaS?
A cold start is the extra delay when a platform must create a fresh execution environment because no warm instance is available. It can range from milliseconds to several seconds and depends on runtime, package size, and memory configuration.
Which companies offer FaaS platforms?
AWS Lambda, Microsoft Azure Functions, and Google’s function offering (now part of Cloud Run functions) are the most widely used managed services. Apache OpenWhisk and Knative provide open-source alternatives.
When should a team avoid FaaS?
Avoid it for long-running jobs, steady high-throughput workloads where per-invocation billing costs more than a small instance, latency-critical paths that cannot tolerate cold starts, or anything requiring deep runtime control.
