Vibeleaderboard
Index / tool
Visit encore.dev
Category
Developer Tools
Rank
Pricing
Open Source
Type
TOOL
Use case
Deployment & Operations
Interfaces
CLI · Web · API · SDK
Builder
encoredev
Latest release
v1.58.4
Date

About

An open-source TypeScript backend framework that automatically provisions infrastructure, databases, and observability tools for distributed systems. It eliminates DevOps complexity by letting developers define infrastructure as code and automatically handling deployment, monitoring, and scaling.

What it does

Encore lets you write a backend service in TypeScript or Go and describe the pieces it needs, a queue, a cache, a file bucket, a scheduled job, as plain objects in your source. A local command boots real versions of those pieces on your machine, including a working Postgres instance and message-queue semantics, so you can exercise the whole system before it touches a server. When you ship a change, the tool compares the declared pieces against what already exists in your own AWS or GCP account and creates only what is missing.

Why it's ranked here

What earns this a spot is not the provisioning pitch, which most infrastructure tools also make, but how plainly the project admits its own edges. It states outright that only TypeScript and Go are supported today, that a third language is still coming, and that automatic cloud provisioning reaches only two providers, with a third still on the roadmap. Alongside that honesty sit real exits: ordinary Go or TypeScript code underneath, a documented plain container build, and cloud resources that live in the team's own account instead of a vendor's. Named production users across fintech, logistics, and commerce back the claim that this runs real systems, not demos.

What's good

The strongest design choice is treating local development as a first-class target rather than an afterthought: running the app locally starts a real relational database and real message-queue semantics instead of stubs, so bugs tied to actual infrastructure behavior surface before code reaches a shared environment. Adoption is deliberately incremental: teams can wrap one service at a time, keep using whatever cloud SDKs or third-party APIs they already rely on, and the project documents a specific path for migrating a service back out again if the fit turns out to be wrong.

Tradeoffs

Committing to the full workflow means adopting more than the open source pieces: scheduled jobs run locally only when triggered by hand, and conveniences like preview environments, cost dashboards, and auto-generated architecture diagrams sit behind the optional managed platform rather than the SDK alone. Cloud coverage is narrow by the project's own admission, limited to two providers with a third still unbuilt, and the language surface is two mature options with a third still unreleased. Teams whose infrastructure needs fall outside the common set of databases, queues, storage, caches, jobs, and secrets are told plainly to keep wiring those up themselves.

How to use it well

This fits teams building new backend services in Go or TypeScript who want infrastructure decisions to live next to the code that uses them, especially ones already deploying into their own cloud account and tired of hand-wiring the same resources on every project. The natural entry point is a single new service, not a wholesale rewrite, since old and new systems can run side by side over ordinary APIs. It is the wrong fit if the target stack is outside its two supported languages, needs an unsupported cloud provider, or depends heavily on infrastructure outside its common-resource focus.

Technical notes+

The repository is a polyglot monorepo. go.mod declares the module as encr.dev on Go 1.25, with a replace directive that points the encore.dev runtime package back at a local runtime directory in this same repo. Cargo.toml defines a separate Rust workspace with members for the core runtime, the JS runtime, a TypeScript parser (plus a wasm build of it), a supervisor process, and a miniredis test double, and it patches in forked versions of tokio-postgres and of swc's ECMAScript parser crates. The go.mod dependency list includes github.com/nsqio/nsq and github.com/mark3labs/mcp-go, matching the README's claims of an NSQ-backed local Pub/Sub emulator and an MCP server for agent tooling. cli/cmd/encore/main.go is a Cobra-based CLI entry point (spf13/cobra via root.Cmd) that registers subcommands through blank imports for app, config, k8s, namespace, and secrets, and resolves the application root via a cmdutil helper. v2/app/app.go shows the static-analysis core: a Desc struct assembled by ValidateAndDescribe from a parser.Result, holding Services, Gateways, and an optional apiframework.AppDesc, with MatchingMiddleware walking global and per-service middleware against an endpoint's tags, meaning routing and infrastructure wiring are derived by parsing the application's source rather than by runtime reflection. docs/README.md confirms the public docs live outside this repo except a TypeDoc-generated API reference built from the JS runtime package, which CI regenerates and fails the build on if the committed output has drifted from source.

Observed

License
License is MPL-2.0, per the README badge.
Language support
Ships two officially supported infrastructure SDK languages, TypeScript and Go, with a third language explicitly marked as not yet available in the README's language table.
Interfaces
Interfaces span a CLI (the encore command), an open source infrastructure SDK usable as a library, an optional managed cloud platform, and an MCP server for agent introspection.
Repository structure
Repository is a polyglot monorepo: a Go module (go.mod) for the CLI and compiler plus a separate Rust workspace (Cargo.toml) for the core runtime, JS runtime, TypeScript parser, a supervisor process, and a Redis-compatible test double.
Self-hosting
A self-hosting path exists independent of the managed platform: a documented CLI command produces a standalone container image.
Cloud provider coverage
Automatic cloud provisioning is scoped to two providers per the README's stated limitations, with a third listed as roadmap-only.
CLI framework
CLI is built on the Cobra command framework, with subcommands registered via package-level blank imports.

Read from README.md, go.mod, Cargo.toml, cli/cmd/encore/main.go, v2/app/app.go, docs/README.md.

What it can do

  • Generate infrastructure configuration from TypeScript code

    TypeScript backend code with Encore annotations → Cloud infrastructure configuration and deployment scripts

  • Provision databases automatically

    Database schema definitions in TypeScript → Configured and deployed database instances

  • Deploy distributed systems to cloud platforms

    TypeScript application code and configuration → Running application deployed to cloud infrastructure

  • Set up monitoring and observability tools

    Application configuration and deployment parameters → Configured monitoring dashboards, metrics, and logging systems

  • Auto-scale application resources

    Traffic patterns and resource utilization metrics → Dynamically adjusted compute and storage resources

  • Generate API documentation

    TypeScript service definitions and API endpoints → Formatted API documentation and schemas

Intel on Encore

More in Intel

Tags

typescriptbackendinfrastructuredistributed-systemsdevopsautomationframeworkopen-source

Tech Stack

RustGo

Media

Encore

Comments (0)

No comments yet

Editorially curated, with community endorsements as a secondary signal. Corrections welcome.