backyard

Backyard

Drop a folder of HTML, get an internal URL — with a zero-config backend for every site.

Backyard is an open-source, enterprise-ready take on Quick, the internal hosting platform Shopify described on its engineering blog: anyone in the company copies a folder of HTML to a server and gets https://lunch-vote.backyard.acme.com/ — reachable only by colleagues, signed in through the company identity provider. Every site can include one script and get a realtime database, file uploads, AI, the data warehouse, websockets and the viewer's identity, with no backend code and no secrets in the page. The free-tier Cloudflare edition is inspired by OpenQuick.

<script src="/__backyard/backyard.js"></script>
<script type="module">
  const me = await backyard.me();                                   // who is viewing
  const votes = backyard.db.collection("votes");
  await votes.set(me.id.replace(/[^A-Za-z0-9_\-:.]/g, "_"), { choice: "tacos", name: me.name });
  votes.watch((docs) => render(docs));                               // live in every tab
</script>

Why

Most internal tools are a page, a list, a button and a bit of AI. They die in the backlog because each one needs a repo, a backend, a database, credentials, a deploy pipeline and a security review. Backyard removes all of that:

• A site is a folder. No framework, no build step (a dist/ folder is fine too), no config. Deploying is copying; overwriting is updating.
• The backend is already there. Database with realtime, files, AI, warehouse, websockets and identity, all scoped per site, all behind your company login.
• Saying no is a feature. No server code, no cron, no custom backends — a small, fixed set of capabilities that a platform team can secure once.
• Agents can do it all. Coding agents get the docs, a skill, an MCP server and templates, so "build me a lunch-vote page" ends with a URL — and with the Claude connector, so does a chat in Claude.

Features

• One binary: server, deploy CLI, local dev server and MCP server; a container image and Terraform/Helm/Compose/systemd kits.
• Client SDK (/__backyard/backyard.js): backyard.db (JSON documents, queries, change feeds, live queries), backyard.files, backyard.ai (chat, streaming, images, embeddings), backyard.warehouse (read-only SQL), backyard.socket (rooms with presence), backyard.id.
• Hub: a searchable directory of every site, drag-and-drop deploys, CLI setup, API docs at /docs and /llms.txt for agents.
• Sign-in: Okta / any OIDC provider, Google IAP, AWS ALB, trusted proxy headers (oauth2-proxy, Pomerium, Azure Easy Auth, Cloudflare Access), or none for labs; API tokens, static CI tokens and the OAuth device flow for CLIs.
• Claude connector (opt-in, both editions): add https://<hub>/__backyard/mcp to Claude (web, Desktop, mobile, Cowork, Claude Code) as a custom connector; people sign in with the company login, approve Backyard's consent page, and Claude finds, reads and publishes sites as them. Backyard is the OAuth server; your IdP needs no change (guide).
• Deploy any way: Backyard's diffed upload API (no cloud account needed), aws s3 sync, gcloud storage rsync, az storage blob sync or plain rsync.
• Pluggable everything: storage (disk, S3, GCS, Azure Blob), database (SQLite, PostgreSQL, DynamoDB), realtime fan-out (in-memory, Postgres, Redis), any AI provider, BigQuery / Redshift / Postgres / Athena.
• Enterprise-ready: admin groups, allowed domains and groups, optional site ownership, rate limits and quotas, audit logs, Prometheus metrics, health checks, horizontal scaling.
• Runs anywhere: AWS, Google Cloud, Azure, Kubernetes, one VM without a bucket — or Cloudflare's free tier with no server at all.

Quickstart (60 seconds)

curl -fsSL https://raw.githubusercontent.com/thasami/backyard/main/scripts/install.sh | sh
# or: go install github.com/thasami/backyard/cmd/backyard@latest

backyard serve --dev          # terminal 1: hub at http://localhost:8080, no login, data in ./.backyard-data

backyard init lunch-vote && cd lunch-vote       # terminal 2: index.html, .backyard.json, CLAUDE.md, AGENTS.md, skill
backyard dev                                    # live preview with a local backend: http://lunch-vote.localhost:4321/
backyard login --server http://localhost:8080   # the dev server accepts anonymous deploys
backyard deploy                                 # → http://lunch-vote.localhost:8080/

Then open http://localhost:8080/ to see the hub. Next: the getting started guide.

The client API at a glance

// Identity — from your IdP, no login forms
const me = await backyard.id.me();     // {id, email, name, title, team, avatar_url, groups, …}

// Database — JSON documents per site, type-strict queries, realtime
const todos = backyard.db.collection("todos");
await todos.create({ text: "Ship it", done: false });
const open = await todos.where("done", "==", false).orderBy("_meta.created_at", "desc").limit(20).get();
todos.subscribe({
  onCreate: (doc) => toast(`${doc._meta.created_by} added “${doc.text}”`),
  onUpdate: (doc) => rerender(doc),
  onDelete: (id) => remove(id),
});

// AI — the server holds the keys; pages pick an alias
const { content } = await backyard.ai.chat("Summarize this thread: " + text, { model: "fast" });
for await (const chunk of backyard.ai.stream("Write release notes for: " + changes)) out.textContent += chunk.text;

// Files and the warehouse
const file = await backyard.files.upload(input.files[0]);            // {id, url, name, size, …}
const { rows } = await backyard.warehouse.named("weekly_active_users", { team: "growth" });

// Websocket rooms — presence and messages
const room = backyard.socket.room("standup", { state: { name: me.name, speaking: false } });
room.on("members", (members) => renderPeople(members));
room.on("message", (data, from) => react(data.emoji, from.user.name));
room.send({ emoji: "🎉" });

Full reference: docs/client-api.md and the API reference; complete example apps in recipes and examples/.

Architecture

                     ┌──────────── company IdP (Okta · Entra ID · Google · …) ────────────┐
                     │                                                                     │
browser ──HTTPS──▶ [ built-in OIDC │ Google IAP │ AWS ALB │ trusted proxy │ none ] ──▶ backyard serve
                                                                                        │
   hub:   https://backyard.acme.com/                      ├─ static sites ─────▶ storage   fs │ s3 │ gcs │ azure
   sites: https://<site>.backyard.acme.com/               ├─ backyard.db ──────▶ database  sqlite │ postgres │ dynamodb
          (or https://backyard.acme.com/s/<site>/)        ├─ backyard.socket ──▶ pub/sub   memory │ postgres │ redis
                                                          ├─ backyard.ai ──────▶ Anthropic · OpenAI-compatible · Azure OpenAI
                                                          │                       · Bedrock · Gemini / Vertex · Ollama
                                                          ├─ backyard.warehouse ▶ BigQuery · Postgres / Redshift · Athena
                                                          └─ deploy gateway (embedded)
CLI · CI · agents ──▶ deploy gateway: embedded │ `backyard gateway` │ AWS Lambda ──presigned PUT──▶ bucket
                └───▶ or direct: aws s3 sync · gcloud storage rsync · az storage blob sync · rsync

More in docs/architecture.md; the normative contract is docs/spec/SPEC.md.

Deploy it

The container image is ghcr.io/thasami/backyard. Configuration is one backyard.yaml (reference; backyard config example prints an annotated one).

Authentication

CLIs sign in through the browser (backyard login), with the OAuth device flow, or with a token; CI uses static tokens whose SHA-256 is all the server stores.

Deploy methods

backyard deploy picks automatically; see deploying sites.

Backends

Guides: storage and databases, AI providers, warehouse, realtime.

Agent-native

• Claude skill — skills/backyard: rules, API cheat sheet, recipes and deploy guide. backyard skill install, and added to every project by backyard init.

• Claude Code plugin — skill, /backyard:new, /backyard:deploy, /backyard:docs and the MCP server:

  /plugin marketplace add thasami/backyard
  /plugin install backyard@backyard
  

• MCP server — backyard mcp (e.g. claude mcp add backyard -- backyard mcp): tools to read the docs, scaffold, deploy, list sites and read other sites' code, with the CLI's login.

• Claude connector — the hub as a remote MCP server at /__backyard/mcp, with the company sign-in and no CLI: docs/claude-connector.md.

• Init templates — backyard init --agents claude,codex,cursor,copilot writes CLAUDE.md, AGENTS.md, .cursor/rules/backyard.mdc and .github/copilot-instructions.md.

• /llms.txt, /llms-full.txt, /docs on every hub.

See docs/agents.md.

Security model

Backyard trusts everyone your IdP signs in — that is the point — and nobody else:

• every request is authenticated; outsiders see nothing, and allowed_domains, allowed_emails and allowed_groups narrow access further;
• inside the bubble there are no per-site permissions: anyone may read and write any site's data, so sites must not hold data not every employee may see;
• in host mode each site is its own browser origin, separated from other sites and the hub by a CSRF header, Origin checks and websocket origin checks (path mode shares one origin — a documented trade-off);
• secrets stay server-side; all keys derive from one server.secret with HKDF; tokens are short-lived JWTs or hashed static tokens;
• rate limits, quotas, upload limits, read-only warehouse roles, sandboxed uploads (only known passive types are served without a sandbox), SSRF-guarded fetching and audit logs bound the damage of a runaway page;
• in host mode a site's page cannot sign visitors in as someone else (conflicting cookies fail closed), a CLI login another site started needs confirmation, and backyard pull never writes repository metadata or agent files from a site.

Read docs/security.md before going to production; report vulnerabilities privately as described in SECURITY.md.

Documentation

Getting started · Configuration · Authentication · Deploying sites · Storage and databases · AI providers · Warehouse · Realtime · Client API · CLI · Agents · Security · Operations · Cloudflare · Architecture · Specification

Project layout

cmd/backyard/            the binary: server, CLI, MCP server
cmd/backyard-lambda/     the deploy gateway as an AWS Lambda function
internal/                server, auth, docstore, blob, pubsub, realtime, ai, warehouse, deploy, cli, …
web/sdk/                 the client SDK (backyard.js / .mjs / .d.ts) served to every site
web/hub/                 the hub UI
skills/backyard/         the Claude skill: the single source of agent-facing docs
templates/               files written by `backyard init`
commands/, .claude-plugin/  the Claude Code plugin
deploy/                  Terraform (aws, gcp, azure, cloudflare), Helm, Docker Compose, systemd,
                         and the Cloudflare Workers edition (deploy/cloudflare)
examples/                complete example sites
conformance/             the black-box API suite both editions must pass (SPEC §17)
e2e/                     real-browser end-to-end tests (Playwright, Chromium)
docs/                    documentation and the design specification (docs/spec/SPEC.md)
scripts/                 install script and CI tooling

Contributing

Contributions are welcome — see CONTRIBUTING.md for the development setup, tests (including the integration services, the cross-edition conformance suite and the Playwright end-to-end tests) and guidelines. Please follow the code of conduct.

License

Apache License 2.0. Backyard is an independent project and is not affiliated with Shopify or Cloudflare.