The best way to control Claude Code, Codex and more from any computer or phone
| 1 | # Alchemy |
| 2 | |
| 3 | > Alchemy Effect is an Infrastructure-as-Effects (IaE) framework that combines cloud infrastructure and application logic into a single, type-safe program powered by [Effect](https://effect.website). Resources are declared as Effects; bindings wire IAM, env vars, and typed SDKs in one call; deploys and runtime share the same code. |
| 4 | |
| 5 | This file is a navigation index for the documentation site at https://alchemy.run. Guide and concept pages are listed below with their URL and a one-line summary, so an agent can pick the right page in one hop. The service-level API reference is indexed separately in [llms-full.txt](https://alchemy.run/llms-full.txt). |
| 6 | |
| 7 | ## Start here |
| 8 | |
| 9 | - [What is Alchemy?](https://alchemy.run/what-is-alchemy) — Alchemy is a TypeScript framework for building cloud applications with Effects and Layers. Your infrastructure and the code that runs on it are written, type-checked, and deployed together. |
| 10 | - [Getting started](https://alchemy.run/getting-started) — Install Alchemy and create your first Stack in under two minutes. |
| 11 | - [Migrating from v1](https://alchemy.run/migrating-from-v1) — Migrate your Alchemy v1 (async/await) project to Alchemy v2. |
| 12 | |
| 13 | ## CLI |
| 14 | |
| 15 | Every command runs through your package manager: bun alchemy <command>. Command pages by role, the Programmatic API for running them from scripts, plus the Adopting Resources and Inspecting State guides. |
| 16 | |
| 17 | - [CLI](https://alchemy.run/cli) — Every alchemy command at a glance — the command map, common options, and how the interactive TUI decides when to render. |
| 18 | - [Programmatic API](https://alchemy.run/cli/api) — Run deploy, plan, destroy, drift, nuke, logs, and state from your own scripts with alchemy/Alchemist. |
| 19 | - [deploy](https://alchemy.run/cli/deploy) — Compute a plan, ask for approval, and create/update/delete resources to match the desired state. |
| 20 | - [plan](https://alchemy.run/cli/plan) — Preview what would change without applying anything. Equivalent to alchemy deploy --dry-run. |
| 21 | - [destroy](https://alchemy.run/cli/destroy) — Delete every resource in a stack — plan all existing resources for deletion, ask for approval, and remove them in dependency order. |
| 22 | - [drift](https://alchemy.run/cli/drift) — Detect infrastructure drift by re-observing the cloud, and optionally repair it back to the last deployed state. |
| 23 | - [nuke](https://alchemy.run/cli/nuke) — Enumerate and delete every live resource across the stack's providers. |
| 24 | - [Adopting Resources](https://alchemy.run/cli/adopting-resources) — How alchemy takes ownership of pre-existing cloud resources — recovery by default, --adopt for foreign resources, and the programmatic AdoptPolicy. |
| 25 | - [dev](https://alchemy.run/cli/dev) — Run your stack in development mode with hot reloading — resources deploy to the cloud while Workers run in the local dev runtime. |
| 26 | - [logs](https://alchemy.run/cli/logs) — Fetch or tail logs from deployed resources, merged and color-coded by resource. |
| 27 | - [profile](https://alchemy.run/cli/profile) — Create, refresh, rename, edit, inspect, or delete Alchemy authentication profiles. |
| 28 | - [state](https://alchemy.run/cli/state) — Browse, read, and delete entries in the state store. |
| 29 | - [Inspecting State](https://alchemy.run/cli/inspecting-state) — See what alchemy thinks is deployed, debug a bad diff, and recover from bad state. |
| 30 | - [aws](https://alchemy.run/cli/aws) — AWS provider commands — bootstrap the per-account assets bucket that Lambda deployments rely on. |
| 31 | - [cloudflare](https://alchemy.run/cli/cloudflare) — Cloudflare provider commands — mint API tokens. |
| 32 | |
| 33 | ## Infrastructure as Code |
| 34 | |
| 35 | The noun graph and its semantics: Stacks of Resources and Actions, data flow via Inputs & Outputs and References, deploy behavior via the Resource lifecycle and Providers. |
| 36 | |
| 37 | - [Stacks](https://alchemy.run/infrastructure-as-code/stack) — A Stack is a collection of Resources deployed together as a unit. |
| 38 | - [Resources](https://alchemy.run/infrastructure-as-code/resource) — Resources are named cloud entities with input properties and output attributes. |
| 39 | - [Actions](https://alchemy.run/infrastructure-as-code/action) — A node in the dependency graph that runs an Effect during apply when its inputs change. |
| 40 | - [Inputs & Outputs](https://alchemy.run/infrastructure-as-code/outputs) — Output<T> is alchemy's lazy reference type — the lazy values that flow between resources, get composed with .pipe, mapped, interpolated, and resolved during deploy. |
| 41 | - [References](https://alchemy.run/infrastructure-as-code/references) — Read an already-deployed Resource or Stack at plan time — Resource.ref by Logical ID with optional stack/stage props, or import a Stack tag and depend on its outputs. |
| 42 | - [Resource Lifecycle](https://alchemy.run/infrastructure-as-code/resource-lifecycle) — How alchemy plans, applies, replaces, and destroys resources — and how to think about idempotency and recovery. |
| 43 | - [Renaming Resources](https://alchemy.run/infrastructure-as-code/renaming) — Migrate a resource's state across a logical ID change instead of replacing it. |
| 44 | - [Providers](https://alchemy.run/infrastructure-as-code/provider) — Providers implement the lifecycle operations for a resource type — reconcile, delete, diff, read, and more. |
| 45 | - [Custom Provider](https://alchemy.run/infrastructure-as-code/custom-provider) — Add support for a new cloud or third-party API by declaring a Resource type and implementing its lifecycle as an Effect Layer. |
| 46 | - [Local Provider](https://alchemy.run/infrastructure-as-code/local-provider) — Build the local implementation of a resource — dual registration with ProviderLayer.dual and the LocalProvider runner for long-running processes. |
| 47 | - [DNS Adapters](https://alchemy.run/infrastructure-as-code/dns-adapters) — Publish a custom domain's DNS records in Route 53, Cloudflare, or Hetzner DNS from any platform, and build an adapter for another DNS host. |
| 48 | - [Provider Contributions](https://alchemy.run/infrastructure-as-code/contributions) — Ship a provider's auth, state stores and CLI commands in a package, so the alchemy CLI finds them without a stack. |
| 49 | |
| 50 | ## Infrastructure as Effects |
| 51 | |
| 52 | How app code and infrastructure compose: Runtime, Bindings, the Construction and Runtime Phases, and Layers. |
| 53 | |
| 54 | - [Runtime](https://alchemy.run/infrastructure-as-effects/runtime) — A Runtime is a Resource that carries the code it runs — a Worker, Lambda Function, Container, or Server declared with the Effectful Constructor pattern. Bind what you need, return what you expose. |
| 55 | - [Bindings](https://alchemy.run/infrastructure-as-effects/binding) — A Binding connects a Resource to a Worker or Lambda. One line declares the capability and generates the permissions, the configuration, and a typed client. |
| 56 | - [Layers](https://alchemy.run/infrastructure-as-effects/layers) — A Layer defines a service contract with swappable implementations. In Alchemy, a Layer can encapsulate Resources and Bindings, so shared services carry their own infrastructure and permissions. |
| 57 | - [Event Sources](https://alchemy.run/infrastructure-as-effects/event-sources) — An event source is a binding that runs your Function when something happens on a resource — one call wires the event-source mapping, the permissions, and a typed handler. |
| 58 | - [Sinks](https://alchemy.run/infrastructure-as-effects/sinks) — A Sink is the write-side dual of an Event Source — a Binding that exposes a resource as an Effect Sink, batching writes into the batch API with least-privilege IAM. |
| 59 | - [Phases](https://alchemy.run/infrastructure-as-effects/phases) — Alchemy programs run in two phases — Construction drives the deploy, Runtime handles requests. Knowing which is which is the key to writing Workers and Lambda Functions. |
| 60 | - [Circular Bindings](https://alchemy.run/infrastructure-as-effects/circular-bindings) — How to model two services that reference each other (Worker A ↔ Worker B, Lambda ↔ Lambda) using tagged classes and Layers. |
| 61 | - [Custom Runtime](https://alchemy.run/infrastructure-as-effects/custom-runtime) — Implement your own Runtime resource on the Platform type — a Provider that provisions the compute and bundles the runtime Effect. |
| 62 | - [Telemetry](https://alchemy.run/infrastructure-as-effects/telemetry) — OpenTelemetry is built into every runtime — exporters are Layers, wired to resources through the binding infrastructure, built per event, and flushed as each request completes. |
| 63 | |
| 64 | ## APIs |
| 65 | |
| 66 | Typed calls between Functions and Servers: schemaless RPC for internal communication, Effect RPC and Effect HTTP for trust boundaries. |
| 67 | |
| 68 | - [APIs](https://alchemy.run/apis) — Every Function and Server returns { fetch, ...rpcs } — schemaless typed calls are the default for internal communication; Effect RPC and Effect HTTP add schemas where data crosses a trust boundary. |
| 69 | - [Schemaless RPC](https://alchemy.run/apis/schemaless) — The pattern behind typed, schema-free RPC — what an RPC member may be, how the typed client arises, how calls travel over the wire, and where the limits are. |
| 70 | - [Effect RPC](https://alchemy.run/apis/effect-rpc) — Schema-first RPC for trust boundaries — declare procedures, construct handler Layers, derive typed clients from the same schema. |
| 71 | - [Effect HTTP](https://alchemy.run/apis/effect-http) — Schema-validated REST endpoints with an rpc-like typed interface — for trust boundaries where consumers want a plain HTTP client. |
| 72 | |
| 73 | ## Environments — the same app in many places |
| 74 | |
| 75 | Stages, credential profiles, auth providers, secrets and config, local development, and CI. |
| 76 | |
| 77 | - [Stages](https://alchemy.run/environments/stages) — Stages are isolated instances of a Stack — live_sam, dev_sam, staging, prod, pr-42 — each with their own state and physical names. |
| 78 | - [Profiles](https://alchemy.run/environments/profiles) — Use profiles to select cloud accounts and credentials for each environment. |
| 79 | - [Auth Providers](https://alchemy.run/environments/auth-providers) — An Auth Provider produces the credentials for a cloud's API calls — resolved lazily as Effects, so tokens and role sessions can refresh instead of pinning one static key. |
| 80 | - [Custom Auth Provider](https://alchemy.run/environments/custom-auth-provider) — Add profile and CI credentials for a third-party API with a generated AuthProvider. |
| 81 | - [Secrets & Config](https://alchemy.run/environments/secrets) — Use effect/Config to read env vars at Construction time and have Alchemy automatically bind them onto the deploy target. |
| 82 | - [Secret providers](https://alchemy.run/environments/secret-providers) — Configure a stack with dotenv files, environment variables, Doppler, or Infisical. |
| 83 | - [Doppler](https://alchemy.run/environments/doppler) — Load a Doppler config into your Stack — log in with the browser on your machine, use a service token in CI. |
| 84 | - [Infisical](https://alchemy.run/environments/infisical) — Load an Infisical environment into your Stack — a machine identity on your machine, the platform's own OIDC token in CI. |
| 85 | - [Local development](https://alchemy.run/environments/local-development) — How alchemy dev provides hot reloading, local execution, and local emulation with per-resource opt-in to real cloud services. |
| 86 | - [Worktrees](https://alchemy.run/environments/worktrees) — Run alchemy deploy, dev, and tests from several git worktrees at once — one stage per worktree, so parallel agents never touch each other's resources. |
| 87 | - [CI](https://alchemy.run/environments/ci) — Set up CI/CD pipelines for alchemy projects with GitHub Actions, automated deployments, and PR previews — with provider credentials managed as code. |
| 88 | |
| 89 | ## State Store |
| 90 | |
| 91 | - [State Store](https://alchemy.run/state-store) — How Alchemy persists resource state between deploys to compute diffs and track infrastructure. |
| 92 | - [Custom State Store](https://alchemy.run/state-store/custom-state-store) — Build a Postgres-backed Alchemy state store step by step — implement the StateService interface, plug it into a stack, and test it end-to-end. |
| 93 | |
| 94 | ## Project structure |
| 95 | |
| 96 | Scaling the codebase: file conventions for one stack, monorepos for many — single Stack or one per package. |
| 97 | |
| 98 | - [File layout](https://alchemy.run/project-structure/file-layout) — How to organize an Alchemy project — one file per Resource or Layer, group Resources that travel together by concern, and keep alchemy.run.ts as the composition root. |
| 99 | - [Monorepo](https://alchemy.run/project-structure/monorepo) — Two ways to organize an Alchemy monorepo — one Stack at the workspace root, or one Stack per package wired with typed references. |
| 100 | - [Single Stack](https://alchemy.run/project-structure/monorepo-single-stack) — One alchemy.run.ts at the workspace root deploys every app in the monorepo — one plan, one state file, and every path anchored to the file that declares it. |
| 101 | - [Multiple Stacks](https://alchemy.run/project-structure/monorepo-multi-stack) — Each package owns its own alchemy.run.ts. The frontend consumes the backend's deployed outputs through a typed Stack handle, resolved from the state store at plan time, so each package deploys and destroys independently. |
| 102 | |
| 103 | ## Testing & observability |
| 104 | |
| 105 | Tests run against real clouds: the model, the end-to-end walkthrough, provider-lifecycle testing, and the harness reference. |
| 106 | |
| 107 | - [Testing](https://alchemy.run/testing) — How Alchemy tests work — real clouds by default, local emulators on demand, one Stack deploy per suite, isolated stages, deploy → assert → destroy. |
| 108 | - [Testing a Stack](https://alchemy.run/testing/testing-a-stack) — Deploy your real Stack once per suite, drive it over HTTP, tear it down. |
| 109 | - [Testing Providers](https://alchemy.run/testing/testing-providers) — Exercise a provider's create, update, replace, and delete paths with test.provider and a scratch in-memory stack. |
| 110 | - [Test harness](https://alchemy.run/testing/test-harness) — Reference for @alchemy.run/test — every helper, hook, and option exposed by Test.make, and how to run it with alchemy-test, bun test, or Vitest. |
| 111 | - [Observability](https://alchemy.run/testing/observability) — Effect emits OpenTelemetry natively and the exporter is a Layer. Provision the receiving end — datasets, monitors, notifiers, alarms — as resources in the same Stack as the code that emits the signals. |
| 112 | |
| 113 | ## Cloudflare — start here |
| 114 | |
| 115 | The Cloudflare hub: overview (resources + recipes), setup (install, account, OAuth vs API token, profiles), and local development. |
| 116 | |
| 117 | - [Cloudflare](https://alchemy.run/cloudflare) — Build and deploy full applications on Cloudflare with Alchemy — one Worker runtime plus resources like Durable Objects, D1, R2, Queues, and Hyperdrive, wired together by typed bindings. |
| 118 | - [Setup](https://alchemy.run/cloudflare/setup) — Install Alchemy, create a Cloudflare account, and connect the two — OAuth or API token, saved to a local profile. No environment variables required. |
| 119 | - [Local development](https://alchemy.run/cloudflare/local-development) — alchemy dev runs Workers in workerd with local simulators for KV, R2, D1, Queues, Hyperdrive, Workflows, Containers, and the Worker binding surface — browser rendering, images, email, cron, Stream, and more. |
| 120 | |
| 121 | ## Cloudflare — tutorial |
| 122 | |
| 123 | A linear six-part walkthrough from zero to a tested, locally-developed, CI-deployed, observable Cloudflare project. Each part builds on the previous one. |
| 124 | |
| 125 | - [Part 1: Your First Stack](https://alchemy.run/cloudflare/tutorial/part-1) — Install Alchemy, create a Stack with a Cloudflare R2 Bucket, and deploy it. |
| 126 | - [Part 2: Add a Worker](https://alchemy.run/cloudflare/tutorial/part-2) — Create a Cloudflare Worker, bind the R2 Bucket, and implement GET/PUT routes. |
| 127 | - [Part 3: Testing](https://alchemy.run/cloudflare/tutorial/part-3) — Write integration tests that deploy your stack and make HTTP requests against your live Worker. |
| 128 | - [Part 4: Local Dev](https://alchemy.run/cloudflare/tutorial/part-4) — Run your stack locally with alchemy dev for hot reloading and instant feedback. |
| 129 | - [Part 5: CI/CD](https://alchemy.run/cloudflare/tutorial/part-5) — Set up GitHub Actions for automated deployments, PR previews, and remote state — with Cloudflare credentials managed as code. |
| 130 | - [Part 6: Observability](https://alchemy.run/cloudflare/tutorial/part-6) — Ship your Worker traces and logs to Axiom — datasets, an ingest token, and the Axiom.Telemetry binding layer declared in the same Stack as the Worker they observe. |
| 131 | |
| 132 | ## Cloudflare — Compute |
| 133 | |
| 134 | - [Worker Previews](https://alchemy.run/cloudflare/compute/previews) — Deploy a branch or pull request as a first-class Preview of another Worker — its own URL, bindings, and isolated Durable Object state, without touching production traffic. |
| 135 | - [Accept WebSockets](https://alchemy.run/cloudflare/compute/hibernatable-websockets) — Accept WebSocket connections in a Durable Object, broadcast between peers, and survive Cloudflare's hibernation. |
| 136 | - [Bind to another Worker's Durable Object](https://alchemy.run/cloudflare/compute/cross-worker-durable-object) — Share a Durable Object across multiple Workers — one Worker hosts the runtime, others bind to it by scriptName for a typed RPC stub — and move the host later with the data intact. |
| 137 | - [Add a Workflow](https://alchemy.run/cloudflare/compute/add-a-workflow) — Orchestrate durable, multi-step work with Cloudflare Workflows — automatic retries, replayable steps, and at-least-once delivery. |
| 138 | - [Run a Container](https://alchemy.run/cloudflare/compute/run-a-container) — Run a long-lived container alongside a Durable Object, expose RPC methods, and proxy HTTP requests to ports inside the container. |
| 139 | - [Rate limiting](https://alchemy.run/cloudflare/compute/rate-limiting) — Throttle requests inside a Worker with Cloudflare's Rate Limiting binding — declare the limit on the binding, count arbitrary keys at runtime, handle failures as typed errors. |
| 140 | - [Workers Cache](https://alchemy.run/cloudflare/compute/cache) — Serve responses from Cloudflare's edge cache before your Worker even runs — enable it with one yield, control it with standard headers, purge it by tag from inside a handler. |
| 141 | - [Browser rendering](https://alchemy.run/cloudflare/compute/browser-rendering) — Attach Cloudflare Browser Rendering to a Worker — run quick actions like markdown and scrape, stream screenshots and PDFs, or drive the raw binding with puppeteer. |
| 142 | - [Worker Loader](https://alchemy.run/cloudflare/compute/worker-loader) — Load and run ephemeral Workers at runtime from inline source — each in its own sandboxed isolate, with optional outbound-network control and typed RPC entrypoints. |
| 143 | - [Workers for Platforms](https://alchemy.run/cloudflare/compute/workers-for-platforms) — Run your customers' Workers in your own account — create a dispatch namespace, upload user Workers into it, and route requests from a platform Worker with the Get binding. |
| 144 | - [Code updates](https://alchemy.run/cloudflare/compute/code-updates) — What happens to running Workers and Durable Objects when you deploy, how to choose when Durable Objects pick up new code, and how to write tests that see the code you just deployed. |
| 145 | - [Container lifecycle](https://alchemy.run/cloudflare/compute/container-lifecycle) — Start, stop, wait for, and restore a Cloudflare Container from its Durable Object — and save its filesystem as a snapshot to restore later. |
| 146 | - [Containers](https://alchemy.run/cloudflare/compute/containers) — Cloudflare Containers run long-lived processes beside a Durable Object — declare a typed container class, implement its runtime in a separate file, and alchemy builds the image, pushes it, and wires the DO pairing. |
| 147 | - [Durable Objects](https://alchemy.run/cloudflare/compute/durable-objects) — Durable Objects are globally-unique stateful instances with transactional storage — define one as an Effect, persist state per key, expose typed RPC methods, and stream values back to the caller. |
| 148 | - [Effect workflows](https://alchemy.run/cloudflare/compute/effect-workflows) — Run Effect workflows on Cloudflare, on Durable Objects or Cloudflare Workflows. Declare a workflow with effect/workflow, implement it with Workflows.layer, start runs with Workflows.RunWorkflow, and let them sleep, wait for signals and undo steps durably. |
| 149 | - [Gradual deployments](https://alchemy.run/cloudflare/compute/gradual-deployments) — Roll out Worker deploys incrementally — upload preview versions, canary a percentage of live traffic, ramp to 100%, pin users to a version during the rollout, and verify which version served each request. |
| 150 | - [Python Workers](https://alchemy.run/cloudflare/compute/python-workers) — Deploy Cloudflare Python Workers by pointing main at a .py file — alchemy uploads the modules, vendors pyproject.toml dependencies with uv, and serves them locally through workerd's built-in Pyodide. |
| 151 | - [Workers](https://alchemy.run/cloudflare/compute/workers) — Cloudflare Workers are the compute Runtime of every Alchemy app — declare the Worker and its handler in one file, bind resources with full type safety, and call other Workers over schemaless RPC. |
| 152 | - [Workflows](https://alchemy.run/cloudflare/compute/workflows) — Cloudflare Workflows run durable multi-step jobs — define a typed workflow class, checkpoint steps with task and sleep, trigger instances from a Worker, and poll status until completion. |
| 153 | |
| 154 | ## Cloudflare — Frontend |
| 155 | |
| 156 | - [Frontend frameworks](https://alchemy.run/cloudflare/frontend/frontends) — Deploy Vite, Foldkit, Astro, Next.js, vinext, Nuxt, SvelteKit, Waku, or any static build to Cloudflare Workers with first-class Website resources. |
| 157 | - [Vite](https://alchemy.run/cloudflare/frontend/vite) — Deploy any pure-Vite app to Cloudflare Workers with a single resource. |
| 158 | - [Static sites](https://alchemy.run/cloudflare/frontend/static-site) — Deploy any build command's output directory as Cloudflare Worker static assets with Cloudflare.Website.StaticSite — custom edge Workers, framework-native local dev, and memoized rebuilds. |
| 159 | - [Add a React SPA](https://alchemy.run/cloudflare/frontend/vite-spa) — Ship a React single-page app from the same Stack as your Worker — built with Vite and deployed to Cloudflare in one command. |
| 160 | - [TanStack Start](https://alchemy.run/cloudflare/frontend/tanstack-start) — Deploy TanStack Start (React or Solid) to Cloudflare with Cloudflare.Website.Vite — SSR, typed Worker bindings, and HMR dev with real cloud resources. |
| 161 | - [Full-stack TanStack Start + RPC + Drizzle](https://alchemy.run/cloudflare/frontend/full-stack-tanstack-rpc-drizzle) — Build a reactive full-stack app on Cloudflare — a TanStack Start UI that drives an Effect RPC backend over Drizzle and Neon Postgres, with browser state wired through Effect 4's native atom RPC. |
| 162 | - [React Router](https://alchemy.run/cloudflare/frontend/react-router) — Deploy React Router v8 — including React Server Components — to Cloudflare with Cloudflare.Website.Vite and viteEnvironments. |
| 163 | - [Vue](https://alchemy.run/cloudflare/frontend/vue) — Deploy a Vue single-page app to Cloudflare with the Vite resource — one declaration, no Wrangler config. |
| 164 | - [Foldkit](https://alchemy.run/cloudflare/frontend/foldkit) — Deploy Foldkit SPA, SSR, SSG, and hybrid applications to Cloudflare Workers. |
| 165 | - [SolidStart](https://alchemy.run/cloudflare/frontend/solidstart) — Deploy SolidStart to Cloudflare with Cloudflare.Website.Vite — plus the hand-rolled SolidJS SSR variant for full control over the server entry. |
| 166 | - [Astro](https://alchemy.run/cloudflare/frontend/astro) — Deploy an Astro site to Cloudflare Workers with Cloudflare.Website.Astro — SSR in the Worker, prerendered pages as static assets, sessions backed by an auto-provisioned KV namespace, and route caching on Workers Cache. |
| 167 | - [Next.js](https://alchemy.run/cloudflare/frontend/nextjs) — Deploy a Next.js app to Cloudflare Workers with Cloudflare.Website.Nextjs — the OpenNext pipeline, writable ISR, and wrangler-free local dev. |
| 168 | - [Vinext](https://alchemy.run/cloudflare/frontend/vinext) — Deploy vinext to Cloudflare Workers with the shared Website API, native local development, and KV-backed caching. |
| 169 | - [Nuxt](https://alchemy.run/cloudflare/frontend/nuxt) — Deploy a Nuxt app to Cloudflare Workers with Cloudflare.Website.Nuxt — nitro's cloudflare_module preset, native nuxt.config.ts loading, and wrangler-free local dev. |
| 170 | - [SvelteKit](https://alchemy.run/cloudflare/frontend/sveltekit) — Deploy a SvelteKit app to Cloudflare Workers with Cloudflare.Website.SvelteKit — a wrangler-free in-memory adapter, real bindings on platform.env, and full-HMR local dev. |
| 171 | - [Waku](https://alchemy.run/cloudflare/frontend/waku) — Deploy a Waku app to Cloudflare Workers with Cloudflare.Website.Waku — RSC server in the Worker, SSG pages as static assets, and a custom-entry seam for Durable Objects. |
| 172 | - [Octane](https://alchemy.run/cloudflare/frontend/octane) — Deploy an OctaneJS fullstack app to Cloudflare Workers with Cloudflare.Website.Octane — native Octane and Vite configuration, no hosting adapter or Wrangler file required. |
| 173 | |
| 174 | ## Cloudflare — APIs |
| 175 | |
| 176 | - [Schemaless RPC](https://alchemy.run/cloudflare/apis/schemaless-rpc) — Typed RPC between Workers, Durable Objects, and Containers with no schema — bind the class, get the client. |
| 177 | - [Effect HTTP API](https://alchemy.run/cloudflare/apis/effect-http-api) — Build a schema-validated HTTP API with Effect's HttpApi module and deploy it as a Cloudflare Worker. |
| 178 | - [Effect RPC](https://alchemy.run/cloudflare/apis/effect-rpc) — Build a typed RPC API with Effect's Rpc module and deploy it as a Cloudflare Worker. |
| 179 | |
| 180 | ## Cloudflare — Data |
| 181 | |
| 182 | - [Store Git Repos with Artifacts](https://alchemy.run/cloudflare/data/artifacts) — Use Cloudflare Artifacts to create Git repos at runtime and hand out clone tokens, all from a tiny Worker. |
| 183 | - [Add Drizzle ORM](https://alchemy.run/cloudflare/data/drizzle) — Deploy a Cloudflare Worker with Drizzle queries, Hyperdrive connections, and reviewed, committed migrations on Neon or PlanetScale. |
| 184 | - [Branch from a shared database](https://alchemy.run/cloudflare/data/branch-from-shared-database) — Have ephemeral PR-preview stages reference a long-lived Neon or PlanetScale database from a staging stage instead of provisioning their own — fast previews, cheap branches, no extra clusters. |
| 185 | - [D1](https://alchemy.run/cloudflare/data/d1) — Cloudflare D1 is serverless SQLite — create a database, apply migrations on deploy, and query it from a Worker through a typed binding. |
| 186 | - [Drizzle on D1](https://alchemy.run/cloudflare/data/d1-drizzle) — Deploy committed SQLite migrations to D1 and query the database from a Worker with Drizzle. |
| 187 | - [Hyperdrive](https://alchemy.run/cloudflare/data/hyperdrive) — Cloudflare Hyperdrive pools connections to your external Postgres or MySQL database at the edge — provision a database (Neon or PlanetScale), front it with Hyperdrive, and bind the connection into your Worker. |
| 188 | - [Iceberg tables](https://alchemy.run/cloudflare/data/iceberg-tables) — Turn an R2 bucket into an Apache Iceberg warehouse with Cloudflare's catalog, manage tables with schema evolution and maintenance, and query them from Spark, DuckDB, or PyIceberg. |
| 189 | - [KV](https://alchemy.run/cloudflare/data/kv) — Cloudflare Workers KV is edge key-value storage — create a namespace, bind it into a Worker with read/write-scoped bindings, and get/put values with metadata. |
| 190 | - [Pipelines](https://alchemy.run/cloudflare/data/pipelines) — Ingest events into R2 with Cloudflare Pipelines — a typed stream, a SQL pipeline, and a sink that writes JSON or Parquet files, or Apache Iceberg tables. |
| 191 | - [Prisma ORM with Postgres](https://alchemy.run/cloudflare/data/prisma) — Deploy Prisma ORM v8 on Cloudflare Workers with Neon Postgres, Hyperdrive, controlled migrations, and Effect-native queries. |
| 192 | - [Private database (Workers VPC)](https://alchemy.run/cloudflare/data/hyperdrive-private-database) — Connect Hyperdrive to a database inside a private network — such as Aurora in an AWS VPC — through a Cloudflare Tunnel and a Workers VPC Service, with no public endpoint. |
| 193 | - [R2](https://alchemy.run/cloudflare/data/r2) — Cloudflare R2 is object storage — create a bucket, bind it into a Worker with read/write-scoped bindings, and stream objects in and out. |
| 194 | - [R2 presigned URLs](https://alchemy.run/cloudflare/data/r2-presigned-urls) — Mint presigned R2 URLs so browsers upload and download objects directly, with the same code in alchemy dev and in production, from Effect-native or async Workers. |
| 195 | - [Shared database across stages](https://alchemy.run/cloudflare/data/shared-database) — Have ephemeral PR-preview stages reference a long-lived Neon or PlanetScale database from a staging stage instead of provisioning their own — fast previews, copy-on-write branches, no extra clusters. |
| 196 | |
| 197 | ## Cloudflare — Messaging & events |
| 198 | |
| 199 | - [Scheduled jobs with Cron Triggers](https://alchemy.run/cloudflare/messaging/cron) — Run Worker code on a schedule — declare a cron expression with an Effect handler, deploy it, and prove the trigger fires with a bounded polling test. |
| 200 | - [React to GitHub events from a Worker](https://alchemy.run/cloudflare/messaging/github-events) — Subscribe a Cloudflare Worker to GitHub repository webhooks with typed payloads — alchemy provisions the webhook and verifies delivery signatures. |
| 201 | - [K2 streams](https://alchemy.run/cloudflare/messaging/k2) — Cloudflare K2 is a durable, replayable log. Produce records from Workers with the WriteStream binding, then consume them from a long-running host with consumeStreamRecords. |
| 202 | - [Queues](https://alchemy.run/cloudflare/messaging/queues) — Cloudflare Queues give you reliable, at-least-once message delivery between Workers — a WriteQueue producer binding on one side and an Effect-style consumeQueueMessages handler with automatic ack/retry on the other. |
| 203 | |
| 204 | ## Cloudflare — Email |
| 205 | |
| 206 | - [Send & receive email](https://alchemy.run/cloudflare/email/send-and-receive) — Enable Email Routing on a zone, verify destination addresses, forward inbound mail with rules and a catch-all, and send email from a Worker with the send_email binding. |
| 207 | - [Receive email in a Worker](https://alchemy.run/cloudflare/email/email-worker) — Receive inbound mail in a Cloudflare Worker with Cloudflare.email({ zone }).subscribe(...) — auto-creates routing and forwarding rules. |
| 208 | - [Email](https://alchemy.run/cloudflare/email) — Cloudflare Email Routing turns a zone into a mail endpoint — enable routing, verify destinations, forward with rules and a catch-all, hand mail to a Worker, and send from Workers with the send_email binding. |
| 209 | |
| 210 | ## Cloudflare — AI |
| 211 | |
| 212 | - [Run Workers AI models](https://alchemy.run/cloudflare/ai/workers-ai) — Bind Workers AI into your Worker with Cloudflare.Workers.AI — run inference and list models directly, or turn the binding into a typed Effect LanguageModel, no gateway required. |
| 213 | - [Effect AI](https://alchemy.run/cloudflare/ai/effect-ai) — Wire Effect's LanguageModel and Chat services into a Cloudflare Worker — read API keys with effect/Config, provide the model layer to your handler, plug in persistence. |
| 214 | - [Add an AI Gateway](https://alchemy.run/cloudflare/ai/ai-gateway) — Wire an AI Gateway into your Worker, turn it into a typed Effect LanguageModel, and run generations and streams through Workers AI with caching, rate limiting, and logs. |
| 215 | - [Add AI Search (AutoRAG)](https://alchemy.run/cloudflare/ai/ai-search) — Stand up a Cloudflare AI Search (AutoRAG) pipeline over an R2 bucket with one Search call, bind it into your Worker as a typed Effect client, and answer questions over your own documents. |
| 216 | - [Vector search with Vectorize](https://alchemy.run/cloudflare/ai/vectorize) — Create a Vectorize index, bind it to a Worker with SearchIndex, and run filtered nearest-neighbor queries over vector embeddings. |
| 217 | |
| 218 | ## Cloudflare — Security & secrets |
| 219 | |
| 220 | - [Secrets Store & auth tokens](https://alchemy.run/cloudflare/security/secrets-store) — Store secrets in Cloudflare's account-level Secrets Store, generate stable tokens with Alchemy.Random, and read them in a Worker through the ReadSecret binding. |
| 221 | - [Protect a Worker with Access](https://alchemy.run/cloudflare/security/access) — Put Cloudflare Access in front of a Worker with the access prop — per-Worker policies, shared applications, ctx.access identity at runtime, and a local dev simulation. |
| 222 | - [Turnstile CAPTCHA](https://alchemy.run/cloudflare/security/turnstile) — Manage Cloudflare Turnstile widgets as resources — deploy a widget, embed its sitekey in HTML, and verify tokens server-side with the redacted secret. |
| 223 | - [Secrets & env](https://alchemy.run/cloudflare/security/secrets-env) — Bind env vars and secrets to Workers with effect/Config, generate stable tokens with Alchemy.Random, and graduate to Secrets Store when secrets are shared across Workers. |
| 224 | |
| 225 | ## Cloudflare — Observability |
| 226 | |
| 227 | - [Native Workers tracing](https://alchemy.run/cloudflare/observability/workers-tracing) — Mirror Effect spans into Cloudflare Workers Observability with Cloudflare.Telemetry() — the same Layer shape as Axiom.Telemetry, with Cloudflare owning sampling and export. |
| 228 | - [Ship Worker telemetry to Axiom](https://alchemy.run/cloudflare/observability/axiom-observability) — Declare Axiom datasets, a least-privilege ingest token, and monitors in the same Stack as the Worker that emits the telemetry — or let Cloudflare push Workers Logs to Axiom natively. |
| 229 | - [Analytics Engine](https://alchemy.run/cloudflare/observability/analytics-engine) — Write time-series data points from a Worker with Workers Analytics Engine — declare a dataset, bind it with WriteDataset, and query it later over Cloudflare's SQL API. |
| 230 | |
| 231 | ## Cloudflare — Networking |
| 232 | |
| 233 | - [Custom domains & routes](https://alchemy.run/cloudflare/networking/custom-domains) — Serve Workers from your own domain — create or adopt a Zone, attach custom domains, route hostname patterns, manage DNS records, and control the workers.dev subdomain. |
| 234 | - [Federated APIs](https://alchemy.run/cloudflare/networking/federated-apis) — Serve one API at one URL from many Workers — each path handled by its own least-privilege Worker, routed by Cloudflare's zone routes with no gateway Worker, and emulated locally by alchemy dev. |
| 235 | - [Expose private origins with Tunnel](https://alchemy.run/cloudflare/networking/tunnel) — Connect a private origin to Cloudflare's edge with a Tunnel, declare its ingress rules as a Configuration resource, and point DNS at it with a proxied CNAME. |
| 236 | - [Domains & DNS](https://alchemy.run/cloudflare/networking/domains) — Manage Cloudflare zones, DNS records, DNSSEC, and zone settings as resources — and safely adopt the domains you already have. |
| 237 | |
| 238 | ## Prisma — start here |
| 239 | |
| 240 | - [Prisma](https://alchemy.run/prisma) — Prisma Postgres and Prisma Compute — projects, databases, connections, and deployed apps as Stack resources, with a zero-config local database in dev. |
| 241 | - [Setup](https://alchemy.run/prisma/setup) — Connect alchemy to Prisma — account, service tokens, and profiles. |
| 242 | |
| 243 | ## Prisma — tutorial |
| 244 | |
| 245 | A four-part walkthrough: a Project, an Effect-native Compute API, Postgres, and a Vite frontend. |
| 246 | |
| 247 | - [Part 1: Your First Project](https://alchemy.run/prisma/tutorial/part-1) — Install Alchemy, configure Prisma credentials, and deploy your first Project. |
| 248 | - [Part 2: An HTTP API](https://alchemy.run/prisma/tutorial/part-2) — Deploy an Effect-native Prisma Compute service and add an HTTP health endpoint. |
| 249 | - [Part 3: Query Postgres](https://alchemy.run/prisma/tutorial/part-3) — Create Prisma Postgres, bind its connection to Compute, and query it with Effect SQL. |
| 250 | - [Part 4: A Vite Frontend](https://alchemy.run/prisma/tutorial/part-4) — Connect a Vite frontend to your Prisma API, develop locally, and destroy the tutorial resources. |
| 251 | |
| 252 | ## Prisma — Compute |
| 253 | |
| 254 | - [Apps](https://alchemy.run/prisma/compute/apps) — Prisma Compute apps as Stack resources — framework builds or Effect-native services, env wiring, custom domains, and a local dev command. |
| 255 | - [Deployments](https://alchemy.run/prisma/compute/deployments) — The fail-closed Compute deployment lifecycle — health-checked promotion, rollback recovery, old-generation cleanup, and env-only redeploys. |
| 256 | |
| 257 | ## Prisma — Data |
| 258 | |
| 259 | - [Branches](https://alchemy.run/prisma/data/branches) — Prisma branches group databases under git-style names — preview branches per stage, default-branch promotion, and database attachment. |
| 260 | - [Buckets](https://alchemy.run/prisma/data/buckets) — Prisma Buckets provision S3-compatible object storage inside a project, and Bucket access keys mint the S3 credentials — access key, one-time secret, endpoint, and the provider-side bucket name. |
| 261 | - [Connections](https://alchemy.run/prisma/data/connections) — Prisma Connections materialize database credentials — a conventional databaseUrl, direct and pooled connection strings, parsed origins for Hyperdrive, and the Connect runtime binding. |
| 262 | - [Drizzle Postgres on Prisma Compute](https://alchemy.run/prisma/data/drizzle-postgres) — Use Alchemy's Prisma hosting provider to run a Drizzle API against Prisma Postgres. |
| 263 | - [Postgres](https://alchemy.run/prisma/data/postgres) — Prisma Postgres as Stack resources — projects, databases, branch attachment, and a zero-config local database under alchemy dev. |
| 264 | |
| 265 | ## Prisma — Frontend |
| 266 | |
| 267 | - [Websites](https://alchemy.run/prisma/frontend/websites) — Deploy Vite, Astro, Next.js, Nuxt, React Router, SolidStart, SvelteKit, TanStack Start, Waku, Octane, Foldkit, Vocs, or any static build to Prisma Compute. |
| 268 | - [Vite](https://alchemy.run/prisma/frontend/vite) — Deploy a Vite SPA to Prisma Compute with Prisma.Website.Vite — static files served on Bun and Vite's native dev server locally. |
| 269 | - [Static sites](https://alchemy.run/prisma/frontend/static-site) — Deploy any static build to Prisma Compute with Prisma.Website.StaticSite — a shell command, output directory, and Bun static-file server. |
| 270 | - [React Router](https://alchemy.run/prisma/frontend/react-router) — Deploy React Router v8 framework apps to Prisma Compute with Prisma.Website.ReactRouter — SSR on Bun and native Vite dev locally. |
| 271 | - [Foldkit](https://alchemy.run/prisma/frontend/foldkit) — Deploy Foldkit SPA, SSR, SSG, and hybrid applications to Prisma Compute with native local development. |
| 272 | - [TanStack Start](https://alchemy.run/prisma/frontend/tanstack-start) — Deploy TanStack Start to Prisma Compute with Prisma.Website.TanStackStart — React or Solid SSR on Bun, with native Vite dev locally. |
| 273 | - [Next.js](https://alchemy.run/prisma/frontend/nextjs) — Deploy Next.js to Prisma Compute with Prisma.Website.Nextjs — a normal Next server on Bun, not OpenNext, and next dev locally. |
| 274 | - [Vinext](https://alchemy.run/prisma/frontend/vinext) — Deploy vinext to Prisma Compute with the shared Website API, native local development, and traced runtime dependencies. |
| 275 | - [Nuxt](https://alchemy.run/prisma/frontend/nuxt) — Deploy Nuxt to Prisma Compute with Prisma.Website.Nuxt — Nitro's Node target running on Bun and Nuxt's own dev server locally. |
| 276 | - [Vocs](https://alchemy.run/prisma/frontend/vocs) — Deploy Vocs documentation to Prisma Compute with Prisma.Website.Vocs — static assets and Waku RSC on Bun, with Vocs dev locally. |
| 277 | - [SolidStart](https://alchemy.run/prisma/frontend/solidstart) — Deploy SolidStart to Prisma Compute with Prisma.Website.SolidStart — Nitro's Node target on Bun and SolidStart's native Vite dev server locally. |
| 278 | - [Astro](https://alchemy.run/prisma/frontend/astro) — Deploy Astro SSR or a fully static site to Prisma Compute with Prisma.Website.Astro, running on Bun with native Astro dev locally. |
| 279 | - [SvelteKit](https://alchemy.run/prisma/frontend/sveltekit) — Deploy SvelteKit to Prisma Compute with Prisma.Website.SvelteKit — SSR and prerendered assets on Bun, with native Vite dev locally. |
| 280 | - [Waku](https://alchemy.run/prisma/frontend/waku) — Deploy Waku to Prisma Compute with Prisma.Website.Waku — React Server Components and static pages on Bun, with Waku's native dev server locally. |
| 281 | - [Octane](https://alchemy.run/prisma/frontend/octane) — Deploy OctaneJS to Prisma Compute with Prisma.Website.Octane — the Node target on Bun, SSR plus client assets, and native Vite dev locally. |
| 282 | |
| 283 | ## Prisma — Guides |
| 284 | |
| 285 | - [Connect from Cloudflare Workers](https://alchemy.run/prisma/guides/cloudflare-workers) — Two ways to reach Prisma Postgres from a Worker — the Connect binding for credentials, or Hyperdrive in front of the direct origin for edge-pooled SQL. |
| 286 | |
| 287 | ## AWS — start here |
| 288 | |
| 289 | The AWS hub: overview (runtimes + resources + recipes), setup (credentials, profiles, region), local development, and the Lambda vs ECS vs EKS vs EC2 decision page. |
| 290 | |
| 291 | - [AWS](https://alchemy.run/aws) — Build AWS applications with Alchemy — a runtime (usually Lambda) plus typed resources, wired together by bindings that mint least-privilege IAM policies. |
| 292 | - [Setup](https://alchemy.run/aws/setup) — Connect Alchemy to AWS with SSO, console login, stored access keys, or CI environment credentials. |
| 293 | - [Local development](https://alchemy.run/aws/local-development) — alchemy dev runs your AWS stack on your machine — Lambda in Docker containers, local S3/DynamoDB/SQS, event sources firing, hot reload — with no AWS account or credentials required. |
| 294 | - [Choosing a runtime](https://alchemy.run/aws/compute/choosing-a-runtime) — Lambda vs ECS vs EKS vs EC2 for Alchemy apps — cold starts, cost shape, packaging, and how much of each Alchemy currently covers. |
| 295 | |
| 296 | ## AWS — tutorial |
| 297 | |
| 298 | A linear five-part walkthrough from zero to a tested, CI-deployed AWS project. Each part builds on the previous one. |
| 299 | |
| 300 | - [Part 1: Your First Stack](https://alchemy.run/aws/tutorial/part-1) — Install Alchemy, create a Stack with an AWS S3 Bucket, and deploy it. |
| 301 | - [Part 2: Add a Lambda](https://alchemy.run/aws/tutorial/part-2) — Create an AWS Lambda Function with a public URL, bind the S3 Bucket, and implement GET/PUT routes. |
| 302 | - [Part 3: Testing](https://alchemy.run/aws/tutorial/part-3) — Write integration tests that deploy your stack and make HTTP requests against your live Lambda Function URL. |
| 303 | - [Part 4: Stages](https://alchemy.run/aws/tutorial/part-4) — Deploy isolated dev, staging, and prod instances of your stack with --stage, and tune resources per stage. |
| 304 | - [Part 5: CI/CD](https://alchemy.run/aws/tutorial/part-5) — Set up GitHub Actions for automated AWS deployments and PR previews — with OIDC credentials provisioned as code. |
| 305 | |
| 306 | ## AWS — Compute |
| 307 | |
| 308 | - [Lambda MicroVMs](https://alchemy.run/aws/compute/microvms) — Build a Firecracker MicroVM image from TypeScript or a Dockerfile, then launch and drive isolated stateful instances from a Lambda Function with typed lifecycle bindings and RPC. |
| 309 | - [EC2](https://alchemy.run/aws/compute/ec2) — Launch virtual machines with the Instance resource — as a raw compute primitive, or hosting a bundled long-lived Effect program served straight off the box. |
| 310 | - [ECS](https://alchemy.run/aws/compute/ecs) — Run containers on AWS with ECS and Fargate — Task definitions that run to completion, Services that keep containers running behind a load balancer, with images bundled from an Effect program, built from your Dockerfile, or mirrored from a registry. |
| 311 | - [Effect workflows](https://alchemy.run/aws/compute/effect-workflows) — Run Effect workflows on AWS Lambda durable functions. Host them in an AWS.Lambda.WorkflowFunction, start runs from other functions with AWS.Lambda.DurableFunctionEngine, and let them sleep and wait durably. |
| 312 | - [EKS](https://alchemy.run/aws/compute/eks) — Stand up an EKS Auto Mode cluster on a Network and run containers on it — Deployments for servers, Jobs for run-to-completion work, Manifests for everything else. No YAML, no kubectl. |
| 313 | - [HyperPod](https://alchemy.run/aws/compute/hyperpod) — Provision SageMaker HyperPod clusters — Slurm or EKS orchestrated — and run ML workloads on them with sbatch, raw manifests, or effectful Jobs with task governance. |
| 314 | - [Lambda](https://alchemy.run/aws/compute/lambda) — Stand up an AWS Lambda Function from a single Effect, expose it over a Function URL, and call it from a test. |
| 315 | - [Lambda Web Functions](https://alchemy.run/aws/compute/web-functions) — Run an HTTP server on AWS Lambda Web Functions — an Effect fetch handler or any Node server, with streaming responses, many concurrent requests per environment, and a built-in HTTPS endpoint. |
| 316 | |
| 317 | ## AWS — Frontend |
| 318 | |
| 319 | - [Websites](https://alchemy.run/aws/frontend/websites) — Deploy Vite, Astro, Next.js, vinext, Nuxt, React Router, SvelteKit, TanStack Start, Waku, Octane, or any static build to AWS with first-class Website resources. |
| 320 | - [Vite](https://alchemy.run/aws/frontend/vite) — Deploy a plain Vite app to AWS with AWS.Website.Vite — the vite build output on S3 behind CloudFront, SPA fallback at the edge, and Vite's own dev server under alchemy dev. |
| 321 | - [Foldkit](https://alchemy.run/aws/frontend/foldkit) — Deploy Foldkit SPA, SSR, SSG, and hybrid applications to AWS with native local development. |
| 322 | - [Static sites](https://alchemy.run/aws/frontend/static-site) — Ship a static site to S3 + CloudFront with AWS.Website.StaticSite — build-step support, Router composition, and cache invalidation on deploy. |
| 323 | - [React SPA](https://alchemy.run/aws/frontend/vite-spa) — Deploy a React single-page app to AWS with AWS.Website.Vite — the Vite build on S3 + CloudFront, deep links answered by index.html out of the box, and Vite's own dev server under alchemy dev. |
| 324 | - [Vue](https://alchemy.run/aws/frontend/vue) — Deploy a Vue single-page app to AWS with AWS.Website.Vite — S3 + CloudFront, deep links that work by default, and Vue's own Vite dev server under alchemy dev. |
| 325 | - [React Router](https://alchemy.run/aws/frontend/react-router) — Deploy React Router v8 (framework mode) to AWS with AWS.Website.ReactRouter — SSR on a Lambda Web Function, client assets on S3 + CloudFront, and React Router's own Vite dev server under alchemy dev. |
| 326 | - [TanStack Start](https://alchemy.run/aws/frontend/tanstack-start) — Deploy TanStack Start (React or Solid) to AWS with AWS.Website.TanStackStart — SSR on a Lambda Web Function, client assets on S3 + CloudFront, and TanStack Start's own Vite dev server under alchemy dev. |
| 327 | - [Next.js](https://alchemy.run/aws/frontend/nextjs) — Deploy a Next.js app to AWS with AWS.Website.Nextjs — Next's own server on a Lambda Web Function with a shared S3 cache, S3 assets behind CloudFront, and next dev under alchemy dev. |
| 328 | - [Vinext](https://alchemy.run/aws/frontend/vinext) — Deploy vinext to AWS with the shared Website API, native local development, and a platform-specific data cache. |
| 329 | - [Nuxt](https://alchemy.run/aws/frontend/nuxt) — Deploy a Nuxt app to AWS with AWS.Website.Nuxt — the nitro server on a Lambda Web Function, S3 assets behind CloudFront, and Nuxt's own dev server under alchemy dev. |
| 330 | - [SolidStart](https://alchemy.run/aws/frontend/solidstart) — Deploy a SolidStart app to AWS with AWS.Website.SolidStart — SSR on a Lambda Web Function, S3 assets behind CloudFront, and SolidStart's own Vite dev server under alchemy dev. |
| 331 | - [Astro](https://alchemy.run/aws/frontend/astro) — Deploy an Astro app to AWS with AWS.Website.Astro — SSR on a Lambda Web Function, static output on S3 + CloudFront, and Astro's own dev server under alchemy dev. |
| 332 | - [SvelteKit](https://alchemy.run/aws/frontend/sveltekit) — Deploy a SvelteKit app to AWS with AWS.Website.SvelteKit — SSR on a Lambda Web Function, assets and prerendered pages on S3 + CloudFront, and Kit's own dev server under alchemy dev. |
| 333 | - [Waku](https://alchemy.run/aws/frontend/waku) — Deploy a Waku app to AWS with AWS.Website.Waku — RSC server on a Lambda Web Function, SSG pages and assets on S3 + CloudFront, and Waku's own dev server under alchemy dev. |
| 334 | - [Octane](https://alchemy.run/aws/frontend/octane) — Deploy an OctaneJS app to AWS with AWS.Website.Octane — SSR on a Lambda Web Function, assets on S3 + CloudFront, and Octane's own Vite dev server under alchemy dev. |
| 335 | - [Full-stack TanStack Start + RPC + Drizzle](https://alchemy.run/aws/frontend/full-stack-tanstack-rpc-drizzle) — Build a reactive full-stack app on AWS — a TanStack Start UI on CloudFront and Lambda that drives an Effect RPC Lambda over Drizzle and Aurora DSQL, with browser state wired through Effect 4's native atom RPC. |
| 336 | |
| 337 | ## AWS — APIs |
| 338 | |
| 339 | - [Schemaless RPC](https://alchemy.run/aws/apis/schemaless-rpc) — Typed RPC from a Lambda Function into a MicroVM with no schema — declare the image's Shape, connect, get the client. |
| 340 | - [Effect HTTP API on Lambda](https://alchemy.run/aws/apis/effect-http-api) — Build a schema-validated HTTP API with Effect's HttpApi module and deploy it as an AWS Lambda Function behind a Function URL. |
| 341 | - [Effect RPC on Lambda](https://alchemy.run/aws/apis/effect-rpc) — Build a typed RPC API with Effect's Rpc module and deploy it as an AWS Lambda Function behind a Function URL. |
| 342 | - [REST API (API Gateway v1)](https://alchemy.run/aws/apis/api-gateway) — Expose a Lambda with a regional Amazon API Gateway REST API using RestApi, Resource, Method, Deployment, and Stage primitives. |
| 343 | |
| 344 | ## AWS — Data |
| 345 | |
| 346 | - [Drizzle + Aurora DSQL](https://alchemy.run/aws/data/drizzle-dsql) — Drizzle on Lambda with Aurora DSQL, a non-admin database role, verified TLS, and an explicit DSQL migration boundary. |
| 347 | - [Drizzle + Aurora PostgreSQL](https://alchemy.run/aws/data/drizzle-aurora) — Drizzle on Lambda with private Aurora PostgreSQL, IAM authentication, verified TLS, and reviewed SQL migrations. |
| 348 | - [DynamoDB](https://alchemy.run/aws/data/dynamodb) — Add a DynamoDB Table, bind GetItem and PutItem to your Lambda, and serve a typed key/value HTTP API backed by DynamoDB. |
| 349 | - [RDS & Aurora](https://alchemy.run/aws/data/rds) — Stand up an Aurora cluster in one call with the Aurora helper, connect from Lambda over the Connect binding with Effect SQL, or skip connections entirely with the Data API. |
| 350 | - [S3](https://alchemy.run/aws/data/s3) — Add an S3 Bucket to your Stack, bind PutObject and GetObject as runtime capabilities, and let Alchemy mint the IAM policy for you. |
| 351 | |
| 352 | ## AWS — AI |
| 353 | |
| 354 | - [Bedrock & Effect AI](https://alchemy.run/aws/ai/bedrock) — Drive Effect's LanguageModel service with Amazon Bedrock models from a Lambda Function — IAM-scoped bindings, streaming, and tool calling over the Converse API. |
| 355 | |
| 356 | ## AWS — Messaging & events |
| 357 | |
| 358 | - [Process DynamoDB Streams](https://alchemy.run/aws/messaging/dynamodb-streams) — Enable a DynamoDB Stream on your table and consume each batch of change records from the same Lambda. |
| 359 | - [React to S3 Events](https://alchemy.run/aws/messaging/s3-events) — Subscribe a Lambda Function to S3 bucket notifications, process them as an Effect Stream, and let Alchemy wire up the IAM and event-source plumbing. |
| 360 | - [EventBridge & Scheduler](https://alchemy.run/aws/messaging/eventbridge) — Route application and AWS events through EventBridge buses and rules, consume them in Lambda as typed streams, and run cron/rate schedules against Lambda, SQS, and ECS with EventBridge Scheduler. |
| 361 | - [Kinesis](https://alchemy.run/aws/messaging/kinesis) — Add a Kinesis Data Stream, publish records from one Lambda, and consume them in order from another — wired through the same batch event source as SQS. |
| 362 | - [SNS](https://alchemy.run/aws/messaging/sns) — Create an SNS Topic, publish to it from a Lambda with the Publish binding, fan messages out to SQS queues, and consume notifications as a typed Stream. |
| 363 | - [SQS](https://alchemy.run/aws/messaging/sqs) — Add an SQS Queue, publish messages from your Lambda, and consume them from a second consumer Lambda — all wired through Alchemy bindings. |
| 364 | |
| 365 | ## AWS — Email |
| 366 | |
| 367 | - [Email receiving](https://alchemy.run/aws/email/receiving) — Receive inbound email with SES — rule sets and rules that store mail in S3, fan out to SNS, invoke a Lambda, or bounce it, plus IP filters and the active rule set pointer. |
| 368 | - [Sending & managing email](https://alchemy.run/aws/email/sending) — Send email with SES — verify identities, send from a Lambda with the SendEmail binding, manage contact lists, tenants, dedicated IP pools, account settings, and deliverability insights. |
| 369 | |
| 370 | ## AWS — Security & secrets |
| 371 | |
| 372 | - [Federated identity](https://alchemy.run/aws/security/federated-identity) — How a Cloud Run service reaches AWS, and a Lambda reaches GCP, through workload identity federation instead of long-lived keys. |
| 373 | - [Secrets & env](https://alchemy.run/aws/security/secrets-env) — Deliver API keys from .env to a Lambda with effect/Config, and graduate to AWS Secrets Manager when the secret is a shared, generated, or rotated cloud resource. |
| 374 | |
| 375 | ## AWS — Observability |
| 376 | |
| 377 | - [CloudWatch](https://alchemy.run/aws/observability/cloudwatch) — Declare CloudWatch dashboards as structured widget documents and metric alarms that fire SNS topics — versioned next to the Lambda functions and queues they observe. |
| 378 | |
| 379 | ## AWS — Networking |
| 380 | |
| 381 | - [Custom domains with Route53 + ACM](https://alchemy.run/aws/networking/custom-domains) — Serve your site or API from your own domain — DNS-validated ACM certificates, Route 53 or another DNS host through a DNS adapter, and the domain prop on Website resources and Lambda Functions. |
| 382 | - [VPC & networking](https://alchemy.run/aws/networking) — The Network helper for a production-shaped VPC in one call, and the full set of EC2 networking primitives — VPCs, subnets, gateways, routes, security groups, and endpoints — for explicit control. |
| 383 | |
| 384 | ## GCP |
| 385 | |
| 386 | Google Cloud as Stack resources — Cloud Run services and jobs, Firestore, Pub/Sub, BigQuery, Secret Manager, Memorystore. Bindings grant IAM onto a per-host service account. |
| 387 | |
| 388 | - [GCP](https://alchemy.run/gcp) — Build Google Cloud applications with Alchemy — a runtime (usually Cloud Run) plus typed resources, wired together by bindings that grant least-privilege IAM. |
| 389 | - [Setup](https://alchemy.run/gcp/setup) — Connect alchemy to Google Cloud — project, service-account key, the APIs to enable, and Docker. |
| 390 | |
| 391 | ## GCP — Tutorial |
| 392 | |
| 393 | - [Part 1: Your First Stack](https://alchemy.run/gcp/tutorial/part-1) — Install Alchemy, create a Stack with a Cloud Storage Bucket, and deploy it to Google Cloud. |
| 394 | - [Part 2: Add a Cloud Run Service](https://alchemy.run/gcp/tutorial/part-2) — Put an HTTP service on Cloud Run, bind the Cloud Storage Bucket, and implement GET/PUT routes. |
| 395 | - [Part 3: Testing](https://alchemy.run/gcp/tutorial/part-3) — Write integration tests that deploy your stack and make HTTP requests against the live Cloud Run service. |
| 396 | - [Part 4: Stages](https://alchemy.run/gcp/tutorial/part-4) — Deploy isolated dev, staging, and prod copies of your stack with --stage, and tune Cloud Run per stage. |
| 397 | - [Part 5: CI/CD](https://alchemy.run/gcp/tutorial/part-5) — Deploy from GitHub Actions with Workload Identity Federation — production on main, a preview stage per pull request, no service-account keys in GitHub. |
| 398 | |
| 399 | ## GCP — Compute |
| 400 | |
| 401 | - [Choosing a runtime](https://alchemy.run/gcp/compute/choosing-a-runtime) — Cloud Run services vs jobs vs worker pools vs Cloud Functions vs GKE — what each one is for and what it costs to run. |
| 402 | - [Cloud Functions](https://alchemy.run/gcp/compute/cloud-functions) — Deploy an Effect fetch handler as a 2nd-gen Cloud Function — built by Google from an uploaded bundle, so no local Docker is needed. |
| 403 | - [Cloud Run](https://alchemy.run/gcp/compute/cloud-run) — Run an Effect HTTP service on Cloud Run with GCP.Function — public or private URLs, environment, scaling, and bindings that grant IAM. |
| 404 | - [Cloud Run jobs](https://alchemy.run/gcp/compute/jobs) — Run batch work to completion with GCP.Run.Job — trigger it from a service with RunJob, or nightly with Cloud Scheduler. |
| 405 | - [Cloud Run sidecars](https://alchemy.run/gcp/compute/sidecars) — Run more containers next to a Cloud Run service — plain images, GCP.Run.Container resources, or your own Effect programs — and control the order they start in. |
| 406 | - [GKE](https://alchemy.run/gcp/compute/gke) — Run Effect programs as Kubernetes Deployments and Jobs on a GKE Autopilot cluster, with bindings granted through Workload Identity. |
| 407 | - [Worker pools](https://alchemy.run/gcp/compute/worker-pools) — Run always-on queue consumers with GCP.Run.WorkerPool — no URL, a fixed instance count, and a Pub/Sub pull loop. |
| 408 | |
| 409 | ## GCP — Frontend |
| 410 | |
| 411 | - [Websites](https://alchemy.run/gcp/frontend/websites) — Deploy Vite, Astro, Next.js, Nuxt, SvelteKit, TanStack Start, React Router, SolidStart, Waku, vinext, Octane, Vocs, or any static build to Cloud Run with GCP.Website. |
| 412 | - [Vite](https://alchemy.run/gcp/frontend/vite) — Deploy any client-only Vite app to Cloud Run with GCP.Website.Vite — your own vite.config, a small static file server, and Vite's dev server under alchemy dev. |
| 413 | - [React SPA](https://alchemy.run/gcp/frontend/vite-spa) — Deploy a React single-page app to Cloud Run with GCP.Website.Vite — scaffold with Vite, deep links answered by index.html, Vite's dev server under alchemy dev. |
| 414 | - [Vue](https://alchemy.run/gcp/frontend/vue) — Deploy a Vue single-page app to Cloud Run with GCP.Website.Vite — scaffold with create-vue, deep links answered by index.html. |
| 415 | - [Foldkit](https://alchemy.run/gcp/frontend/foldkit) — Deploy a Foldkit app to Cloud Run with GCP.Website.Foldkit — a Vite build with deep links that boot the app. |
| 416 | - [Astro](https://alchemy.run/gcp/frontend/astro) — Deploy an Astro site to Cloud Run with GCP.Website.Astro — server-rendered pages, prerendered pages, and Astro's own dev server under alchemy dev. |
| 417 | - [Next.js](https://alchemy.run/gcp/frontend/nextjs) — Deploy a Next.js app to Cloud Run with GCP.Website.Nextjs — Next's own production server in a container, no OpenNext. |
| 418 | - [Nuxt](https://alchemy.run/gcp/frontend/nuxt) — Deploy a Nuxt app to Cloud Run with GCP.Website.Nuxt — the nitro Node server in a container, prerendered pages served as static files. |
| 419 | - [SvelteKit](https://alchemy.run/gcp/frontend/sveltekit) — Deploy a SvelteKit app to Cloud Run with GCP.Website.SvelteKit — kit's server in a container, static assets served first. |
| 420 | - [TanStack Start](https://alchemy.run/gcp/frontend/tanstack-start) — Deploy a TanStack Start app (React or Solid) to Cloud Run with GCP.Website.TanStackStart — your own vite build, served by a Node server. |
| 421 | - [React Router](https://alchemy.run/gcp/frontend/react-router) — Deploy a React Router v8 app in framework mode to Cloud Run with GCP.Website.ReactRouter. |
| 422 | - [SolidStart](https://alchemy.run/gcp/frontend/solidstart) — Deploy a SolidStart app to Cloud Run with GCP.Website.SolidStart — SSR in a container, prerendered pages served as static files. |
| 423 | - [Waku](https://alchemy.run/gcp/frontend/waku) — Deploy a Waku (React Server Components) app to Cloud Run with GCP.Website.Waku. |
| 424 | - [vinext](https://alchemy.run/gcp/frontend/vinext) — Deploy a vinext app (the Next.js API on Vite) to Cloud Run with GCP.Website.Vinext. |
| 425 | - [Octane](https://alchemy.run/gcp/frontend/octane) — Deploy an OctaneJS app to Cloud Run with GCP.Website.Octane. |
| 426 | - [Vocs](https://alchemy.run/gcp/frontend/vocs) — Deploy a Vocs documentation site to Cloud Run with GCP.Website.Vocs. |
| 427 | - [Static sites](https://alchemy.run/gcp/frontend/static-site) — Deploy Hugo, Zola, or any static build to Google Cloud — on Cloud Run with GCP.Website.StaticSite, or from a public Cloud Storage bucket. |
| 428 | |
| 429 | ## GCP — APIs |
| 430 | |
| 431 | - [Effect HTTP API on Cloud Run](https://alchemy.run/gcp/apis/effect-http-api) — Build a schema-validated HTTP API with Effect's HttpApi module, deploy it to Cloud Run, and call it from a typed client. |
| 432 | - [Effect RPC on Cloud Run](https://alchemy.run/gcp/apis/effect-rpc) — Build a typed RPC API with Effect's Rpc module, deploy it to Cloud Run, and call its procedures from a typed client. |
| 433 | |
| 434 | ## GCP — Data |
| 435 | |
| 436 | - [BigQuery](https://alchemy.run/gcp/data/bigquery) — Create BigQuery datasets and tables, stream rows in, and run parameterized queries from Cloud Run with ReadTable and WriteTable bindings. |
| 437 | - [Cloud SQL](https://alchemy.run/gcp/data/cloud-sql) — Run Postgres on Cloud SQL, connect Cloud Run to it over the Cloud SQL socket with GCP.SQL.Connect, and query it with Drizzle. |
| 438 | - [Cloud Storage](https://alchemy.run/gcp/data/storage) — Create Cloud Storage buckets, read and write objects from Cloud Run with Read, Write, and ReadWrite bindings, and hand out signed download URLs. |
| 439 | - [Firestore](https://alchemy.run/gcp/data/firestore) — Create a Firestore database and read and write documents from Cloud Run with typed Read, Write, and ReadWrite bindings. |
| 440 | - [Memorystore](https://alchemy.run/gcp/data/memorystore) — Create a Memorystore for Redis instance and reach it from Cloud Run over Direct VPC egress with the ReadWriteRedis binding. |
| 441 | |
| 442 | ## GCP — AI |
| 443 | |
| 444 | - [Vertex AI](https://alchemy.run/gcp/ai/vertex-ai) — Call Gemini on Vertex AI from Cloud Run with the GenerateContent binding — no API key, just the service's own identity. |
| 445 | |
| 446 | ## GCP — Messaging & events |
| 447 | |
| 448 | - [Cloud Scheduler](https://alchemy.run/gcp/messaging/scheduler) — Run code on a cron schedule with GCP.CloudScheduler.consumeSchedule — the handler lives on your Cloud Run service and only Cloud Scheduler can call it. |
| 449 | - [Eventarc](https://alchemy.run/gcp/messaging/eventarc) — React to Firestore changes, Cloud Storage events, and audit-logged Google API calls with GCP.Eventarc.consumeEvents. |
| 450 | - [Pub/Sub](https://alchemy.run/gcp/messaging/pubsub) — Publish to Pub/Sub topics from Cloud Run, consume them with push delivery or a pull loop, filter by attribute, and dead-letter failures. |
| 451 | - [Storage events](https://alchemy.run/gcp/messaging/storage-events) — Run code when an object lands in a Cloud Storage bucket with GCP.Storage.consumeBucketEvents. |
| 452 | |
| 453 | ## GCP — Security & secrets |
| 454 | |
| 455 | - [Federated identity](https://alchemy.run/gcp/security/federated-identity) — How a Lambda reaches GCP, and a Cloud Run service reaches AWS, through workload identity federation instead of long-lived keys. |
| 456 | - [IAM & bindings](https://alchemy.run/gcp/security/iam) — What a GCP binding does — the per-runtime service account, the role it grants, where the grant lands, and how removing a binding revokes it. |
| 457 | - [Secret Manager & KMS](https://alchemy.run/gcp/security/secrets-kms) — Keep API keys in Secret Manager and read them per request, encrypt data with Cloud KMS, and pass plain config through env. |
| 458 | |
| 459 | ## GCP — Observability |
| 460 | |
| 461 | - [Logging & Monitoring](https://alchemy.run/gcp/observability/monitoring) — Declare uptime checks, alert policies, notification channels, and logs-based metrics in the same Stack as the services they watch. |
| 462 | |
| 463 | ## GCP — Networking |
| 464 | |
| 465 | - [Private services](https://alchemy.run/gcp/networking/private-services) — Keep a Cloud Run service private and call it from another service with GCP.Run.InvokeService and Google-signed identity tokens. |
| 466 | - [VPC & private networking](https://alchemy.run/gcp/networking/vpc) — Give Cloud Run services Direct VPC egress to reach private IPs like Memorystore, and create your own VPC networks and subnets. |
| 467 | |
| 468 | ## Fly — start here |
| 469 | |
| 470 | The Fly hub: overview (Apps, Machines, Services, Sprites), setup (org, API token, profile), and networking. |
| 471 | |
| 472 | - [Fly](https://alchemy.run/fly) — Deploy Effect programs to Fly.io as Apps, Machines, Services, and Sprites. |
| 473 | - [Setup](https://alchemy.run/fly/setup) — Create a Fly org, generate an API token, and store it in a profile. |
| 474 | - [IPs & certificates](https://alchemy.run/fly/networking) — Public and private Fly Services, App addresses, and certificates for your own hostname. |
| 475 | |
| 476 | ## Fly — Tutorial |
| 477 | |
| 478 | - [Part 1: Your First Service](https://alchemy.run/fly/tutorial/part-1) — Install Alchemy, create a Stack, and deploy an Effect HTTP Service to Fly on its own fly.dev hostname. |
| 479 | - [Part 2: Configure the Service](https://alchemy.run/fly/tutorial/part-2) — Pin the Service's region and port, add a health route, and ship a code change. |
| 480 | - [Part 3: Persist Data with a Volume](https://alchemy.run/fly/tutorial/part-3) — Mount a Fly disk into your Service with MountVolume and store files that survive deploys. |
| 481 | - [Part 4: Secrets and Cleanup](https://alchemy.run/fly/tutorial/part-4) — Read a secret from .env in the Service with Config.Redacted, guard a route with it, and destroy the stack. |
| 482 | |
| 483 | ## Fly — Compute |
| 484 | |
| 485 | - [Apps](https://alchemy.run/fly/compute/apps) — A global namespace containing Machines, Services, Secrets, IPs, and certificates. |
| 486 | - [Blue/green deployments](https://alchemy.run/fly/compute/deployments) — Deploy a new version, check it before serving traffic, and give the old version time to finish work. |
| 487 | - [Connect Services](https://alchemy.run/fly/compute/connecting-services) — Build several Fly Services that call each other's methods over a private network, behind one public entry point. |
| 488 | - [Machines](https://alchemy.run/fly/compute/machines) — A Firecracker VM running a container image. |
| 489 | - [Regions](https://alchemy.run/fly/compute/regions) — Where Fly Machines, Volumes, Postgres, and Redis live. Alchemy defaults to iad. |
| 490 | - [Services](https://alchemy.run/fly/compute/services) — An Effect program running in Fly Machines in its own Fly App. Scale it with count. |
| 491 | - [Sprites](https://alchemy.run/fly/compute/sprites) — An Effect program running in a Fly.io Sprite. It hibernates when idle. |
| 492 | |
| 493 | ## Fly — Data |
| 494 | |
| 495 | - [Drizzle Postgres on Fly](https://alchemy.run/fly/data/drizzle-postgres) — Connect a Fly Service to Managed Postgres and deploy reviewed Drizzle migrations. |
| 496 | - [Postgres](https://alchemy.run/fly/data/postgres) — A billed Managed Postgres cluster. Bind Fly.ConnectPostgres and query with Drizzle or SQL. |
| 497 | - [Redis](https://alchemy.run/fly/data/redis) — Managed Upstash Redis. Bind Fly.ReadRedis / WriteRedis / ReadWriteRedis on a Service. |
| 498 | - [Secrets](https://alchemy.run/fly/data/secrets) — Config.Redacted on a Service, Fly.Secret when Fly should own the value, and KMS keys. |
| 499 | - [Tigris](https://alchemy.run/fly/data/tigris) — S3-compatible object storage billed through Fly. Bind Fly.PutObject / Fly.GetObject. |
| 500 | - [Volumes](https://alchemy.run/fly/data/volumes) — A disk in one region, attached to one Machine. |
| 501 | |
| 502 | ## Fly — Frontend |
| 503 | |
| 504 | - [Websites](https://alchemy.run/fly/frontend/websites) — Deploy Vite, Astro, Next.js, vinext, Nuxt, React Router, SolidStart, SvelteKit, TanStack Start, Waku, Octane, Foldkit, Vocs, or any static build to Fly with first-class Website resources. |
| 505 | - [Vite](https://alchemy.run/fly/frontend/vite) — Deploy a Vite SPA to Fly with Fly.Website.Vite — static assets on a Node Machine, fly.dev (or your domain) over HTTPS, and Vite's own dev server under alchemy dev. |
| 506 | - [Static sites](https://alchemy.run/fly/frontend/static-site) — Deploy a static site to Fly with Fly.Website.StaticSite — a build command, a Node static-file server on a Machine, and https://{app}.fly.dev (or your hostname) on deploy. |
| 507 | - [React Router](https://alchemy.run/fly/frontend/react-router) — Deploy React Router v8 (framework mode) to Fly with Fly.Website.ReactRouter — SSR on a Machine, client assets baked into the image, and React Router's own Vite dev server under alchemy dev. |
| 508 | - [Foldkit](https://alchemy.run/fly/frontend/foldkit) — Deploy Foldkit SPA, SSR, SSG, and hybrid applications to Fly with native local development. |
| 509 | - [TanStack Start](https://alchemy.run/fly/frontend/tanstack-start) — Deploy TanStack Start (React or Solid) to Fly with Fly.Website.TanStackStart — SSR on a Machine, client assets baked into the image, and TanStack Start's own Vite dev server under alchemy dev. |
| 510 | - [Next.js](https://alchemy.run/fly/frontend/nextjs) — Deploy a Next.js app to Fly with Fly.Website.Nextjs — next build plus a Node next({ dev: false }) Machine, and next dev under alchemy dev. |
| 511 | - [Vinext](https://alchemy.run/fly/frontend/vinext) — Deploy vinext to Fly with the shared Website API, native local development, and a platform-specific data cache. |
| 512 | - [Nuxt](https://alchemy.run/fly/frontend/nuxt) — Deploy a Nuxt app to Fly with Fly.Website.Nuxt — nitro's node preset on a Machine, assets baked into the image, and Nuxt's own dev server under alchemy dev. |
| 513 | - [Vocs](https://alchemy.run/fly/frontend/vocs) — Deploy a Vocs docs site to Fly with Fly.Website.Vocs — prerendered HTML on a Node static-file server, extensionless routes, and Vocs' own dev server under alchemy dev. |
| 514 | - [SolidStart](https://alchemy.run/fly/frontend/solidstart) — Deploy a SolidStart app to Fly with Fly.Website.SolidStart — nitro's node preset on a Machine, prerendered pages baked into the image, and SolidStart's own Vite dev server under alchemy dev. |
| 515 | - [Astro](https://alchemy.run/fly/frontend/astro) — Deploy an Astro app to Fly with Fly.Website.Astro — Node SSR on a Machine, static output as a file server, and Astro's own dev server under alchemy dev. |
| 516 | - [SvelteKit](https://alchemy.run/fly/frontend/sveltekit) — Deploy a SvelteKit app to Fly with Fly.Website.SvelteKit — kit SSR on a Machine, prerendered assets baked into the image, and Kit's own dev server under alchemy dev. |
| 517 | - [Waku](https://alchemy.run/fly/frontend/waku) — Deploy a Waku app to Fly with Fly.Website.Waku — RSC server on a Machine, SSG pages baked into the image, and Waku's own dev server under alchemy dev. |
| 518 | - [Octane](https://alchemy.run/fly/frontend/octane) — Deploy an OctaneJS app to Fly with Fly.Website.Octane — SSR on a Machine, client assets baked into the image, and Octane's own Vite dev server under alchemy dev. |
| 519 | |
| 520 | ## Hetzner — start here |
| 521 | |
| 522 | The Hetzner hub: overview (Servers and Services) and setup (project, API token, profile). |
| 523 | |
| 524 | - [Hetzner](https://alchemy.run/hetzner) — Build applications on Hetzner Cloud with Alchemy — Servers running your Effect programs as Services, plus volumes, networks, firewalls, load balancers, and DNS, all in one typed program. |
| 525 | - [Setup](https://alchemy.run/hetzner/setup) — Install Alchemy and connect it to Hetzner Cloud — create a project, generate an API token, and store it in a profile. |
| 526 | |
| 527 | ## Hetzner — Tutorial |
| 528 | |
| 529 | - [Part 1: Your First Server](https://alchemy.run/hetzner/tutorial/part-1) — Install Alchemy, create a Stack with a Hetzner Server, and deploy it. |
| 530 | - [Part 2: Deploy a Service](https://alchemy.run/hetzner/tutorial/part-2) — Bundle an Effect HTTP server, deploy it to your Hetzner Server as a systemd unit, and serve requests on a public URL. |
| 531 | - [Part 3: Persist Data with a Volume](https://alchemy.run/hetzner/tutorial/part-3) — Attach a Hetzner Volume, mount it into your Service with the MountVolume binding, and store files that survive deploys. |
| 532 | - [Part 4: Networking & Load Balancing](https://alchemy.run/hetzner/tutorial/part-4) — Put your Service behind a managed Load Balancer on a private network, and lock the Server down with a Firewall. |
| 533 | |
| 534 | ## Hetzner — Compute |
| 535 | |
| 536 | - [Servers](https://alchemy.run/hetzner/compute/servers) — Launch Hetzner Cloud Servers with Alchemy — SSH keys and typed SSH access, cloud-init, networks, volumes, snapshots, and placement groups. |
| 537 | - [Services](https://alchemy.run/hetzner/compute/services) — Deploy Effect programs to Hetzner Servers as supervised systemd units — HTTP handlers, background workers, env & config, updates, and logs. |
| 538 | |
| 539 | ## Hetzner — Data |
| 540 | |
| 541 | - [Drizzle Postgres on Hetzner](https://alchemy.run/hetzner/data/drizzle-postgres) — Run a Drizzle API on a Hetzner Server with external Neon Postgres and reviewed SQL migrations. |
| 542 | - [Volumes](https://alchemy.run/hetzner/data/volumes) — Durable network block storage for Hetzner Servers — attach with props or VolumeAttachment, mount into Services with the MountVolume binding. |
| 543 | |
| 544 | ## Hetzner — Networking |
| 545 | |
| 546 | - [DNS](https://alchemy.run/hetzner/networking/dns) — Hetzner Cloud DNS with Alchemy — Zones and RecordSets as resources, plus ReadDns/WriteDns bindings for querying and mutating records from Effects. |
| 547 | - [Networking](https://alchemy.run/hetzner/networking) — Private networks, default-deny firewalls, managed load balancers with TLS, and stable Floating & Primary IPs for Hetzner Cloud. |
| 548 | |
| 549 | ## Hetzner — Frontend |
| 550 | |
| 551 | - [Websites](https://alchemy.run/hetzner/frontend/websites) — Deploy Vite, Astro, Next.js, vinext, Nuxt, React Router, SolidStart, SvelteKit, TanStack Start, Waku, Octane, Foldkit, Vocs, or any static build to Hetzner with first-class Website resources. |
| 552 | - [Vite](https://alchemy.run/hetzner/frontend/vite) — Deploy a Vite SPA to Hetzner with Hetzner.Website.Vite — static assets as a systemd unit on a Server, http://{ipv4}:3000, and Vite's own dev server under alchemy dev. |
| 553 | - [Static sites](https://alchemy.run/hetzner/frontend/static-site) — Deploy a static site to Hetzner with Hetzner.Website.StaticSite — a build command, a systemd unit on a Server, and http://{ipv4}:3000 (or your hostname) on deploy. |
| 554 | - [React Router](https://alchemy.run/hetzner/frontend/react-router) — Deploy React Router v8 (framework mode) to Hetzner with Hetzner.Website.ReactRouter — SSR as a systemd unit on port 3000, client assets baked into the unit, and React Router's own Vite dev server under alchemy dev. |
| 555 | - [Foldkit](https://alchemy.run/hetzner/frontend/foldkit) — Deploy Foldkit SPA, SSR, SSG, and hybrid applications to Hetzner with native local development. |
| 556 | - [TanStack Start](https://alchemy.run/hetzner/frontend/tanstack-start) — Deploy TanStack Start (React or Solid) to Hetzner with Hetzner.Website.TanStackStart — SSR as a systemd unit on port 3000, client assets baked into the unit, and TanStack Start's own Vite dev server under alchemy dev. |
| 557 | - [Next.js](https://alchemy.run/hetzner/frontend/nextjs) — Deploy a Next.js app to Hetzner with Hetzner.Website.Nextjs — next build plus a Node next({ dev: false }) systemd unit, and next dev under alchemy dev. |
| 558 | - [Vinext](https://alchemy.run/hetzner/frontend/vinext) — Deploy vinext to Hetzner with the shared Website API, native local development, and a platform-specific data cache. |
| 559 | - [Nuxt](https://alchemy.run/hetzner/frontend/nuxt) — Deploy a Nuxt app to Hetzner with Hetzner.Website.Nuxt — nitro's node preset as a systemd unit on port 3000, and Nuxt's own dev server under alchemy dev. |
| 560 | - [Vocs](https://alchemy.run/hetzner/frontend/vocs) — Deploy a Vocs docs site to Hetzner with Hetzner.Website.Vocs — prerendered HTML on a systemd unit, extensionless routes, and Vocs' own dev server under alchemy dev. |
| 561 | - [SolidStart](https://alchemy.run/hetzner/frontend/solidstart) — Deploy a SolidStart app to Hetzner with Hetzner.Website.SolidStart — nitro's node preset as a systemd unit on port 3000, prerendered pages baked into the unit, and SolidStart's own Vite dev server under alchemy dev. |
| 562 | - [Astro](https://alchemy.run/hetzner/frontend/astro) — Deploy an Astro app to Hetzner with Hetzner.Website.Astro — Node SSR as a systemd unit on a Server, static output as a file server, and Astro's own dev server under alchemy dev. |
| 563 | - [SvelteKit](https://alchemy.run/hetzner/frontend/sveltekit) — Deploy a SvelteKit app to Hetzner with Hetzner.Website.SvelteKit — kit SSR as a systemd unit on port 3000, prerendered assets baked into the unit, and Kit's own dev server under alchemy dev. |
| 564 | - [Waku](https://alchemy.run/hetzner/frontend/waku) — Deploy a Waku app to Hetzner with Hetzner.Website.Waku — RSC server as a systemd unit on port 3000, SSG pages baked into the unit, and Waku's own dev server under alchemy dev. |
| 565 | - [Octane](https://alchemy.run/hetzner/frontend/octane) — Deploy an OctaneJS app to Hetzner with Hetzner.Website.Octane — SSR as a systemd unit on port 3000, client assets baked into the unit, and Octane's own Vite dev server under alchemy dev. |
| 566 | |
| 567 | ## Railway — start here |
| 568 | |
| 569 | The Railway hub: overview (Projects, Services, databases), setup (workspace, API token, profile), and networking. |
| 570 | |
| 571 | - [Railway](https://alchemy.run/railway) — Deploy Effect programs to Railway as Projects, Services, databases, Volumes, and Buckets. |
| 572 | - [Setup](https://alchemy.run/railway/setup) — Create a Railway workspace, generate an account API token, and store it in a profile. |
| 573 | - [Custom domains, TCP & private networks](https://alchemy.run/railway/networking) — Reach a Railway Service on your own hostname, expose databases over public TCP, and name private-mesh DNS. |
| 574 | |
| 575 | ## Railway — Tutorial |
| 576 | |
| 577 | - [Part 1: Your First Project](https://alchemy.run/railway/tutorial/part-1) — Install Alchemy, create a Stack with a Railway Project, and deploy it. |
| 578 | - [Part 2: Deploy a Service](https://alchemy.run/railway/tutorial/part-2) — Bundle an Effect HTTP server, deploy it to Railway as a Service, and serve requests on up.railway.app. |
| 579 | - [Part 3: Persist Data with a Volume](https://alchemy.run/railway/tutorial/part-3) — Mount a Railway disk into your Service with MountVolume and store files that survive deploys. |
| 580 | - [Part 4: Variables and Cleanup](https://alchemy.run/railway/tutorial/part-4) — Store a Project variable, read it from the Service at runtime, and destroy the stack. |
| 581 | |
| 582 | ## Railway — Compute |
| 583 | |
| 584 | - [Environments](https://alchemy.run/railway/compute/environments) — Extra deploy environments under a Project. Production is created with the Project — do not duplicate it. |
| 585 | - [Functions, templates & VMs](https://alchemy.run/railway/compute/functions) — Effect-native canvas Functions, marketplace templates, sandboxes, and cloud agents on Railway. |
| 586 | - [Projects](https://alchemy.run/railway/compute/projects) — A workspace-scoped namespace containing Services, Environments, Volumes, Variables, and Buckets. |
| 587 | - [Regions](https://alchemy.run/railway/compute/regions) — Where Railway Services, Volumes, Postgres, and Buckets live. |
| 588 | - [Services](https://alchemy.run/railway/compute/services) — A container in a Railway Project — a public image, or an Effect program Railway builds from a generated Dockerfile. |
| 589 | |
| 590 | ## Railway — Data |
| 591 | |
| 592 | - [Buckets](https://alchemy.run/railway/data/buckets) — S3-compatible object storage in a Project. Bind Railway.PutObject / Railway.GetObject. |
| 593 | - [Drizzle MySQL on Railway](https://alchemy.run/railway/data/drizzle-mysql) — Connect an Effect-native Railway Service to MySQL and deploy committed Drizzle migrations. |
| 594 | - [Drizzle Postgres on Railway](https://alchemy.run/railway/data/drizzle-postgres) — Query Railway Postgres from an Effect-native Service and apply reviewed Drizzle migrations separately. |
| 595 | - [Mongo](https://alchemy.run/railway/data/mongo) — Official MongoDB in a Project. Bind Railway.ConnectMongo and ping with the MongoDB driver. |
| 596 | - [MySQL](https://alchemy.run/railway/data/mysql) — Official MySQL in a Project. Bind Railway.ConnectMySQL and query with Drizzle or SQL. |
| 597 | - [Postgres](https://alchemy.run/railway/data/postgres) — Official SSL Postgres in a Project. Bind Railway.ConnectPostgres and query with Drizzle or SQL. |
| 598 | - [Redis](https://alchemy.run/railway/data/redis) — Redis in a Project. Bind Railway.ReadRedis / WriteRedis / ReadWriteRedis on a Service. |
| 599 | - [Variables](https://alchemy.run/railway/data/variables) — Config.Redacted on a Service, Railway.Variable when Railway should own the value. |
| 600 | - [Volumes](https://alchemy.run/railway/data/volumes) — Block disk in a Project. Mount it into a Service with MountVolume. |
| 601 | |
| 602 | ## Railway — Frontend |
| 603 | |
| 604 | - [Websites](https://alchemy.run/railway/frontend/websites) — Deploy Vite, Astro, Next.js, vinext, Nuxt, React Router, SolidStart, SvelteKit, TanStack Start, Waku, Octane, Foldkit, Vocs, or any static build to Railway with first-class Website resources. |
| 605 | - [Vite](https://alchemy.run/railway/frontend/vite) — Deploy a Vite SPA to Railway with Railway.Website.Vite — static assets on a container Service, a *.up.railway.app URL (or your domain), and Vite's own dev server under alchemy dev. |
| 606 | - [Static sites](https://alchemy.run/railway/frontend/static-site) — Deploy a static site to Railway with Railway.Website.StaticSite — a build command, a container Service. |
| 607 | - [React Router](https://alchemy.run/railway/frontend/react-router) — Deploy React Router v8 (framework mode) to Railway with Railway.Website.ReactRouter — SSR on a container Service, client assets in the image, and React Router's own Vite dev server under alchemy dev. |
| 608 | - [Foldkit](https://alchemy.run/railway/frontend/foldkit) — Deploy Foldkit SPA, SSR, SSG, and hybrid applications to Railway with native local development. |
| 609 | - [TanStack Start](https://alchemy.run/railway/frontend/tanstack-start) — Deploy TanStack Start (React or Solid) to Railway with Railway.Website.TanStackStart — SSR on a container Service, client assets in the image, and TanStack Start's own Vite dev server under alchemy dev. |
| 610 | - [Next.js](https://alchemy.run/railway/frontend/nextjs) — Deploy a Next.js app to Railway with Railway.Website.Nextjs — next build plus a Node next({ dev: false }) container, and next dev under alchemy dev. |
| 611 | - [Vinext](https://alchemy.run/railway/frontend/vinext) — Deploy vinext to Railway with the shared Website API, native local development, and a platform-specific data cache. |
| 612 | - [Nuxt](https://alchemy.run/railway/frontend/nuxt) — Deploy a Nuxt app to Railway with Railway.Website.Nuxt — nitro's node preset on a Service, and Nuxt's own dev server under alchemy dev. |
| 613 | - [Vocs](https://alchemy.run/railway/frontend/vocs) — Deploy a Vocs docs site to Railway with Railway.Website.Vocs — prerendered HTML on a Railway Service, extensionless routes, and Vocs' own dev server under alchemy dev. |
| 614 | - [SolidStart](https://alchemy.run/railway/frontend/solidstart) — Deploy a SolidStart app to Railway with Railway.Website.SolidStart — nitro's node preset on a container Service, prerendered pages in the image, and SolidStart's own Vite dev server under alchemy dev. |
| 615 | - [Astro](https://alchemy.run/railway/frontend/astro) — Deploy an Astro app to Railway with Railway.Website.Astro — Node SSR on a Service container, static output as a file server, and Astro's own dev server under alchemy dev. |
| 616 | - [SvelteKit](https://alchemy.run/railway/frontend/sveltekit) — Deploy a SvelteKit app to Railway with Railway.Website.SvelteKit — kit SSR plus prerendered assets on one Service, and Kit's own dev server under alchemy dev. |
| 617 | - [Waku](https://alchemy.run/railway/frontend/waku) — Deploy a Waku app to Railway with Railway.Website.Waku — RSC server on a container Service, SSG pages in the image, and Waku's own dev server under alchemy dev. |
| 618 | - [Octane](https://alchemy.run/railway/frontend/octane) — Deploy an OctaneJS app to Railway with Railway.Website.Octane — SSR plus client assets on one Service, and Octane's own Vite dev server under alchemy dev. |
| 619 | |
| 620 | ## PlanetScale |
| 621 | |
| 622 | Serverless MySQL & Postgres as Stack resources. Composes with Cloudflare Hyperdrive and Drizzle — those guides are listed under Cloudflare. |
| 623 | |
| 624 | - [PlanetScale](https://alchemy.run/planetscale) — Serverless MySQL (Vitess) and Postgres with database branching — databases, branches, and credentials as Stack resources. |
| 625 | - [Setup](https://alchemy.run/planetscale/setup) — Connect alchemy to PlanetScale — account, credentials, and profiles. |
| 626 | - [Postgres](https://alchemy.run/planetscale/data/postgres) — PlanetScale Postgres as Stack resources — databases, branches, roles with least-privilege inherited roles, and direct vs pooled connection origins. |
| 627 | - [MySQL](https://alchemy.run/planetscale/data/mysql) — PlanetScale MySQL (Vitess) as Stack resources — databases, branches, and passwords, with SQL migrations per branch and a straight line into Cloudflare Hyperdrive. |
| 628 | - [Migrations](https://alchemy.run/planetscale/data/migrations) — Apply SQL migrations and seed data to PlanetScale databases and branches as part of every deploy — ordered, hashed, tracked, and run over short-lived credentials. |
| 629 | - [Credentials](https://alchemy.run/planetscale/data/credentials) — PlanetScale credentials as Stack resources — Postgres roles, the default role and forceReset, MySQL passwords, TTLs, CIDR allowlists, and direct vs pooled connection origins. |
| 630 | - [Backups & restores](https://alchemy.run/planetscale/data/backups) — Restore a PlanetScale backup into a fresh branch with backupId, or seed a new branch from the last successful backup with seedData. |
| 631 | - [Preview branches per PR](https://alchemy.run/planetscale/guides/preview-branches) — Give every pull request its own PlanetScale branch — a long-lived database owned by a staging stage, referenced by ephemeral PR stages that fork, migrate, and tear down a branch each. |
| 632 | - [Drizzle ORM with PlanetScale](https://alchemy.run/planetscale/guides/drizzle) — Configure PlanetScale Postgres or MySQL branches, committed Drizzle migrations, and role or password connections. |
| 633 | |
| 634 | ## Neon |
| 635 | |
| 636 | Neon backend resources: Postgres branches, Functions, private object storage, managed Auth, Data API, AI Gateway and Website adapters. The upload tutorial combines native and Effect handlers with authenticated browser uploads. |
| 637 | |
| 638 | - [Neon](https://alchemy.run/neon) — Declare Neon Postgres, Functions, storage, Auth, AI Gateway and websites together in an Alchemy Stack. |
| 639 | - [Setup](https://alchemy.run/neon/setup) — Prepare Neon credentials, service access, regions, and external dependencies before deploying with Alchemy. |
| 640 | - [Organization governance](https://alchemy.run/neon/governance) — Manage existing Neon organization access, billing alerts, and private-network associations with explicit ownership and restoration. |
| 641 | - [AI Gateway setup](https://alchemy.run/neon/guides/ai-gateway) — Buy Neon AI Gateway credits and use a model from an Effect Function. |
| 642 | - [Production Auth](https://alchemy.run/neon/guides/production-auth) — Configure trusted origins, SMTP, OAuth callbacks, and verification before launching Managed Better Auth. |
| 643 | - [Private networking](https://alchemy.run/neon/guides/private-networking) — Prepare AWS PrivateLink endpoints, register them with Neon, enable private DNS, and verify database access. |
| 644 | - [Custom domains](https://alchemy.run/neon/guides/custom-domains) — Register a Function hostname, configure DNS and CAA, verify HTTPS, and retire the domain safely. |
| 645 | - [State and recovery](https://alchemy.run/neon/guides/state-recovery) — Preserve Neon ownership and reveal-once secrets, recover interrupted deployments, and clean up without discarding state. |
| 646 | - [Build an upload journal](https://alchemy.run/neon/tutorial) — Sign in, upload private files, process real storage events, and view Postgres-backed status with Neon and Alchemy. |
| 647 | - [Create the upload backend](https://alchemy.run/neon/tutorial/backend) — Add a Neon project, a migrated branch, private storage, and managed authentication. |
| 648 | - [Protect and process uploads](https://alchemy.run/neon/tutorial/functions) — Verify JWTs, sign private uploads, and record real bucket events in Postgres. |
| 649 | - [Connect the browser](https://alchemy.run/neon/tutorial/frontend) — Use managed signup and sessions to upload and download private files from Vite. |
| 650 | - [Fork a preview and clean up](https://alchemy.run/neon/tutorial/previews) — Keep preview writes isolated from the parent, verify inheritance, and destroy only owned resources. |
| 651 | - [Branching](https://alchemy.run/neon/data/branching) — Neon branches are copy-on-write forks of a parent branch — create them per stage or preview, pin them to a point in time, copy schema only, and let them expire on their own. |
| 652 | - [Connections](https://alchemy.run/neon/data/connections) — Every Neon project and branch exposes direct and pooled connection URIs plus pre-parsed origin outputs — feed the direct origin to Hyperdrive and the pooled one to everything else. |
| 653 | - [Roles](https://alchemy.run/neon/data/roles) — Create Postgres roles on a Neon branch with Neon.Role — separate logins for your app and your migrations, with passwords as Redacted outputs. |
| 654 | - [Migrations](https://alchemy.run/neon/data/migrations) — Apply SQL migrations and seed data to Neon projects and branches as part of every deploy — ordered, hashed, and tracked in Alchemy's __alchemy_migrations table. |
| 655 | - [Preview branches per PR](https://alchemy.run/neon/guides/preview-branches) — Keep one long-lived Neon project in a staging stage and fork a copy-on-write branch per PR stage — isolated preview databases in seconds, destroyed with the stage. |
| 656 | - [Drizzle ORM with Neon](https://alchemy.run/neon/guides/drizzle) — Configure Neon projects, branches, committed Drizzle migrations, and direct or pooled connections. |
| 657 | |
| 658 | ## Neon — Frontend |
| 659 | |
| 660 | - [Vite](https://alchemy.run/neon/frontend/vite) — Package a Vite client build as a Neon Function, with native Vite development. |
| 661 | - [Astro](https://alchemy.run/neon/frontend/astro) — Package Astro SSR or prerendered pages for Neon Functions, with native Astro development. |
| 662 | - [Next.js](https://alchemy.run/neon/frontend/nextjs) — Build Next.js for a Neon Function Fetch entry and use next dev locally. |
| 663 | - [Nuxt](https://alchemy.run/neon/frontend/nuxt) — Package Nuxt SSR and public assets for Neon Functions, with native Nuxt development. |
| 664 | - [SvelteKit](https://alchemy.run/neon/frontend/sveltekit) — Package SvelteKit SSR and prerendered assets as a Neon Function Fetch artifact. |
| 665 | - [React Router](https://alchemy.run/neon/frontend/react-router) — Package React Router framework-mode SSR and browser assets for Neon Functions. |
| 666 | - [SolidStart](https://alchemy.run/neon/frontend/solidstart) — Package SolidStart SSR and prerendered assets for a Neon Function Fetch entry. |
| 667 | - [TanStack Start](https://alchemy.run/neon/frontend/tanstack-start) — Package TanStack Start SSR and client assets for Neon Functions, with native Vite development. |
| 668 | - [Waku](https://alchemy.run/neon/frontend/waku) — Package Waku RSC and static pages for Neon Functions, with native Waku development. |
| 669 | - [Octane](https://alchemy.run/neon/frontend/octane) — Package Octane rendering and server routes as a Neon Function Fetch artifact. |
| 670 | - [Foldkit](https://alchemy.run/neon/frontend/foldkit) — Deploy Foldkit SPA, SSR, SSG, and hybrid applications to Neon Functions with native local development. |
| 671 | - [Vocs](https://alchemy.run/neon/frontend/vocs) — Package Vocs documentation and its Waku RSC handler for Neon Functions. |
| 672 | - [Static Site](https://alchemy.run/neon/frontend/static-site) — Run a static-site build command and package its output for a Neon Function. |
| 673 | |
| 674 | ## Turso |
| 675 | |
| 676 | Turso SQLite databases as Stack resources: groups, databases, migrations, connections, a database per tenant, preview databases, and scoped tokens. |
| 677 | |
| 678 | - [Turso](https://alchemy.run/turso) — Create Turso SQLite databases and query them from your Workers. |
| 679 | - [Setup](https://alchemy.run/turso/setup) — Give Alchemy a Turso API token. |
| 680 | - [Part 1: Your First Database](https://alchemy.run/turso/tutorial/part-1) — Create a Turso group and a template database, migrated from a Drizzle schema. |
| 681 | - [Part 2: Create Tenant Databases](https://alchemy.run/turso/tutorial/part-2) — Let a Worker create a database for each tenant. |
| 682 | - [Part 3: Query Tenant Notes](https://alchemy.run/turso/tutorial/part-3) — Read and write a tenant's notes with Drizzle, then try it out. |
| 683 | - [Groups](https://alchemy.run/turso/groups) — Turso groups decide where your databases run. |
| 684 | - [Create & configure databases](https://alchemy.run/turso/databases) — Create, copy, and protect Turso databases. |
| 685 | - [Migrations](https://alchemy.run/turso/migrations) — Run SQL migrations and seed files on every deploy. |
| 686 | - [Connections](https://alchemy.run/turso/connections) — Query a Turso database from a Worker or Lambda. |
| 687 | - [Database per tenant](https://alchemy.run/turso/database-per-tenant) — Give each customer their own Turso database. |
| 688 | - [Preview databases](https://alchemy.run/turso/preview-databases) — Give every pull request its own copy of your staging database. |
| 689 | - [Tokens](https://alchemy.run/turso/tokens) — Create tokens for apps that run outside your Stack. |
| 690 | - [Team & organization](https://alchemy.run/turso/organization) — Invite teammates and change your Turso organization's settings. |
| 691 | |
| 692 | ## Better Auth |
| 693 | |
| 694 | Better Auth as an Effect service on Workers and Lambda: a tutorial, sign-in providers, database layers, and guides for config, middleware, secondary storage, migrations, and upgrades. |
| 695 | |
| 696 | - [Better Auth](https://alchemy.run/better-auth) — Build authentication with an Effect service, automatic database bindings, and deploy-time migrations. |
| 697 | |
| 698 | ## Better Auth — Tutorial |
| 699 | |
| 700 | - [Part 1: Create an Auth service](https://alchemy.run/better-auth/tutorial/part-1) — Install Better Auth, provide a D1 database layer, and create an Effect service. |
| 701 | - [Part 2: Mount the HTTP API](https://alchemy.run/better-auth/tutorial/part-2) — Serve Better Auth routes and an Effect HTTP API from the same Worker. |
| 702 | - [Part 3: Build sign-in](https://alchemy.run/better-auth/tutorial/part-3) — Add a same-origin browser client with sign-up, sign-in, session lookup, and sign-out. |
| 703 | - [Part 4: Protect API endpoints](https://alchemy.run/better-auth/tutorial/part-4) — Resolve the session in Effect HTTP API middleware and provide a typed CurrentUser service. |
| 704 | - [Part 5: Add GitHub sign-in](https://alchemy.run/better-auth/tutorial/part-5) — Register a GitHub OAuth app, bind its credentials through Effect Config, and sign in from the browser. |
| 705 | - [Part 6: Deploy and verify](https://alchemy.run/better-auth/tutorial/part-6) — Deploy the authenticated API, configure production OAuth callbacks, and verify session boundaries. |
| 706 | |
| 707 | ## Better Auth — Sign-in providers |
| 708 | |
| 709 | - [Sign-in providers](https://alchemy.run/better-auth/sign-in-providers) — Choose a standalone sign-in walkthrough for your existing Alchemy project. |
| 710 | - [Custom OAuth and OIDC](https://alchemy.run/better-auth/sign-in-providers/custom-oauth) — Add Keycloak OIDC sign-in to an Alchemy Worker with D1, one small step at a time. |
| 711 | - [Email and password](https://alchemy.run/better-auth/sign-in-providers/email-password) — Add D1-backed registration, real email verification, and password recovery to an Alchemy project. |
| 712 | - [GitHub](https://alchemy.run/better-auth/sign-in-providers/github) — Add GitHub sign-in to a D1-backed Alchemy Worker, one step at a time. |
| 713 | - [Google](https://alchemy.run/better-auth/sign-in-providers/google) — Add Google sign-in to a D1-backed Alchemy Worker, one step at a time. |
| 714 | - [Microsoft](https://alchemy.run/better-auth/sign-in-providers/microsoft) — Add Microsoft sign-in to an Alchemy Worker with D1, one small step at a time. |
| 715 | |
| 716 | ## Better Auth — Databases |
| 717 | |
| 718 | - [Choose a database](https://alchemy.run/better-auth/databases) — Choose a Better Auth database layer with a complete, standalone integration example. |
| 719 | - [Aurora Data API](https://alchemy.run/better-auth/databases/aurora-data-api) — Deploy a Better Auth Lambda with Aurora PostgreSQL over HTTPS and automatic IAM bindings. |
| 720 | - [Cloudflare D1](https://alchemy.run/better-auth/databases/cloudflare-d1) — Deploy a Better Auth Worker with a native D1 database and automatic schema migrations. |
| 721 | - [Cloudflare Hyperdrive](https://alchemy.run/better-auth/databases/cloudflare-hyperdrive) — Deploy a Better Auth Worker with an uncached Hyperdrive connection to a Neon Postgres origin. |
| 722 | - [Drizzle](https://alchemy.run/better-auth/databases/drizzle) — Generate a Relations v2 auth schema and deploy a Better Auth Lambda with a request-scoped raw Drizzle database. |
| 723 | - [Memory](https://alchemy.run/better-auth/databases/memory) — Run a disposable Better Auth Worker with an isolate-local memory store. |
| 724 | - [MySQL](https://alchemy.run/better-auth/databases/mysql) — Deploy Better Auth on Lambda with an existing MySQL database and a request-scoped mysql2 pool. |
| 725 | - [Neon](https://alchemy.run/better-auth/databases/neon) — Deploy a Better Auth Worker with a Neon project and the serverless database driver. |
| 726 | - [Postgres](https://alchemy.run/better-auth/databases/postgres) — Deploy Better Auth on Lambda with an existing PostgreSQL database and a request-scoped pg pool. |
| 727 | - [SQLite](https://alchemy.run/better-auth/databases/sqlite) — Run Better Auth in a local Bun server with a persistent SQLite file. |
| 728 | |
| 729 | ## Better Auth — Guides |
| 730 | |
| 731 | - [Config and secrets](https://alchemy.run/better-auth/guides/configuration) — Bind Effect Config into an Alchemy host, compose database layers, and preserve generated signing secrets. |
| 732 | - [HTTP API middleware](https://alchemy.run/better-auth/guides/http-api-middleware) — Authenticate each request and provide a typed current user to Effect HTTP API handlers. |
| 733 | - [Secondary storage](https://alchemy.run/better-auth/guides/secondary-storage) — Supply a strongly consistent session and rate-limit store through an Effect layer. |
| 734 | - [Migrations](https://alchemy.run/better-auth/guides/migrations) — Apply Better Auth schema changes at deploy, or manage the schema yourself. |
| 735 | - [Upgrading from 1.6 to 1.7.5 or newer](https://alchemy.run/better-auth/upgrades/from-1-6-to-1-7) — Upgrade Better Auth directly from 1.6, preserve existing users, and update your schema and application APIs. |
| 736 | |
| 737 | ## Axiom |
| 738 | |
| 739 | Observability as Stack resources — datasets, monitors, notifiers. The exporter-Layer pattern is documented in Concepts → Observability. |
| 740 | |
| 741 | - [Axiom](https://alchemy.run/axiom) — Observability as resources — OTEL datasets, ingest tokens, monitors, notifiers, and dashboards declared next to the code that emits the data. |
| 742 | - [Setup](https://alchemy.run/axiom/setup) — Connect alchemy to Axiom — account, credentials, and profiles. |
| 743 | - [Datasets & ingest](https://alchemy.run/axiom/data/ingest) — Axiom datasets per OTel signal with OTLP endpoints as outputs, least-privilege ingest tokens, and per-stage naming with Stack.useSync. |
| 744 | - [Alerting: monitors & notifiers](https://alchemy.run/axiom/guides/alerting) — Turn APL queries into alerts — Threshold, MatchEvent, and AnomalyDetection monitors wired to Slack, email, PagerDuty, and webhook notifiers, all as resources in your Stack. |
| 745 | - [Dashboards as code](https://alchemy.run/axiom/guides/dashboards) — Declare Axiom dashboards — charts, layout, filter bars, saved views, and deploy annotations — as alchemy resources next to the services they observe. |
| 746 | - [Deploy markers & annotations](https://alchemy.run/axiom/guides/annotations) — Overlay deploys, incidents, and flag flips as vertical markers on Axiom charts — point or range annotations, scoped to one or more datasets, declared as alchemy resources. |
| 747 | |
| 748 | ## GitHub |
| 749 | |
| 750 | Repos, secrets, variables, and repository event sources as Stack resources; the CI/CD guides live under Guides and each cloud's tutorial part 5. |
| 751 | |
| 752 | - [GitHub](https://alchemy.run/github) — Repositories, Actions secrets and variables, webhooks, and repository event sources as Stack resources — the glue for CI/CD. |
| 753 | - [Setup](https://alchemy.run/github/setup) — Connect alchemy to GitHub — account, credentials, and profiles. |
| 754 | - [Repositories](https://alchemy.run/github/repository) — Manage GitHub repositories as Stack resources — create or adopt a repo, converge its settings on every deploy, rename in place, and opt into deletion explicitly. |
| 755 | - [Actions secrets & variables](https://alchemy.run/github/actions-config) — Manage GitHub Actions secrets and variables as Stack resources — encrypted secrets, plain-text variables, bulk helpers, and CI credentials provisioned as code. |
| 756 | - [Webhooks & events](https://alchemy.run/github/events) — Provision GitHub repository webhooks as resources, or subscribe a Cloudflare Worker to repository events with typed payloads and verified deliveries. |
| 757 | |
| 758 | ## Git |
| 759 | |
| 760 | A git server you build in one file, use like any remote, and reshape one block at a time: setup, a six-part tutorial (push, access control, publishing, per-user credentials, your app's API, branch protection), the REST and GitHub-compatible planes, the building blocks with their implementations, and recipes with the scaling model and measurements. |
| 761 | |
| 762 | - [Git](https://alchemy.run/git) — A pluggable, embeddable, self-hostable git server on Cloudflare Workers, Durable Objects, and R2. Smart HTTP for any client, a typed REST plane with pull requests, and a GitHub-compatible API. |
| 763 | - [Getting Started](https://alchemy.run/git/getting-started) — A complete quickstart for a Git host protected by a shared credential. Deploy it to Cloudflare, push a repository, and clone it back. |
| 764 | - [Part 1: Push your first repository](https://alchemy.run/git/tutorial/part-1) — Deploy a Git host, push a commit, and clone it back. Add storage and hashing one layer at a time. |
| 765 | - [Part 2: Control access](https://alchemy.run/git/tutorial/part-2) — Protect the existing Git host with one shared credential, then verify both accepted and rejected requests. |
| 766 | - [Part 3: Publish a repository](https://alchemy.run/git/tutorial/part-3) — Allow anonymous clones of public repositories while preserving authenticated writes. |
| 767 | - [Part 4: Give users their own credentials](https://alchemy.run/git/tutorial/part-4) — Replace the shared credential with Better Auth accounts and individual Git API keys. |
| 768 | - [Part 5: Add your application's API](https://alchemy.run/git/tutorial/part-5) — Add a typed /me endpoint beside Git and use the caller already supplied by your authentication middleware. |
| 769 | - [Part 6: Protect a branch](https://alchemy.run/git/tutorial/part-6) — Authorize parsed Git mutations in ordinary HTTP handlers, using the request's user before committing changes. |
| 770 | - [Cloning & pushing](https://alchemy.run/git/clone-and-push) — Standard git clients over smart HTTP. What the wire supports, where credentials go, and what to do when something hangs. |
| 771 | - [Repositories](https://alchemy.run/git/repositories) — Create, fork, import, and manage repositories over the typed REST plane. |
| 772 | - [Pull requests](https://alchemy.run/git/pull-requests) — Server-side merge base, tree diffs, and fast-forward or three-way merges, computed inside the repository. |
| 773 | - [GitHub API compatibility](https://alchemy.run/git/github-api) — Point the gh CLI and Octokit at your host with the /api/v3 facade. |
| 774 | - [Overview](https://alchemy.run/git/blocks) — One layer graph, provided once, builds the Worker and every Durable Object behind it. Each line is a decision with implementations you choose or write. |
| 775 | - [HTTP routes](https://alchemy.run/git/blocks/server) — Compose Git route layers beside your application's Effect HTTP API, with your middleware and server. |
| 776 | - [Engine operations](https://alchemy.run/git/blocks/engine) — Build your own HTTP API over Git operations, with scoped preparation, application authorization, and explicit commit. |
| 777 | - [Repository](https://alchemy.run/git/blocks/repositories) — One Durable Object per repository, behind the Git.RepoStore service. Provide it, call it from your own routes, compose operations through Git.Engine, or implement its shape over another store. |
| 778 | - [Registry](https://alchemy.run/git/blocks/registry) — The registry resolves owner/name to a repository and serves listings. Keep it in a Durable Object or move it to a D1 database. |
| 779 | - [Blob Store](https://alchemy.run/git/blocks/blob-store) — Bulk, immutable, content-addressed bytes. R2 by default, S3 when data has to live in AWS, or any store that can do ranged reads and multipart writes. |
| 780 | - [Hasher](https://alchemy.run/git/blocks/hasher) — Every object a push sends is inflated and hashed before a ref moves. That is CPU, and where it runs is a Layer, in the Worker, in dynamically loaded Workers, or on Lambda. |
| 781 | - [Authentication and authorization](https://alchemy.run/git/blocks/auth) — Use native Effect HTTP middleware and ordinary application effects to authorize Git operations. |
| 782 | - [Overview](https://alchemy.run/git/recipes) — Requirements pick lines. One table from what you need to the line that changes, the stack shape for one cloud or two, and complete files to copy. |
| 783 | - [Scaling](https://alchemy.run/git/recipes/scaling) — Reads scale like a CDN and writes scale like git. The shape, the per-repository limits, the measured numbers, and a worked example of pushing something large and swapping the hasher. |
| 784 | - [All on Cloudflare](https://alchemy.run/git/recipes/cloudflare) — A git host on one Cloudflare account. One Worker, one bucket, two Durable Object namespaces, and dynamically loaded Workers hashing large pushes. |
| 785 | - [Bytes in S3, hashing on Lambda](https://alchemy.run/git/recipes/cloudflare-aws) — Compute on Cloudflare, bytes in S3, and large pushes hashed one Lambda per chunk. One stack carries both provider sets, and Alchemy mints the cross-cloud identity. |
| 786 | - [Bring your own store](https://alchemy.run/git/recipes/your-own-store) — Bytes have to live somewhere that is neither R2 nor S3. Implement the five operations of Git.BlobStore and provide it in place of the shipped Layers. |
| 787 | |
| 788 | ## Stripe |
| 789 | |
| 790 | Products, prices, coupons, customers, payment links, and webhooks as Stack resources. HTTP bindings run inside a Worker or Lambda. |
| 791 | |
| 792 | - [Stripe](https://alchemy.run/stripe) — Sell subscriptions and onboard merchants from a Cloudflare Worker — catalog, Checkout, the Billing Portal, Connect, and webhooks declared next to the code that uses them. |
| 793 | - [Setup](https://alchemy.run/stripe/setup) — Connect alchemy to Stripe — secret key, profiles, CI, and how Worker bindings get their credentials. |
| 794 | - [Sell a subscription](https://alchemy.run/stripe/guides/subscriptions) — The full SaaS billing loop on one Cloudflare Worker — hosted Checkout, the Billing Portal, and webhooks that keep an entitlement record your app gates on. |
| 795 | - [Onboard merchants with Connect](https://alchemy.run/stripe/guides/connect) — Build a Connect platform on a Cloudflare Worker — create Express accounts, send merchants through hosted onboarding, and learn from account.updated when they can take payments. |
| 796 | - [React to Stripe events](https://alchemy.run/stripe/guides/webhooks) — consumeEvents provisions the webhook endpoint and runs one Effect per delivery. When to use it, which events to listen for, and how to manage the endpoint yourself. |
| 797 | |
| 798 | ## Docker |
| 799 | |
| 800 | Local and CI Docker as Stack resources — images, containers, networks, and volumes driven through the active Docker CLI context; cloud container runtimes (Cloudflare Containers, ECS) consume the pushed image refs from their own hubs. |
| 801 | |
| 802 | - [Docker](https://alchemy.run/docker) — Images, containers, networks, and volumes as Stack resources, driven through your active Docker CLI context. |
| 803 | - [Setup](https://alchemy.run/docker/setup) — Point alchemy at a Docker daemon — the active CLI context and the DOCKER_BIN override. |
| 804 | - [Local services: Postgres with containers, networks, and volumes](https://alchemy.run/docker/local-services) — Run a local Postgres for development as alchemy resources — a pinned image, a named network and volume, a Redacted password, and a healthchecked container that converges on every deploy. |
| 805 | - [Build & push images](https://alchemy.run/docker/build-and-push) — Build a container image from a Dockerfile, push it to a registry, and hand the resulting image reference to Cloudflare Containers or AWS ECS. |
| 806 | - [Docker Swarm](https://alchemy.run/docker/swarm) — Provision a swarm and deploy replicated services to it, from local dev to a remote VPS |
| 807 | |
| 808 | ## Kubernetes |
| 809 | |
| 810 | Cluster-agnostic Kubernetes workloads — Deployments, Jobs and CronJobs (as images or Effect programs), raw manifests, and Helm charts — on a local cluster or any cluster reachable through a kubeconfig, token, client certificate, or exec plugin. |
| 811 | |
| 812 | - [Kubernetes](https://alchemy.run/kubernetes) — Run containers and Effect programs on any Kubernetes cluster with Alchemy. Declare Deployments, Jobs, raw manifests, and Helm charts in the same typed program as the rest of your infrastructure. No YAML, no kubectl apply. |
| 813 | - [Setup](https://alchemy.run/kubernetes/setup) — Install Alchemy and connect it to a Kubernetes cluster, whether a local cluster on your machine, any cluster in your kubeconfig, or an explicit connection for CI. Then add a registry for images built from your code. |
| 814 | - [Part 1: Your First Deployment](https://alchemy.run/kubernetes/tutorial/part-1) — Create a Stack, start a Kubernetes cluster on your machine with Kubernetes.LocalCluster, deploy a replicated HTTP service with Kubernetes.Deployment, and reach it with kubectl. |
| 815 | - [Part 2: Namespaces & Configuration](https://alchemy.run/kubernetes/tutorial/part-2) — Create a Namespace with Kubernetes.Manifest, move the Deployment into it, and configure the app with environment variables and resource limits. |
| 816 | - [Part 3: Effect Jobs](https://alchemy.run/kubernetes/tutorial/part-3) — Write a smoke test as an Effect program, run it as a Kubernetes Job that Alchemy builds and pushes for you, watch it re-run when the program changes, and schedule it as a CronJob. |
| 817 | - [Part 4: Install a Helm Chart](https://alchemy.run/kubernetes/tutorial/part-4) — Install metrics-server from its Helm chart with Kubernetes.HelmChart, pass chart values, and check pod metrics with kubectl top. |
| 818 | - [Part 5: Deploy to Your Own Cluster](https://alchemy.run/kubernetes/tutorial/part-5) — Point the tutorial stack at a hosted Kubernetes cluster such as GKE, AKS, EKS, k3s, or anything in your kubeconfig. Keep the local cluster for development with stages, and clean up. |
| 819 | - [Connecting to clusters](https://alchemy.run/kubernetes/clusters/connecting) — Point Kubernetes resources at any cluster with Kubernetes.KubeConfig, a raw Kubernetes.Connection (bearer token, client certificate, or exec plugin), or a cluster resource such as Kubernetes.LocalCluster. |
| 820 | - [Container registries](https://alchemy.run/kubernetes/clusters/registries) — Give a Kubernetes connection a registry so Deployments and Jobs built from Effect programs or Dockerfiles are pushed where the cluster's nodes can pull them, such as GHCR, Docker Hub, Artifact Registry, ACR, or a registry of your own. |
| 821 | - [Local clusters](https://alchemy.run/kubernetes/clusters/local) — Run a Kubernetes cluster on your machine with Kubernetes.LocalCluster. It is a kind cluster in Docker with an image registry wired into its nodes, so Effect programs and Dockerfiles deploy the same way they do on a hosted cluster. |
| 822 | - [Amazon EKS](https://alchemy.run/kubernetes/clusters/eks) — Run Alchemy's Kubernetes resources on Amazon EKS. Find the guide for creating clusters, ECR images, Pod Identity, and load balancers. |
| 823 | - [Cluster adapters](https://alchemy.run/kubernetes/clusters/cluster-adapters) — The extension point between Alchemy's cluster-agnostic Kubernetes resources and the platform a cluster runs on. Covers authentication, image registries, workload identity, load balancer defaults, and how to write your own. |
| 824 | - [Deployments](https://alchemy.run/kubernetes/workloads/deployments) — Run a replicated server on any Kubernetes cluster with Kubernetes.Deployment. Covers names, namespaces, Service types and URLs, replicas, resources, labels, the pod template escape hatch, and Effect servers. |
| 825 | - [Jobs & CronJobs](https://alchemy.run/kubernetes/workloads/jobs) — Run work to completion with Kubernetes.Job, as a container image or as an Effect program, and on a schedule as a CronJob. Covers how Job names, re-runs, retries, and cleanup work. |
| 826 | - [Container images](https://alchemy.run/kubernetes/workloads/images) — Choose where a Deployment or Job's container image comes from and where built images are pushed. Sources are a registry reference, your own Dockerfile, or a bundled Effect program. |
| 827 | - [Configuration & bindings](https://alchemy.run/kubernetes/workloads/bindings) — Pass configuration into Kubernetes workloads with env and Outputs, understand the variables Alchemy sets, keep secrets out of plain text, and use bindings. |
| 828 | - [How objects are managed](https://alchemy.run/kubernetes/workloads/object-lifecycle) — How Alchemy applies, orders, prunes, and deletes Kubernetes objects, including server-side apply and field ownership, drift, replacement, unreachable clusters, and adoption. |
| 829 | - [Manifests](https://alchemy.run/kubernetes/objects/manifests) — Apply any single Kubernetes object with Kubernetes.Manifest, including Namespaces, ConfigMaps, Secrets, StatefulSets, Ingresses, CRDs and custom resources, and order objects with Output references. |
| 830 | - [Helm charts](https://alchemy.run/kubernetes/objects/helm-charts) — Install Helm charts with Kubernetes.HelmChart. Covers repository, OCI, and local charts, values, release names, namespaces, CRDs, hooks, and how Alchemy owns the rendered objects instead of a Helm release. |
| 831 | |
| 832 | ## SQL |
| 833 | |
| 834 | Database comparison, Effect SQL, Drizzle, Prisma ORM v8 (Postgres-only), committed migrations, and connection lifecycle. Deployment walkthroughs live with their runtime providers. |
| 835 | |
| 836 | - [SQL](https://alchemy.run/sql) — Choose a database, connect with Effect SQL, Drizzle, or Prisma ORM, and deploy committed migrations. |
| 837 | - [Databases](https://alchemy.run/sql/databases) — Compare database engines, connection paths, and deployment guides across Alchemy's SQL providers. |
| 838 | - [Postgres](https://alchemy.run/sql/effect-sql/postgres) — SQL.Postgres turns a connection string into an @effect/sql-pg client — tagged-template queries with typed errors, one pool per execution. |
| 839 | - [MySQL](https://alchemy.run/sql/effect-sql/mysql) — SQL.MySQL turns a connection string into an @effect/sql-mysql2 client — portable tagged-template queries with typed errors and one pool per execution. |
| 840 | - [D1](https://alchemy.run/sql/effect-sql/d1) — SQL.D1 wraps a bound D1 database in an @effect/sql-d1 client — tagged-template queries with typed errors over the native binding. |
| 841 | - [libSQL](https://alchemy.run/sql/effect-sql/libsql) — Run SQL on a libSQL database, such as Turso, with Effect SQL. |
| 842 | - [Migrations](https://alchemy.run/sql/effect-sql/migrations) — Commit ordered SQL files and apply them on database deploy or Durable Object activation, tracked in one Alchemy-owned table. |
| 843 | - [Connection lifecycle](https://alchemy.run/sql/effect-sql/lifecycle) — SQL and Drizzle clients build lazily, reuse a client within the current execution scope, and release resources when that scope closes. |
| 844 | - [Postgres](https://alchemy.run/sql/drizzle/postgres) — Provider-neutral Postgres schemas, Effect-native Drizzle queries, and connections for Workers, Lambda, and servers. |
| 845 | - [MySQL](https://alchemy.run/sql/drizzle/mysql) — Provider-neutral MySQL schemas, Effect-native Drizzle queries, and connection configuration. |
| 846 | - [D1](https://alchemy.run/sql/drizzle/d1) — SQLite schemas and Effect-native Drizzle queries over a Cloudflare D1 binding. |
| 847 | - [libSQL](https://alchemy.run/sql/drizzle/libsql) — Use Drizzle with a libSQL database, such as Turso. |
| 848 | - [Migrations](https://alchemy.run/sql/drizzle/migrations) — Generate migrations when your schema changes, review and commit the SQL and snapshots, then deploy from Git. |
| 849 | - [Postgres](https://alchemy.run/sql/prisma/postgres) — Connect Prisma ORM v8 to Postgres and run Effect-native queries, streams, prepared statements, and transactions independently of your cloud provider. |
| 850 | - [Contracts](https://alchemy.run/sql/prisma/contracts) — Author Prisma ORM v8 contracts in Prisma Schema Language or TypeScript, generate optional Effect bindings and row schemas, and connect them to migrations. |
| 851 | - [Migrations](https://alchemy.run/sql/prisma/migrations) — How Prisma.Contract and Prisma.Migrate run Prisma's contract emission, migration planning, and graph-ordered apply inside alchemy deploy. |
| 852 | |
| 853 | ## Command |
| 854 | |
| 855 | Cloud-agnostic local process primitives — memoized builds, one-off commands, and dev servers; the static-site guides in each cloud hub consume them under the hood. |
| 856 | |
| 857 | - [Command](https://alchemy.run/command) — Alchemy's cloud-agnostic primitives for local processes in the deploy graph — memoized builds, one-off commands, and dev servers. |
| 858 | - [Memoization: builds & one-off commands](https://alchemy.run/command/memoization) — Content-hash memoization shared by Command.Build and Command.Exec — what gets hashed, when a command re-runs, and the outdir contract on destroy. |
| 859 | - [Dev servers](https://alchemy.run/command/dev-servers) — Run a framework dev server as a Command.Dev resource — started by alchemy dev, a no-op on alchemy deploy, with the server's URL surfaced back into your stack. |
| 860 | |
| 861 | ## ACME |
| 862 | |
| 863 | TLS certificates from any ACME certificate authority as Stack resources, validated over DNS, renewed on deploy, or issued at runtime. |
| 864 | |
| 865 | - [ACME](https://alchemy.run/acme) — Manage TLS certificates independently of your hosting provider, at deploy time or from an application. |
| 866 | - [Getting started](https://alchemy.run/acme/getting-started) — Issue a staging TLS certificate with Let's Encrypt and an existing Cloudflare DNS zone. |
| 867 | - [Certificate authorities](https://alchemy.run/acme/certificate-authorities) — Select a CA, configure external account binding, and understand account identity and key storage. |
| 868 | - [DNS validation](https://alchemy.run/acme/dns-validation) — Configure Cloudflare DNS-01 challenges, wildcard certificates, propagation, and custom solvers. |
| 869 | - [Renewal & revocation](https://alchemy.run/acme/renewal) — Schedule renewal, understand replacement and deletion, and protect certificate and account keys. |
| 870 | - [Runtime issuance](https://alchemy.run/acme/runtime) — Deploy an authenticated Worker that issues and revokes certificates using a bound ACME account. |
| 871 | - [Using certificates](https://alchemy.run/acme/using-certificates) — Upload an ACME certificate to Fly or pass its chain and private key to another TLS consumer. |
| 872 | - [Troubleshooting](https://alchemy.run/acme/troubleshooting) — Diagnose failed DNS challenges, rejected orders, rate limits, and runtime certificate operations. |
| 873 | |
| 874 | ## Domain |
| 875 | |
| 876 | A domain-driven design framework: model commands, events, aggregates, views, projections, policies, and sagas once, then host them on Durable Objects or in memory. |
| 877 | |
| 878 | - [Domain](https://alchemy.run/domain) — A domain-driven design framework for Effect. Model your business as commands, aggregates, events, views, projections and policies, test it in memory, and run it on Cloudflare Durable Objects. |
| 879 | - [What is Domain-Driven Design?](https://alchemy.run/domain/what-is-ddd) — The concepts of Domain-Driven Design, event sourcing and CQRS, and how they fit together to model a business. |
| 880 | - [Project layout](https://alchemy.run/domain/project-layout) — How to lay out an @alchemy.run/domain project. One file per building block, named after its noun and its kind; folders per subdomain; a pure domain package, a server package that hosts it, and a foldkit web package, wired in one stack. |
| 881 | - [Part 1: Model an account](https://alchemy.run/domain/tutorial/part-1) — Declare events, commands and rejections, decide them in an aggregate, and check it with stories. |
| 882 | - [Part 2: Read it with a view](https://alchemy.run/domain/tutorial/part-2) — Show each account's balance and a statement of every movement, kept up to date as events arrive. |
| 883 | - [Part 3: React with a policy](https://alchemy.run/domain/tutorial/part-3) — Register customers, and open a main account for each one with a policy. |
| 884 | - [Part 4: Expose an Api](https://alchemy.run/domain/tutorial/part-4) — Authenticate requests, let customers act only on their own accounts, and expose the bank through a typed Api. |
| 885 | - [Part 5: Deploy to Cloudflare](https://alchemy.run/domain/tutorial/part-5) — Host the bank on Durable Objects behind a Worker, run it locally, deploy it, and watch a balance change live. |
| 886 | - [Part 6: Build the UI with foldkit](https://alchemy.run/domain/tutorial/part-6) — A browser app that signs in with a cookie, opens an account, deposits, and watches its balance live. |
| 887 | - [Part 7: Observe it](https://alchemy.run/domain/tutorial/part-7) — Send the bank's traces and logs to Axiom, follow a deposit through every Durable Object it reaches, and trace clicks from the browser. |
| 888 | - [Part 8: Change a deployed model](https://alchemy.run/domain/tutorial/part-8) — Change what a view computes after it has data, add a view over every account, and follow what each deploy does with the events already recorded. |
| 889 | - [Domain Model](https://alchemy.run/domain/model) — What a domain model contains, how it processes every command, and how you declare, run and use one. |
| 890 | - [Command](https://alchemy.run/domain/command) — How a command names its target, carries its data, declares every outcome, and reaches its aggregate exactly once. |
| 891 | - [Event](https://alchemy.run/domain/event) — What an event records, what to put in it, how it's stored, and how the rest of the model consumes it. |
| 892 | - [Aggregate](https://alchemy.run/domain/aggregate) — How an aggregate holds state, decides commands, applies events, and keeps its rules consistent. |
| 893 | - [View](https://alchemy.run/domain/view) — How a view folds events into a read model per key, emits events of its own, combines other views, and serves reads. |
| 894 | - [Projection](https://alchemy.run/domain/projection) — How a projection consumes events into a store you own, in order per key, batched and replayable, and why it never sends commands. |
| 895 | - [Stream](https://alchemy.run/domain/stream) — How a stream keeps a keyed, append-only log that a projection writes and clients read through an Api, with its latest entry as the current value. |
| 896 | - [Policy](https://alchemy.run/domain/policy) — How a policy reacts to events with commands and calls to outside systems, and how to make it safe to run more than once. |
| 897 | - [Saga](https://alchemy.run/domain/saga) — A process that spans several aggregates and takes time, run step by step as an Effect workflow, with steps that undo earlier ones when a later one fails. |
| 898 | - [External System](https://alchemy.run/domain/external-system) — Declare the outside systems your model calls in the model's own language, implement them with Layers, and turn their events into commands. |
| 899 | - [Api](https://alchemy.run/domain/api) — How an Api publishes a model to one kind of client, how it's served, and how a typed client calls it. |
| 900 | - [Story](https://alchemy.run/domain/story) — A specification you can run. Given some history, when a command is sent, then these events are recorded. |
| 901 | - [Testing a model](https://alchemy.run/domain/testing-models) — Test your model's rules, views, policies and deadlines with stories that run it in memory. |
| 902 | - [Testing an Api](https://alchemy.run/domain/testing-apis) — Test what each client may do and see, in process, over HTTP, and against a real deployment. |
| 903 | - [Integrate with Foldkit](https://alchemy.run/domain/foldkit) — Derive Foldkit Commands from an Api, follow View snapshots, and seed the Model from Flags. |
| 904 | - [Optimistic updates](https://alchemy.run/domain/optimistic-updates) — Show pending intent, confirm it by commandId from a View feed, and retry an unknown outcome safely. |
| 905 | - [Offline and local first](https://alchemy.run/domain/local-first) — Choose how local an app is, and keep it working offline by recording intents and sending them when the connection returns. |
| 906 | - [MCP](https://alchemy.run/domain/mcp) — Give an agent the commands and reads of an Api as tools, inside the app with Effect AI, or outside it over MCP. |
| 907 | - [Sessions and middleware](https://alchemy.run/domain/sessions) — Authenticate every request, carry who is asking into the domain, and sign browsers in with a cookie. |
| 908 | - [Sign in with better-auth](https://alchemy.run/domain/better-auth) — Sign users in to a Domain Api with GitHub or Google through better-auth, and give every command and view the signed-in user. |
| 909 | - [Views as security boundaries](https://alchemy.run/domain/view-security) — Decide who may read each view, keep watches honest as data changes hands, and give each audience a view of its own. |
| 910 | - [Unique values](https://alchemy.run/domain/unique-values) — Keep a value unique across every customer by making the value itself an aggregate. |
| 911 | - [Deadlines](https://alchemy.run/domain/deadlines) — Give a waiting process a time limit with a scheduled command, and let the aggregate decide whether the deadline or the action wins. |
| 912 | - [Cloudflare Durable Objects](https://alchemy.run/domain/cloudflare) — Host a domain model on Durable Objects behind a Worker, with live reads over WebSockets. |
| 913 | - [History at scale](https://alchemy.run/domain/backfill) — How a deploy backfills new views and projections on Cloudflare, how long it takes, and how to run a large Domain within Cloudflare's limits. |
| 914 | - [In memory](https://alchemy.run/domain/in-memory) — Run a domain model in a single process, for tests and for apps that don't need Cloudflare. |
| 915 | - [Plain HTTP and OpenAPI](https://alchemy.run/domain/http-api) — Publish an Api as a plain HTTP JSON API, with an OpenAPI document, from the same Api. |
| 916 | - [CLI](https://alchemy.run/domain/cli) — Run an Api's calls from a terminal, as a person or an agent, against the deployed Api. |
| 917 | - [Observability](https://alchemy.run/domain/observability) — Trace how commands, events and reactions flow through an @alchemy.run/domain model, across Durable Objects and over hours. Automatic spans, correlation ids and metrics, plus the attributes you choose to record. |
| 918 | |
| 919 | ## API reference |
| 920 | |
| 921 | Service-level API reference, generated from JSDoc on the source `.ts` files via `bun scripts/generate-api-reference.ts`. Each page groups resources and capabilities by service, with a heading per resource and examples extracted from source JSDoc. |
| 922 | |
| 923 | The service-level pages are indexed in [llms-full.txt](https://alchemy.run/llms-full.txt), which repeats this entire file plus one link per service. Warning: it is large (~201 KB) — only fetch it when you need to locate a specific resource's reference page. |