openfaas.com

OpenFaaS runs on any Kubernetes cluster and turns your code into serverless functions packaged as portable OCI images. You deploy it to a cluster you already control — on-premises or in the cloud — and get a unified experience for shipping functions, scaling them with demand, and scaling to zero when idle. It fits teams that already run Kubernetes and want a FaaS layer without rebuilding autoscaling, queuing, retries, and event triggers from scratch.

What OpenFaaS adds on top of Kubernetes

Kubernetes gives you the building blocks, but wiring up auto-scaling, queuing, retries, and event triggers yourself takes months of work. OpenFaaS packages that into a usable layer:

• Deploy anywhere — run functions on-premises or in the cloud using portable OCI images, so the same artifact moves between environments.
• Any code — write functions in any language, and bring existing microservices along too.
• Any scale — scale functions to meet demand and down to zero when idle to save on costs.
• Templates that just work — get code into production within minutes using provided templates, or create your own.

The result is one unified experience: deploy OpenFaaS to any Kubernetes cluster, write a function, and ship it to production in minutes knowing it will scale.

How a function gets to production

1. Pick or build a template. Templates handle the packaging so you focus on code. Use a provided template for your language, or create your own.
2. Write the function. Any language is supported, and existing microservices can be brought along rather than rewritten.
3. Build and deploy. The function is packaged as an OCI image and deployed to your Kubernetes cluster.
4. Scale it. Functions can be fine-tuned to match the type of traffic they receive, including scaling to zero.

The expected outcome: code that runs on the same cluster you already operate, with scaling behavior you configure rather than build.

Where the Pro tier changes the picture

The core OpenFaaS experience is described as stable, portable, and built for production. OpenFaaS Pro adds capabilities that matter once you move past a basic deployment:

• Autoscaling
• Event connectors
• Monitoring dashboards
• SSO and RBAC
• Direct-to-engineering support

If you need single sign-on, role-based access control, or dashboards out of the box, that is a Pro consideration rather than a core one. Pricing and trial details live on the OpenFaaS pricing page — check there for current terms rather than assuming what is included.

Event-driven workloads

Functions can be invoked through events rather than only HTTP calls. Supported event sources include:

• Apache Kafka
• AWS SQS/SNS
• GCP Pub/Sub
• RabbitMQ
• PostgreSQL
• Cron
• MQTT

This matters for pipelines where work arrives asynchronously — for example, a batch job or ML model that runs as a function with built-in retries, whether it takes milliseconds or hours.

How teams actually use it

A sandbox for customer code. If you want customers to extend your product with custom code, running untrusted code safely is hard to get right. With OpenFaaS, code snippets become isolated functions built and deployed through a REST API, with each tenant in its own namespace and security boundaries enforced at every layer. This pattern is used in production by Waylay (IoT), LivePerson, Cognite (ML/data-science), and RudderStack.

ETL and data pipelines. When processing large volumes of data, managing infrastructure for parallel execution, retries, and scaling is a project in itself. OpenFaaS fans out to thousands of parallel function executions that scale automatically, with batch jobs and ML models running as functions with built-in retries.

Is it a fit for your cluster?

OpenFaaS is a reasonable choice if:

• You already run Kubernetes and want a FaaS capability without building the surrounding machinery.
• You need portability across on-premises and cloud via OCI images.
• You want functions that scale to zero to control cost.
• You need event-driven invocation from Kafka, queues, databases, cron, or MQTT.

Look at OpenFaaS Pro if you need SSO, RBAC, dashboards, or vendor engineering support as part of the deployment.

OpenFaaS is an open-source serverless platform that runs on Kubernetes, letting you deploy functions written in any language as portable OCI images. OpenFaaS Pro is the commercial edition that adds production-grade features on top of the same core: autoscaling, event connectors, monitoring dashboards, SSO, RBAC, and direct engineering support. Choose the open-source version if you're evaluating the model, running small or internal workloads, or building your own operational tooling. Choose Pro if you need those specific capabilities and commercial support for production systems.

The shared foundation

Both editions run on the same platform, so the core experience doesn't change when you move between them:

• Deploy to any Kubernetes cluster — on-premises or in the cloud, with the same unified workflow.
• Any language — write functions in whatever language you use, and bring existing microservices along too.
• Portable OCI images — functions are packaged as standard container images, so they aren't locked to a proprietary format.
• Templates — get code into production within minutes using provided templates, or create your own.
• Basic scaling — functions can scale to match traffic, including down to zero when idle to save on costs.

The website describes this as "serverless on your terms — stable, portable, built for production," and the open-source project has a substantial community (the site shows 31.1k GitHub stars).

What OpenFaaS Pro adds

The Pro edition layers commercial features onto that base. According to the site, OpenFaaS Pro adds:

These are the differences that matter most for production decisions: the event connectors turn OpenFaaS into an event-driven workload platform rather than just an HTTP function host, and SSO/RBAC matter as soon as more than a couple of people need access.

How to decide

Stay on open source if:

• You're learning the platform or running a proof of concept.
• Your workloads are small, internal, or you're comfortable wiring up your own scaling, queuing, retries, and event triggers.
• You don't need commercial support or enterprise access controls.

Move to Pro if:

• You need autoscaling tuned to your traffic patterns, or event-driven invocation from Kafka, SQS/SNS, Pub/Sub, RabbitMQ, PostgreSQL, Cron, or MQTT.
• You need SSO and RBAC for team or tenant access.
• You want monitoring dashboards and direct access to the engineering team when something breaks in production.

The site frames the trade-off directly: Kubernetes has the building blocks, but "wiring up auto-scaling, queuing, retries, and event triggers from scratch takes months of work." Pro is aimed at teams that would rather buy that work than build it.

Common production patterns

The site lists several ways teams use OpenFaaS, which can help you judge whether Pro's features are relevant to you:

• A sandbox for customer code — turn code snippets into isolated functions built and deployed through a REST API, with each tenant in its own namespace and security boundaries enforced at every layer. Used in production by Waylay (IoT), LivePerson, Cognite (ML/data science), and RudderStack.
• ETL and data pipelines — fan out to thousands of parallel function executions that scale automatically, with batch jobs and ML models running as functions with built-in retries, whether they take milliseconds or hours.
• Kubernetes made usable — avoid building auto-scaling, queuing, retries, and event triggers from scratch.

If your use case looks like the customer-code sandbox or large-scale parallel pipelines, the Pro features (RBAC, SSO, autoscaling, event connectors) are likely the ones you'd otherwise have to build yourself.

Pricing and trial

The site links to a pricing page and offers a "Request a free trial" option for OpenFaaS Pro. Pricing details and trial terms aren't specified in the available material — check the pricing page for current figures and conditions before committing.

OpenFaaS can trigger functions from Apache Kafka, AWS SQS/SNS, GCP Pub/Sub, RabbitMQ, PostgreSQL, Cron, and MQTT, and it is built for asynchronous work such as ETL and data pipelines, batch jobs, and ML model runs. The fit is strongest when you need fan-out to many parallel executions, automatic retries, and queue-based scaling — including down to zero when idle. If your workload is a simple synchronous HTTP request, you do not need the event connectors at all.

Supported event sources

The OpenFaaS event connectors let you invoke functions from the following systems:

Each connector subscribes to the source and invokes your function when a message or event arrives, so you write the function logic rather than the plumbing.

Workload patterns that fit

ETL and data pipelines

The site describes processing large volumes of data where managing parallel execution, retries, and scaling is "a project in itself." With OpenFaaS you fan out to thousands of parallel function executions that scale automatically, and batch jobs run as functions with built-in retries — whether they take milliseconds or hours.

Batch and ML model runs

Long-running jobs are supported: functions can run for milliseconds or hours, with retries handled for you. This suits batch processing and ML model execution where a single run may be slow but many runs happen at once.

Multi-tenant code execution

If you want customers to extend your product with custom code, OpenFaaS turns code snippets into isolated functions built and deployed through a REST API. Each tenant runs in its own namespace with security boundaries enforced at every layer. The site names Waylay (IoT), LivePerson, Cognite (ML/data science), and RudderStack as production users.

Queue-based scaling

Surge is cited as running async jobs at scale — importing financial and government data to power background checks through Salesforce. This is the pattern to look at when you have a backlog of async jobs that must drain reliably.

What makes it work

• Scale to zero when idle. Functions scale down when there is no traffic, which matters for cost on bursty event workloads.
• Scale to meet demand. Pro features add autoscaling so parallel executions keep up with the event rate.
• Built-in retries. Async jobs are retried rather than silently dropped.
• Portable OCI images. Functions deploy on-premises or in the cloud with the same unified experience on any Kubernetes cluster.

Choosing between the free project and Pro

The event connectors and the core function model are the reason to use OpenFaaS for event-driven work. OpenFaaS Pro adds autoscaling, event connectors, monitoring dashboards, SSO, RBAC, and direct-to-engineering support. If you are running event-driven workloads in production and need autoscaling plus commercial support, evaluate Pro; the pricing page offers a free trial request. For a small internal pipeline, the open-source project may be enough — but confirm which connectors and scaling features you actually need before deciding.

When this is not the right fit

If your work is request/response with no queue, no schedule, and no event source, a plain HTTP function is simpler and the connectors add nothing. Event-driven OpenFaaS pays off when you have at least one of: a message broker or database feeding work in, a schedule, or a large fan-out of async jobs that must retry and scale.

OpenFaaS is a serverless platform that runs on Kubernetes and deploys functions as portable OCI images, on-premises or in the cloud. Teams typically adopt it for three recurring jobs: letting customers run custom code inside a product, running ETL and data pipelines at scale, and making Kubernetes usable without building autoscaling, queuing, and event triggers from scratch. If your workload fits one of those shapes, the fastest way to judge fit is to deploy it to a Kubernetes cluster, ship a function, and then evaluate OpenFaaS Pro against your scaling, event, and access-control requirements.

Use case 1: A sandbox for your customer's code

The problem: you want customers to extend your product with custom code, but running untrusted code safely is hard to get right.

How OpenFaaS is used here: code snippets become isolated functions, built and deployed through a REST API. Each tenant runs in its own namespace, with security boundaries enforced at every layer. The site cites production use by Waylay (IoT), LivePerson, Cognite (ML/data science), and RudderStack.

This is the pattern to pick if your product needs a "bring your own code" extension point and you care more about tenant isolation than about raw execution speed. Two concrete entry points the site names:

• Add a FaaS capability to your product
• Build a function editor for your customers

Use case 2: ETL and data pipelines

The problem: you're processing large volumes of data, and managing infrastructure for parallel execution, retries, and scaling is a project in itself.

How OpenFaaS is used here: fan out to thousands of parallel function executions that scale automatically. Batch jobs and ML models run as functions with built-in retries, whether they take milliseconds or hours. The site cites Surge, which runs async jobs at scale — importing financial and government data to power background checks for customers through Salesforce.

Choose this pattern when your jobs are bursty, long-running, or need retries without you writing the orchestration layer. The relevant starting point is queue-based scaling with OpenFaaS.

Use case 3: Kubernetes, made usable

The problem: Kubernetes has the building blocks, but wiring up auto-scaling, queuing, retries, and event triggers from scratch takes months of work.

How OpenFaaS is used here: you deploy to any Kubernetes cluster and get a unified experience for running code, with functions scaling to meet demand and down to zero when idle. Templates get code into production within minutes, and you can write functions in any language while bringing existing microservices along.

This is the right framing if your team already runs Kubernetes and wants serverless behavior without assembling the control plane yourself.

What event-driven workloads can it handle?

Functions can be invoked through events from Apache Kafka, AWS SQS/SNS, GCP Pub/Sub, RabbitMQ, PostgreSQL, Cron, and MQTT. If your pipeline is triggered by one of those sources, you don't need to build a custom poller — the event connector is the integration point.

OpenFaaS vs OpenFaaS Pro

The open-source project gives you the core deploy-and-run model. OpenFaaS Pro adds the operational features that usually decide a production rollout:

Use the table as a checklist, not a verdict: if you only need to run functions on Kubernetes and can handle scaling and access control yourself, the open-source path may be enough. If you need autoscaling, event connectors, dashboards, SSO, or RBAC, those are the specific gaps Pro fills.

How to try it

1. Confirm the prerequisite: a Kubernetes cluster. OpenFaaS deploys to any Kubernetes cluster, on-premises or in the cloud.
2. Deploy OpenFaaS to that cluster and write a new function. The site's claim to verify against your own setup is that you can ship it to production in minutes and it will scale to meet demand.
3. Start from a template rather than a blank function — templates are described as working out of the box, and you can create your own.
4. Test the scaling behavior that matters to you: scale to match your traffic type, including down to zero when idle to save on costs.
5. Evaluate OpenFaaS Pro if steps 2–4 surface gaps in autoscaling, event connectors, monitoring, SSO, or RBAC. The site offers a free trial request for Pro; pricing details are on the pricing page, and the trial terms are not specified there, so confirm scope and duration with the vendor.

Choosing between the three patterns

• Customer-facing extension point → prioritize namespace isolation and a REST API for build/deploy.
• ETL and batch → prioritize parallel fan-out, retries, and queue-based scaling.
• Kubernetes simplification → prioritize templates, scale-to-zero, and the event sources you already run.

If none of these match how your team ships code, the platform is likely a poor fit regardless of feature list.

OpenFaaS is a platform for running serverless functions on Kubernetes. It lets you package code as portable OCI images, deploy it to any Kubernetes cluster, and have it scale automatically — including down to zero when idle. It supports any programming language and can also host existing microservices alongside functions. There is an open-source edition and a commercial edition, OpenFaaS Pro, which adds autoscaling, event connectors, monitoring dashboards, SSO, RBAC, and direct engineering support.

The core idea

OpenFaaS turns code into functions that run as containers on Kubernetes. You write a function in whatever language you prefer, build it into an OCI image, and deploy it. The platform handles the rest: routing, scaling, and lifecycle.

The tagline on the site is "Serverless Functions, Made Simple," with the positioning "Serverless on your terms — stable, portable, built for production."

What it does

Anywhere

Functions deploy on-premises or in the cloud using portable OCI images. The same unified experience applies to any Kubernetes cluster, so you are not locked into a single provider.

Any code

You can write functions in any language, and bring existing microservices along too. This matters if you have services that are not functions but still need to run in the same environment.

Any scale

Pro features scale functions to meet demand and down to zero when idle. Scaling to zero is the cost-saving mechanism: when there is no traffic, there are no running instances.

Key capabilities

How teams use it

The site describes three common patterns:

A sandbox for customer code. If you want customers to extend your product with custom code, OpenFaaS turns code snippets into isolated functions built and deployed through a REST API. Each tenant runs in its own namespace with security boundaries enforced at every layer. The site cites Waylay (IoT), LivePerson, Cognite (ML/data-science), and RudderStack as production users.

ETL and data pipelines. For large volumes of data, OpenFaaS fans out to thousands of parallel function executions that scale automatically. Batch jobs and ML models run as functions with built-in retries, whether they take milliseconds or hours. Surge is cited as running async jobs at scale for background checks.

Kubernetes, made usable. Kubernetes has the building blocks, but wiring up auto-scaling, queuing, retries, and event triggers from scratch takes months. OpenFaaS packages these so you do not build them yourself.

Open source vs. OpenFaaS Pro

The open-source edition gives you the core function platform. OpenFaaS Pro adds autoscaling, event connectors, monitoring dashboards, SSO, RBAC, and direct-to-engineering support. The site links to a pricing page and a free trial request, so commercial terms are available there rather than stated on the homepage.

When to look further

OpenFaaS is worth investigating if you already run Kubernetes and want to add function deployment without building the scaling, queuing, and event-triggering layer yourself. It is also a fit if you need to run untrusted or customer-supplied code in isolation, or if you want event-driven workloads triggered by Kafka, SQS/SNS, Pub/Sub, RabbitMQ, PostgreSQL, Cron, or MQTT.

If you are not on Kubernetes, or you need a fully managed serverless platform with no cluster to operate, this is a different category of tool.