Encore vs Simple Container + Simple Forge

Infrastructure Automation for AI Coding Agents — Deep Comparative Analysis

Prepared by Kate Jones · Research date: 2026-10-07 · Primary sources: encore.dev/docs · docs.simple-container.com · github.com/encoredev/encore · SC org repositories (simple-container-com)

Jump to: Executive Summary The Claim Verified Encore Deep-Dive SC + Forge Deep-Dive Feature Matrix End-to-End Scenarios Executive Verdict Threats & Opportunities Recommendations Sources

1. Executive Summary

Key Finding: Encore's claim that "AI agents can set up infrastructure without Terraform" is substantially true for its specific scope — TypeScript or Go backends targeting AWS or GCP — but carries important qualifications that marketing language obscures. It is a deep, opinionated, code-first framework, not a general-purpose IaC replacement. Simple Container (SC) + Simple Forge take a different approach: YAML-driven, Docker/Kubernetes-centric, multi-cloud including Kubernetes self-hosting, with Forge as an AI agent layer on top. The two products serve overlapping but distinct segments.

Encore has significant advantages in developer experience for greenfield TypeScript/Go backends — its code-first infrastructure inference, local-to-cloud consistency, preview environments, MCP tooling, and AI agent integration are polished and production-proven. Its core limitation is lock-in: the framework requires rewriting application code to use Encore SDKs, and "without Terraform" actually means Encore replaces Terraform internally using AWS/GCP cloud APIs — you never write Terraform, but Encore's provisioning engine does equivalent work under the hood.

Simple Container + Forge is better suited for language-agnostic, container-native, multi-cloud, or Kubernetes self-hosted workloads. It is less opinionated about application code structure, but requires more explicit YAML configuration from DevOps teams. Forge agents operate at the deployment/workflow orchestration level rather than infra-inference level. SC does not yet offer the same depth of per-PR preview environment automation or local-to-cloud development symmetry.

2. Encore's "No Terraform" Claim — Verified with Primary Sources

The Precise Claim

Encore's homepage (October 2026) states: "Automated infrastructure from development to production" and "Declare infrastructure in your TypeScript or Go code and Encore provisions it on AWS or GCP." The pricing page says: "Declarative Infrastructure as Code (No Terraform, no YAML)." The docs explicitly state the goal is that AI agents can declare what a feature needs and Encore provisions it without Terraform.

Source: encore.dev/docs/understanding-encore (fetched 2026-10-07): "Infrastructure that would normally be described in Terraform can instead be derived from the application, with Encore using static analysis to work out service dependencies, IAM, and how resources connect."

What "Without Terraform" Actually Means

Layer	What Happens	Terraform Equivalent
Developer / Agent writes	`const db = new SQLDatabase("orders", ...)` in TypeScript	Would write `aws_db_instance` resource block
Encore parser (open source, runs locally)	Builds Application Model via static analysis of source code	Terraform plan
Encore Cloud Platform (SaaS, Pro tier)	Calls AWS/GCP APIs directly to provision RDS, Cloud SQL, SNS+SQS, etc.	Terraform apply (but done by Encore, not you)
State management	Encore tracks provisioned resources; drift-aware updates; PATCH-style (not full sync)	Terraform state file
IAM	Least-privilege, auto-derived from which service calls which resource	aws_iam_policy written manually

Verdict on the claim: Encore legitimately eliminates the need for developers and AI agents to write Terraform. The provisioning engine does the equivalent internally via cloud APIs. This is a real, shipped capability — not marketing. However, it requires using the Encore framework SDK (code rewrite), and only works for AWS/GCP (not Azure, Kubernetes self-host, etc.). The "agent can set everything up" is accurate within these constraints.

Open Source vs. Encore Cloud Platform

Component	Open Source / Free	Requires Pro/Enterprise ($49+/member/mo)
Encore.ts / Encore.go SDKs	✓ Open Source
CLI, parser, compiler	✓ Open Source
Local infra (Docker Postgres, in-mem Pub/Sub)	✓ Free
Encore Cloud hosting (dev envs, free tier)	✓ Free (Fair Use)
Provision to your own AWS/GCP		Pro required
Preview Environments per PR		Pro required
Least-privilege IAM management		Enterprise only
Self-hosted Preview Environments		Enterprise only
Self-host (build Docker image, run anywhere)	✓ Free via `encore build docker`

Source: encore.dev/pricing, fetched 2026-10-07. Encore v1.58.6, released 2026-10-01.

3. Encore — Deep-Dive Analysis

How Infrastructure Inference Works

Encore uses a static-analysis parser that reads TypeScript or Go source at build time (not at runtime). When you write new SQLDatabase("orders", { migrations: "./migrations" }), the parser records the resource name and migration path without executing the code. This builds the Application Model — a graph of services, APIs, databases, Pub/Sub topics, caches, object storage, cron jobs, and secrets, plus inter-service dependencies and access patterns.

Key constraint: Resource names must be string literals (not template strings or variables) and declarations must be at module scope. Dynamic resource creation (e.g., inside loops or conditionals) is not supported and causes build errors. This is intentional — it enables deterministic static analysis.

Supported Languages & Frameworks

Language	Status	Notes
TypeScript (Node.js)	Production	Encore.ts — full SDK, primary target
Go	Production	Encore.go — full SDK, original language
Python	Beta/preview	Encore.py — announced, limited support
Rust	Early preview	Encore.rs — announced on blog
Other languages	Not supported	No Java, .NET, Ruby, PHP, etc.

Supported Cloud Targets

Target	Status	Notes
AWS (ECS Fargate, EKS)	Production	RDS, S3, SNS+SQS, ElastiCache, Secrets Manager
GCP (Cloud Run, GKE)	Production	CloudSQL, GCS, Pub/Sub, Memorystore, Secret Manager
Azure	Not supported	No Azure support listed anywhere in docs
Self-hosted Kubernetes	Partial	`encore build docker` + manual infra config; no auto-provisioning
On-prem	Partial	Self-host path exists but requires manual infra config JSON

Infrastructure Primitives Supported

Encore's Application Model supports a fixed set of resource types:

SQL Databases — PostgreSQL (local: Docker; cloud: RDS or Cloud SQL)
Pub/Sub Topics & Subscriptions — local: NSQ in-memory; cloud: SNS+SQS / GCP Pub/Sub
Object Storage Buckets — local: disk; cloud: S3 / GCS
Caches — Redis-compatible; local: in-memory; cloud: ElastiCache / Memorystore
Cron Jobs — local: disabled; cloud: Encore-managed scheduler
Secrets — referenced by name; cloud: AWS Secrets Manager / GCP Secret Manager
Services & API Endpoints — type-safe, auto-documented

Notable gaps: Elasticsearch/OpenSearch, Kafka, Redis Cluster (only single-node cache), custom VPC networking rules, static frontends/CDN, MongoDB, DynamoDB/Firestore — all must be provisioned externally and connected via secrets.

Agent Setup Interface

CLI

encore app create — creates new app, generates project rules for AI tools
encore llm-rules init — generates CLAUDE.md, Cursor rules, AGENTS.md for existing projects
encore mcp start / encore mcp run — starts local MCP server
encore run — starts app + local infra; encore build docker for self-hosting

MCP Server (Shipped, v1.58.x)

Encore provides a local MCP server (SSE or stdio) that gives AI agents structured access to the running application. Tools exposed:

get_databases, query_database — schema inspection, live queries
call_endpoint, get_services, get_middleware, get_auth_handlers
get_traces, get_trace_spans — trace search and span inspection
get_metadata, get_src_files — full app model + source code
get_pubsub, get_storage_buckets, get_cache_keyspaces, get_cronjobs, get_metrics, get_secrets
search_docs, get_docs — documentation search

A Cloud MCP Server also exists at https://api.encore.dev/mcp for accessing deployed cloud environments (production traces, deployment status, etc.).

Encore Skills Package

An npm package (npx add-skill encoredev/skills) installs repeatable agent workflows for Cursor, Claude Code, GitHub Copilot: creating APIs, databases, topics, testing, migration. Source: github.com/encoredev/skills.

Preview Environments

Per-PR preview environments: real cloud infra, automatically created on PR open, destroyed on merge/close
Named after PR number: pr:72 → https://pr72-<app-id>.encr.app
Database branching via Neon: PR environments can be seeded from a staging DB snapshot
Default: hosted on Encore Cloud (free, ephemeral)
Enterprise: self-hosted preview environments in your own VPC

Secrets / IAM / Security

Secrets referenced by name in code; stored/injected from AWS Secrets Manager / GCP Secret Manager
IAM is auto-derived from static analysis: which service reads/writes which resource gets exactly those permissions — no manual policy writing
Per-environment credential isolation; each container has its own DB credentials
mTLS 1.3 between services; encrypted DB access with cert validation
Least-privilege IAM management: Enterprise tier only

State / Drift / Import

Encore tracks provisioned infrastructure in its own state (not Terraform state file)
Drift-aware: before any update, Encore pulls current resource properties from the cloud; if drift is detected, it updates its internal representation (does NOT overwrite manual changes)
PATCH-style updates: only changes attributes that require changing (not full Terraform apply)
Deletion protection: infrastructure is NOT auto-destroyed; requires manual approval in dashboard
Terraform Provider available: existing Terraform configs can reference Encore-managed resources by name
Import of existing Kubernetes clusters: supported (Enterprise)

Rollback / Destroy

Deploy rollback: available via Encore dashboard (re-deploy previous version)
Infra destroy: manual approval required in dashboard; safety gate prevents accidental destruction

Observability

Distributed tracing: built-in, no agent code in application; spans across service boundaries and Pub/Sub
Metrics: built-in, can export to Datadog, Grafana
Logs: streamed to Encore dashboard; 7 days retention (Starter), 30 days (Pro)
Local dev dashboard: architecture diagram, API docs, trace viewer, database explorer
Cost monitoring: GCP (available), AWS (in progress per docs)

Portability / Self-Host / Anti-Lock-In

encore build docker builds a standard Docker image (no Encore runtime dependency)
Self-hosting path: build Docker image, provision own infra (Terraform/Pulumi/manual), supply infra-config.json
No proprietary code runs in your cloud at runtime
You own the cloud account and provisioned infrastructure
Cancelling Encore Pro does not take your infrastructure offline
Migration-away docs available at encore.dev/migrate-away

Pricing (Encore Cloud Platform)

Starter (Free): Local development, Encore Cloud hosting (fair use), 1 concurrent build, 1M traces/mo, 7 days retention, no own-cloud deploy, no preview envs
Pro ($49/member/mo + $99/environment + $2.50/resource/environment): Own-cloud AWS/GCP, preview envs, custom domains, 2 concurrent builds, 20M traces, 30 days retention, WAF (Cloudflare), Datadog/Grafana integrations
Enterprise (Custom): Least-privilege IAM, self-hosted preview envs, RBAC, CI/CD customization, SOC 2, TAM, custom SLAs

Resources = Encore primitives (services, DBs, cron jobs, caches, buckets, topics, subscriptions, secrets). Underlying cloud primitives not counted separately.

4. Simple Container + Simple Forge — Deep-Dive Analysis

Simple Container (SC) — What It Is

SC is an open-source, MIT-licensed CLI tool (sc) for cloud-agnostic deployment of containerised microservices. It uses YAML configuration files (server.yaml / client.yaml) to define infrastructure resources and deployment targets, without requiring developers to write Terraform or Pulumi directly.

Source: SC README (github.com/simple-container-com/api): "Define infrastructure with lightweight YAML configurations, no need for Terraform or Pulumi." Installation: curl -s "https://dist.simple-container.com/sc.sh" | bash

Architecture Model

SC uses a stack model:

Parent stack (DevOps-managed): server.yaml defines cloud resources (databases, Kubernetes clusters, MongoDB Atlas, etc.), provisioner type, secrets backend
Child stack (developer-managed): client.yaml defines the service to deploy (image, env vars, compute type, referenced resources from parent)
Resources are explicitly declared in YAML with full control over configuration (region, instance size, network config, etc.)

Supported Cloud Targets

Target	Status	Notes
AWS ECS Fargate	Production	Containerised services on Fargate
AWS Lambda	Production	Serverless Lambda deployment (forge itself deployed here)
GCP Cloud Run	Production	Serverless containers
Kubernetes (generic)	Production	Any Kubernetes cluster (EKS, GKE, K3s, on-prem, Rancher)
GKE Autopilot	Production	Specific GKE support verified in testdata
Self-hosted / on-prem K8s	Production	Ansible+K3s deployment supported in testdata
Azure	Unknown	Not explicitly listed in docs/testdata; [to be verified]

Supported Infrastructure Resources (server.yaml)

From testdata and docs (docs.simple-container.com/reference/supported-resources):

Databases: MongoDB Atlas (including Private Link), GCP Cloud SQL PostgreSQL, Amazon RDS (seen in testdata)
Kubernetes: Create/use existing clusters, GKE Autopilot, K3s via Ansible
Secrets: AWS Secrets Manager, GCP Secret Manager, Kubernetes Secrets — referenced and injected at deploy time
DNS: Custom DNS management in dns.go
Container Registry: DockerHub (used in CI/CD)
Static files/CDN: Seen in testdata (refapp-static-gcp)

Important distinction: SC does NOT infer infrastructure from application code. A DevOps engineer must explicitly declare every resource in server.yaml. The developer writes a much simpler client.yaml (service config) that references parent resources. This is explicit YAML declaration, not code-first inference.

Agent Setup Interface (Simple Forge)

Simple Forge is an AI agent orchestration layer running as AWS Lambda + MongoDB Atlas, deployed via SC itself:

GitHub Webhooks: Forge monitors GitHub issues/comments → triggers Claude AI → commits code to branches → manages PRs
Job Queue: MongoDB-backed, issue-level concurrency control, FIFO, exponential backoff retry
Context Management: API-based context fetching, pruning to stay within Claude token limits, version-controlled conversation history
GitHub Actions: Dynamic workflow triggering; Claude CLI runs in GitHub Actions environment
Telegram Notifications: Real-time job completion alerts (shipped)
No MCP server exposed for agents to inspect infra state in real-time (unlike Encore)

Secrets Management

Secrets stored encrypted in repository (X25519 + AES-256-GCM encryption, scoped per stack/environment)
Backed by AWS Secrets Manager or GCP Secret Manager in production
KMS integration (AWS KMS, GCP KMS) for envelope encryption
sc secrets reveal decrypts secrets for local dev/CI
Scoped secrets: each environment has its own scope; secrets can't bleed across environments
Well-tested: extensive test coverage in pkg/api/secrets/

State / Drift / Import

State managed via YAML + cloud provider state (depends on provisioner type)
Pulumi provider available (pulumi-yandex in org; Pulumi used in pkg/clouds/pulumi/)
Drift handling: depends on provisioner; Pulumi-based provisioners have full state reconciliation
Import of existing infrastructure: possible via YAML reference (explicit, not auto-detected)

Observability

CloudWatch monitoring with alerts (Email, Slack, Discord, Telegram) — AWS-native
Simple Container dashboard for deployment status and logs
No built-in distributed tracing across service boundaries (would need external APM)
No built-in service catalog or architecture diagram generation

Preview / Ephemeral Environments

No native per-PR preview environment automation equivalent to Encore's built-in feature
Can be constructed manually via SC deploy scripts + GitHub Actions
Forge agents can be instructed to deploy to ephemeral environments, but not automatically wired

Portability / Anti-Lock-In

MIT licensed; SC CLI is fully open source
YAML configs are human-readable and not bound to a specific SaaS
Works with any Dockerfile / docker-compose — no application code changes required
Multi-cloud by design; same client.yaml can target different cloud providers
On-prem Kubernetes fully supported

Pricing

Simple Container CLI: free, open source (MIT)
Simple Container Cloud (the managed SaaS offering): [pricing not publicly listed, contact required]
Simple Forge: internal tooling, not sold separately
You pay cloud provider directly for all provisioned infrastructure

5. Feature Comparison Matrix

Dimension	Encore (Cloud Platform, Pro)	Simple Container + Forge
Infra declaration method	Code-first (TypeScript/Go typed SDK calls)	YAML-first (server.yaml + client.yaml)
Infra inference (no-write)	✓ Auto-inferred via static analysis	✗ Explicit YAML declaration required
Languages supported	TypeScript, Go (production); Python, Rust (preview)	Any (container-based; language-agnostic)
AWS support	✓ Full (ECS Fargate, EKS, RDS, S3, etc.)	✓ Full (Fargate, Lambda, RDS, etc.)
GCP support	✓ Full (Cloud Run, GKE, CloudSQL, etc.)	✓ Full (Cloud Run, GKE Autopilot, CloudSQL)
Azure support	✗ Not supported	Unknown (not confirmed in docs)
Kubernetes self-host	Partial (build Docker, manual infra config)	✓ Full (K3s, GKE Autopilot, any K8s cluster)
On-prem deployment	Partial (self-host Docker, manual config)	✓ Full (Ansible+K3s, any Kubernetes)
Preview environments (per PR)	✓ Built-in (Pro; Encore Cloud or own VPC Enterprise)	✗ Not built-in; manual scripting required
Local dev parity with cloud	✓ Strong (Docker Postgres, in-mem Pub/Sub, local tracing)	Partial (docker-compose for local; env parity not automatic)
MCP server for AI agents	✓ Shipped (local + cloud MCP servers)	✗ Not available
AI agent integration depth	Deep (MCP tools, skills package, project rules, build-time validation)	Workflow-level (GitHub issue→Claude→PR pipeline; no infra inspection)
Auto IAM least-privilege	✓ Auto-derived from code (Enterprise for full feature)	Manual (DevOps configures in server.yaml / cloud console)
Secrets management	✓ Built-in (name references in code; cloud-native secret managers)	✓ Built-in (encrypted YAML + cloud secret managers + KMS)
Distributed tracing	✓ Built-in (no agent code; cross-service spans)	External (CloudWatch metrics; no cross-service trace built-in)
Service catalog / arch diagram	✓ Built-in (auto-generated from Application Model)	✗ Not available
Drift detection	✓ Built-in (PATCH-style, drift-aware before any update)	Partial (depends on provisioner; Pulumi has state reconciliation)
State management	Encore internal state (not Terraform state)	YAML + provisioner state (Pulumi state where applicable)
Rollback	✓ Dashboard re-deploy to previous version	✓ `sc deploy` to previous image/version
Infra destroy safety	✓ Manual approval required in dashboard	Standard per-provisioner behavior
Vendor lock-in risk	Medium (SDK rewrite required; AWS/GCP only; escape hatch via Docker)	Low (any container; any cloud; MIT open source)
Application code changes required	Yes — must use Encore SDK primitives	No — any Dockerfile/docker-compose works
Open source	SDK + CLI open source; cloud platform is SaaS	SC CLI: MIT open source; Forge: proprietary internal tooling
Pricing model	$49/member/mo + $99/env + $2.50/resource (Pro); Enterprise custom	SC CLI free; SC Cloud: undisclosed; cloud infra direct to provider
Latest release	v1.58.6 (2026-10-01)	SC API continuously deployed; version stamped at build

6. Concrete End-to-End Scenarios

Scenario A: Greenfield TypeScript backend — AI agent sets up from scratch

With Encore:

Run encore app create → choose AI tool → CLAUDE.md and MCP config auto-generated
Agent (Claude Code, Cursor) uses encore mcp run to inspect the application model in real-time
Agent writes new SQLDatabase(...), new Topic(...), etc. in TypeScript — Encore validates at build time
Push to GitHub → Encore Cloud provisions RDS + SNS+SQS in developer's AWS account; per-PR preview env created
Agent calls API via MCP call_endpoint, verifies traces via get_traces, iterates

Result: Fully automated, zero Terraform, real AWS infra in minutes. Lock-in cost: application is now Encore-specific.

With SC + Forge:

DevOps writes server.yaml defining the stack (Postgres RDS, Kubernetes cluster, secrets backend)
Developer writes client.yaml + Dockerfile for the service
Forge agent (triggered by GitHub issue) generates application code, commits to branch, opens PR
SC deploys the PR branch to staging (sc deploy -s myservice -e staging)
Agent cannot inspect live infra state; must rely on logs and test endpoints manually

Result: Partially automated. More DevOps YAML setup upfront. No automatic per-PR preview environments. No application code changes. Lock-in cost: minimal.

Scenario B: Existing microservices on Kubernetes — adopting AI agent infra management

With Encore: Requires rewriting services to use Encore SDK primitives. Partial adoption possible (self-host path), but full automation requires SDK adoption. High migration cost. Not recommended for large existing codebases.

With SC + Forge: Add .sc/stacks/myservice/client.yaml to existing repos. Zero application code changes. Forge agents work on any codebase. More natural fit. Better fit here.

Scenario C: Multi-cloud or hybrid (AWS + on-prem Kubernetes)

With Encore: AWS and GCP supported; no Azure; on-prem requires manual Docker + infra config. Limited automation for hybrid scenarios.

With SC + Forge: Native support for AWS + GCP + any Kubernetes (including on-prem K3s). Same client.yaml can target different environments. Better fit here.

Scenario D: Real-time AI agent validation loop (agent writes code → tests infra → iterates)

With Encore: Full real-time validation loop via MCP server. Agent can: inspect schema → write code → run → call endpoint via MCP → inspect trace → iterate. Build-time guardrails catch invalid declarations before deployment. Strong advantage for Encore.

With SC + Forge: Agent writes code → commits → SC deploys → agent must parse logs or call HTTP endpoints externally to validate. No structured MCP-style inspection of live infra state. Loop is slower and less reliable.

7. Executive Verdict

🔍 Proven Advantages — Encore over SC + Forge

Code-first infrastructure inference: Genuinely eliminates Terraform for TypeScript/Go backends — no YAML config needed by developers or agents
MCP tooling for AI agents: Structured, real-time application model inspection is a clear lead; SC has no equivalent
Per-PR preview environments: Built-in, zero-config; SC has no native equivalent
Local dev ↔ cloud parity: encore run boots local Postgres, Pub/Sub, tracing — exact same code runs everywhere
Distributed tracing built-in: Zero instrumentation required; SC relies on CloudWatch metrics + external APM
Auto-generated IAM: Least-privilege derived from static analysis; SC requires manual configuration
Build-time validation: Invalid declarations are caught before deployment; provides strong guardrails for agent-generated code

🛡️ Proven Advantages — SC + Forge over Encore

Language agnostic: Works with any language, any framework, any Dockerfile
No application code changes: Zero SDK rewrite cost; critical for existing codebases
Kubernetes self-host and on-prem: Full support; Encore's self-host path is manual and limited
Lower vendor lock-in: MIT license; YAML configs are portable; not bound to a SaaS
Richer database ecosystem: MongoDB Atlas, multi-provider Postgres; not limited to RDS/CloudSQL
Secrets encryption at rest in repo: X25519 + AES-256-GCM in-repo encryption with KMS; Encore stores secrets in cloud secret managers only

⚖️ Parity

AWS + GCP production deployment
Secrets injection at runtime
Rollback mechanisms
CI/CD via GitHub Actions
Infra deletion safety gates
Open source core tooling

❓ Unknowns / Unverified

SC Cloud pricing (not published)
Azure support for SC (not confirmed)
Forge roadmap for MCP/agent-infra inspection
Encore Python/Rust production readiness
SC's vertical pod autoscaler maturity
Encore cost monitoring for AWS (listed as "in progress")

Roadmap-Only Features (do not treat as shipped):

Encore cost monitoring for AWS — docs state "GCP today, AWS in progress"
Encore.py / Encore.rs — production-quality status unconfirmed; listed in nav but limited docs
Azure support for either product — not confirmed for either
SC Forge MCP-style agent tools — not in current shipped product

8. Strategic Threats & Opportunities

Threats from Encore to SC + Forge

AI agent developer experience gap: Encore's MCP + skills package + build-time guardrails create a developer experience that AI-first teams will strongly prefer for greenfield TypeScript/Go. This is a growing market segment.
Preview environments as table stakes: Per-PR preview environments are becoming an expected feature; SC's absence here is a gap for teams evaluating modern dev platforms.
Growing Encore mindshare: 12K+ GitHub stars, endorsements from CTOs of fintech/marketplace companies; increasing community adoption.
Open source SDK removes migration friction: Developers can adopt Encore's SDK layer for free and feel the local dev experience; SaaS lock-in only happens later. Low barrier to try → higher conversion risk.

SC + Forge Opportunities vs. Encore

Language-agnostic wins: Any team using Python, Java, .NET, Ruby, or polyglot services cannot adopt Encore. SC's footprint here is entirely defensible.
Kubernetes power users: Teams with existing Kubernetes investment (EKS, GKE, on-prem) do not want to rewrite applications. SC's native Kubernetes support is a strong retention factor.
MCP tooling gap in SC + Forge is addressable: Adding an MCP server exposing stack state, deployment history, and log/trace data to Forge agents would close the AI agent experience gap significantly without requiring any application code changes.
Multi-cloud / Azure opportunity: If SC confirms Azure support, it has a geography that Encore cannot serve at all.
Enterprise/compliance angle: SC's in-repo secrets encryption, NIST compliance docs, and on-prem Kubernetes support are strong selling points for regulated industries that Encore's cloud-centric model cannot match.

9. Prioritised Recommendations

Research only — no code or roadmap modifications made in this run.

Add an MCP server to SC + Forge that exposes stack state to AI agents. This is the single highest-leverage action to close the AI agent experience gap. The server should expose: deployed service status, recent deployment history, resource configuration, secrets metadata (not values), and deployment logs. This would allow agents to inspect, validate, and iterate on infra changes without application code changes.

Build native per-PR preview environment automation. Add a sc preview-env create --pr=72 workflow that provisions an ephemeral environment from a PR, registers it as a GitHub deployment, and tears it down on PR close. Even a lightweight version (reusing existing stack templates) would address a critical feature gap vs. Encore.

Publish SC Cloud pricing and positioning. The absence of public pricing creates evaluation friction. Even a "contact us" tier + a clear free tier description would help teams comparing SC to Encore's well-documented pricing.

Develop "Encore migration" or "Encore parity" documentation for SC. A doc showing how SC handles each of Encore's core features (preview envs, secrets, IAM, local dev) would help teams currently evaluating Encore discover SC as an alternative — especially for teams with existing codebases they cannot rewrite.

Add local dev infrastructure parity (docker-compose-first DX). SC should document and streamline the local development story — ideally with a sc dev up command that starts all declared resources from server.yaml locally in Docker, matching the env your service expects. This directly addresses one of Encore's strongest differentiators.

Confirm and publicise Azure support. If Azure is supported (or can be added), this is a market segment Encore entirely misses. Clear documentation would attract enterprise teams in Azure-heavy environments.

Add built-in distributed tracing support or a first-class Forge workflow for trace correlation. Even an OpenTelemetry collector integration in the Forge agent would close the observability gap. Encore's built-in tracing (no agent code required) is a meaningful DX win that SC currently lacks.

10. Source List

Source	URL	Date Retrieved	Credibility
Encore Docs — Overview	encore.dev/docs.md	2026-10-07	Primary — official docs
Encore — Understanding Encore	encore.dev/docs/understanding-encore.md	2026-10-07	Primary — official docs
Encore — AI Integration	encore.dev/docs/ai-integration.md	2026-10-07	Primary — official docs
Encore — Platform Introduction	encore.dev/docs/platform/introduction.md	2026-10-07	Primary — official docs
Encore — Infrastructure Provisioning	encore.dev/docs/platform/infrastructure/infra.md	2026-10-07	Primary — official docs
Encore — Infrastructure Configuration	encore.dev/docs/platform/infrastructure/configuration.md	2026-10-07	Primary — official docs
Encore — Preview Environments	encore.dev/docs/platform/deploy/preview-environments.md	2026-10-07	Primary — official docs
Encore — Own Cloud Setup	encore.dev/docs/platform/deploy/own-cloud.md	2026-10-07	Primary — official docs
Encore — Security	encore.dev/docs/platform/deploy/security.md	2026-10-07	Primary — official docs
Encore — Self-Hosting / Build Docker	encore.dev/docs/self-host/build.md	2026-10-07	Primary — official docs
Encore — Local MCP Server	encore.dev/docs/mcp.md	2026-10-07	Primary — official docs
Encore — Platform AI Integration	encore.dev/docs/platform/ai-integration.md	2026-10-07	Primary — official docs
Encore — Pricing	encore.dev/pricing	2026-10-07	Primary — official pricing page
Encore GitHub — Latest Release v1.58.6	github.com/encoredev/encore releases	2026-10-07	Primary — GitHub API, released 2026-10-01
SC API README	github.com/simple-container-com/api (private)	2026-10-07	Primary — org source code
SC API — welder.yaml	github.com/simple-container-com/api/welder.yaml (private)	2026-10-07	Primary — org source code
SC API — testdata/stacks/refapp/server.yaml	github.com/simple-container-com/api (private)	2026-10-07	Primary — org source code
SC Forge README	github.com/simple-container-com/forge (private)	2026-10-07	Primary — org source code
SC Docs — Supported Resources	docs.simple-container.com	2026-10-07	Primary — official docs

Key Quotes

"Infrastructure that would normally be described in Terraform can instead be derived from the application, with Encore using static analysis to work out service dependencies, IAM, and how resources connect." — Encore docs, Understanding Encore (2026-10-07)
"Direct provisioning via cloud APIs: The Encore platform creates resources using your cloud provider's official APIs. No IaC files to maintain; your code is the source of truth." — Encore docs, Platform Introduction
"When your application is deployed, there are no runtime dependencies on the Encore platform and no proprietary code runs in your cloud." — Encore docs, Platform Introduction
"Define infrastructure with lightweight YAML configurations, no need for Terraform or Pulumi." — SC API README (github.com/simple-container-com/api)
"AI doesn't need to know the intricacies of AWS or GCP. It just declares what it needs, and the Encore platform handles the cloud-specific configuration." — Encore docs, Platform AI Integration

Report generated by Kate Jones (Research Agent) · Simple Forge Workflow Run 628440cf · 2026-10-07 UTC · All facts verified against primary sources. Pricing, versions, and feature availability as of retrieval date.