Deploy invincible backends

What is Golem

Golem is an open source serverless computing platform that orchestrates and executes any software packaged into WebAssembly components.

Golem’s transparent durable execution ensures that components execute reliably, even in the presence of faults, restarts, updates, and transient failures.

Golem lets you build and deploy reliable distributed systems with simple code.

Example Use Cases

Durable computing guarantees your business logic executes completely, even in the presence of updates and infrastructure failures.

From workflows to process automation and microservice orchestration, Golem gives you effortless and flawless reliability.

Traditional serverless can’t be used to implement a checkout API, because implementing checkout requires coordinating state changes across many different systems, and this coordination must happen in a reliable way.

With Golem, implementing checkout is as simple as writing ordinary code with libraries you already know and love.

Golem will execute the checkout logic reliably, even in the presence of faults, restarts, updates, and transient failures, like cloud flakiness.


async function checkout(user, cart,paymentDetails, shippingAddress) { 
    try { 
        if (!(await checkAndReserveInventory(cart))) { 
            throw new Error("Inventory issue"); 
        }

        if (!user.isAuthenticated) { 
            await authenticateUser(user); 
        }

        const paymentInfo = paymentDetails || 
            (await getPaymentInformation(user));

        if (!(await processPayment(paymentInfo, cart.totalAmount))) {
            throw new Error("Payment issue");
        }

        const shippingDetails = 
            await generateShippingLabelAndTracking(shippingAddress, cart); 

        if (!(await dispatchOrderForFulfillment(cart, shippingDetails))) {
            throw new Error("Fulfillment issue");
        }

        await Promise.all([
            sendConfirmationEmail(user.email, cart, shippingDetails), 
            updateInventory(cart) 
        ]);

        return { success: true, message: "Checkout successful" }; 
    } catch (error) {
        console.error("Checkout failed:", error); // Rollback logic could be added here
    return { success: false, message: error.message }; 
    }
}

Traditional serverless can’t be used to implement a checkout API, because implementing checkout requires orchestrating state changes across many different systems, and this orchestration must happen in a reliable way.

With Golem, implementing checkout is as simple as writing ordinary code with libraries you already know and love.

Golem will execute the checkout logic reliably, even in the presence of faults, software updates, and cloud flakiness.


async function checkout(user, cart,paymentDetails, shippingAddress) { 
    try { 
        if (!(await checkAndReserveInventory(cart))) { 
            throw new Error("Inventory issue"); 
        }

        if (!user.isAuthenticated) { 
            await authenticateUser(user); 
        }

        const paymentInfo = paymentDetails || 
            (await getPaymentInformation(user));

        if (!(await processPayment(paymentInfo, cart.totalAmount))) {
            throw new Error("Payment issue");
        }

        const shippingDetails = 
            await generateShippingLabelAndTracking(shippingAddress, cart); 

        if (!(await dispatchOrderForFulfillment(cart, shippingDetails))) {
            throw new Error("Fulfillment issue");
        }

        await Promise.all([
            sendConfirmationEmail(user.email, cart, shippingDetails), 
            updateInventory(cart) 
        ]);

        return { success: true, message: "Checkout successful" }; 
    } catch (error) {
        console.error("Checkout failed:", error); // Rollback logic could be added here
    return { success: false, message: error.message }; 
    }
}

Traditional serverless can’t be used to implement a checkout API, because implementing checkout requires orchestrating state changes across many different systems, and this orchestration must happen in a reliable way.

With Golem, implementing checkout is as simple as writing ordinary code with libraries you already know and love.

Golem will execute the checkout logic reliably, even in the presence of faults, software updates, and cloud flakiness.


async function checkout(user, cart,paymentDetails, shippingAddress) { 
    try { 
        if (!(await checkAndReserveInventory(cart))) { 
            throw new Error("Inventory issue"); 
        }

        if (!user.isAuthenticated) { 
            await authenticateUser(user); 
        }

        const paymentInfo = paymentDetails || 
            (await getPaymentInformation(user));

        if (!(await processPayment(paymentInfo, cart.totalAmount))) {
            throw new Error("Payment issue");
        }

        const shippingDetails = 
            await generateShippingLabelAndTracking(shippingAddress, cart); 

        if (!(await dispatchOrderForFulfillment(cart, shippingDetails))) {
            throw new Error("Fulfillment issue");
        }

        await Promise.all([
            sendConfirmationEmail(user.email, cart, shippingDetails), 
            updateInventory(cart) 
        ]);

        return { success: true, message: "Checkout successful" }; 
    } catch (error) {
        console.error("Checkout failed:", error); // Rollback logic could be added here
    return { success: false, message: error.message }; 
    }
}

Benefits

Quickly build and deploy robust services in any language with the leading open source platform for durable computing.

Resilient

Golem detects faults and transparently migrates running workers to new nodes without disruption or loss of state.

Robust

Golem automatically applies customizable retry policies to all recoverable failures, ending cloud flakiness once and for all.

Serverless

Golem lets you focus on business logic, and uses standards like OpenAPI to create APIs for your workers automatically.

Stateful

Golem automatically preserves worker state between requests, regardless of failures, reducing the need for databases.

Transactional

Golem brings transactions to your business logic, guaranteeing exactly-once semantics, even in the presence of failures.

Composable

Golem brings compositionality to serverless through the WASM component model, enabling polyglot reuse.

Scalable

Golem automatically scales different components of your application to minimize infrastructure costs and maximize uptime.

Observable*

Golem provides built-in OTel metrics and tracing to hook into observability platforms so you can understand your applications.

Secure

Golem sandboxes and locks down every worker, providing them with capabilities and validated input, eliminating common vulnerabilities.

*Coming Soon

Golem vs Functions-as-a-Service (FaaS)

Golem extends the power of serverless computing into the realm of highly resilient distributed systems, taking severless to a whole new level.

	Golem	Functions-as-a-Service
Rapid development Enables rapid development of scalable services without deep technical expertise.	✅	✅
Automatic scalability Enables automatic horizontal scalability to minimize costs and handle any load.	✅	✅
Short-running workers Enables efficient and low-latency responses to requests and events.	✅	✅
Zero ops Enables the team to focus on delivering business value instead of infrastructure.	✅	✅
Instant observability* Enables the team to benefit from metrics and distributed tracing without coding.	✅	❓
Transactional workers Enables workers to atomically and reliably execute logic that is impervious to faults.	✅	❌
Long-running workers Enables complex workflows and orchestrations that execute over days or years.	✅	❌
Durable state Enables workflows to use ordinary memory instead of databases and caches.	✅	❌
Worker-to-worker communication Enables design of type-safe distributed systems with flawless reliability.	✅	❌
Vendor-neutral Enables you to deploy Golem on any cloud, public or private, without lock-in.	✅	❌

*Coming Soon

Why Golem

Durable computing guarantees your business logic executes completely, even in the presence of updates and infrastructure failures.

From workflows to process automation and microservice orchestration, Golem gives you effortless and flawless reliability.

Many distributed systems must be highly reliable, executing critical updates across many systems in a way that is fault-tolerant. To achieve this level of reliability in the cloud, developers often adopt event-driven architectures powered by fault-tolerant durable queues. These architectures deliver mission-critical reliability, but they require high skill and add complexity.
‍
Golem solves the problem at the level of infrastructure, which radically simplifies code for developers. All software components deployed on Golem are automatically executed transactionally, with no changes or SDK required, even in the presence of faults, restarts, updates, and transient failures.
‍
Golem gives you high reliability with simple code.

Serverless computing simplifies building modern cloud systems, by abstracting away infrastructure and allowing developers to focus on business logic. In serverless, the platform automatically creates and manages workers, executing code in response to requests.

Golem improves serverless by introducing stateful workers that run indefinitely (not just for a single request) and reliable worker-to-worker communication. Combined with transparent durable execution, Golem allows developers to build any distributed system with serverless

WASM is a new way to package cloud applications that is portable across platforms, secure, and performant. With the WASM component model, code can natively and performantly call other code written in other languages, without the boilerplate and overhead of HTTP or gRPC.

Golem has a sophisticated custom executor for WASM components that provides automatic and transparent durability, which lets developers build highly reliable and scalable distributed systems with simple code, in any language and with any tech stack

Get started

In just a few minutes, you can go from zero to having invincible serverless workers running Golem, in any language and technology stack.

1

Download

Fork the open source, grab a Docker image, or sign up for a free managed Golem Cloud account.

2

Develop

Build your app in any language or tech stack that compiles to WebAssembly, like Go, Typescript, or Rust.

3

Test

Test your app running on Golem, and watch it automatically be tolerant to faults, flakiness, and updates.

4

Deploy

Deploy in K8S, containers, public cloud or private cloud, and self-hosted or fully managed.

Get started

Golem News

Stay updated with the latest trends and developments in invincible serverless computing. Dive into our posts that offer insights and discussions around Golem and its diverse applications.

see all

Golem Hackathon coming to LambdaConf 2025!

learn more

Announcements

June 22, 2023

Golem 1.2 Release

learn more

Golem is Heading to KubeCon 2025

learn more

Subscribe to the Golem Open Source Newsletter

Subscribe to the Golem Open Source Newsletter to learn about improvements to Golem, and to hear about the latest articles, talks, and conferences that show you how to build reliable applications using Golem.

Thank you! Your submission has been received!

Oops! Something went wrong while submitting the form.