Distributed systems,
without the distributed pain

Splitting a backend into services usually means hand-written clients, service discovery, config for every environment, and no single view of a request once it crosses a boundary. With Encore, services call each other as typed functions and the whole system runs locally with one command, fully traced.

Start building

See how it could work for your team.

Book a demo

~/checkout — claude

Claude Code v2.1.180Opus 4.8 · Encore MCP connected~/checkout

Infra from codereading the code…

SQLDatabaseorders · postgres

Topicorder-placed

Servicedeclared in code

Clientdeclared in code

not running yet

Call another service like a function

Encore parses your application at compile time and generates a typed client for every service. You import it and call the endpoint directly, with parameters and return types checked by the compiler.No hand-written HTTP clients, no OpenAPI generation step, and no stringly-typed URLs that break silently when an endpoint changes.

Service-to-service calls

orders/order.ts

import { api } from "encore.dev/api";
// Encore generates a typed client for every service.
import { checkout } from "~encore/clients";

export const place = api(
  { expose: true, method: "POST", path: "/orders" },
  async (p: PlaceParams): Promise<Order> => {
    // A function call, checked at compile time.
    const quote = await checkout.quote({ cartID: p.cartID });

    return await save(p, quote.total);
  },
);

Run every service on your machine

One command starts the entire system: every service, the databases they own, and the queues between them. You get the real topology locally instead of running one service and mocking the rest.As the system grows past a handful of services, this is the difference between testing a change and hoping it works.

Every service running, not just the one you're editing
Databases and queues provisioned automatically
Traces across service boundaries locally
The same topology runs in production

Running locally

orders6 endpoints

checkout3 endpoints

users5 endpoints

search4 endpoints

Started by Encore when you run your app.

See the whole system, always current

Because the architecture is derived from the code, the service catalog and API docs can never drift from what is actually deployed. Every service, endpoint, and dependency is listed as it exists today.New engineers can see how the system fits together without reading every repo or asking whoever wrote it.

Service catalog

Service catalog4 servicesGenerated from your code

orders4 endpoints

SQLDatabaseTopicBucket

POST/orders(CreateOrderRequest) → Order

GET/orders/:id({ id: string }) → Order

GET/orders(ListParams) → OrderList

PUT/orders/:id/cancel({ id: string }) → Order

Follow one request across every service

In a distributed system the hard part is not the failure, it is finding which hop caused it. Encore traces every request across service calls, database queries, and async handlers as one timeline.Latency and errors are attached to the specific hop that produced them, in local development and in production.

One trace spanning every service hop
Database queries and payloads inline
Async handlers linked to the request that triggered them
Available locally and in production

trace_8f2c1a04b7POST /orders0msRecording

POST /orders

auth.Verify

SELECT users WHERE id = $1

orders.Create

INSERT INTO orders

SELECT inventory FOR UPDATE

cache.Set order:4821

publish orders.created

payments.Charge

POST api.stripe.com/charges

APIDBPUBSUBHTTPCACHE0 lines of instrumentation

Deployed to your own cloud account

Encore provisions each service and its infrastructure in your AWS or GCP account, with least-privilege IAM between them. Services scale independently, on managed cloud primitives rather than anything proprietary.Everything runs under your billing and compliance boundary, with full console access to every resource.