fuast vs Val Town

Val Town and fuast are both lightweight, TypeScript-first, and allergic to setup. If you like the idea of writing a little code in the cloud and having it just run, you will like both. The difference is the shape of what you are shipping. Val Town runs a function. fuast runs an app.

The core difference: a function vs a full app

Val Town is built around the val: a small piece of TypeScript, a script, an HTTP handler, a scheduled job. It is perfect for the glue that holds a stack together. A webhook receiver, a cron that pings an API, a quick tool you call from the command line. You write the function, Val Town hosts it and gives you a URL.

fuast is a step up in shape. A capsule is a whole app: a server/ half with a schema, queries, mutations, and endpoints, and a client/ half that is a real Preact UI your team opens in a browser. It is the difference between "a function that does one thing" and "a small piece of software a team signs into and uses."

import { capsule, table, string, query, mutation } from "fuast/server";

export default capsule({
  schema: {
    requests: table({ what: string(), status: string() }),
  },
  queries: { all: query(async (ctx) => ctx.db.requests.order("desc").collect()) },
  mutations: {
    submit: mutation(async (ctx, what: string) => {
      if (ctx.auth.isGuest) throw new Error("sign in first");
      return ctx.db.requests.insert({ what, status: "pending" });
    }),
  },
});

That is a database, verified sign-in, and a client all in one deploy. A val is one handler; a capsule is the app the handler would have been a small part of.

Batteries: bring your own vs included

On Val Town you reach for storage, auth, or a database by wiring in a service, a key, an external Postgres. That is fine for glue code, which usually has no user accounts and no UI. But the moment your function grows into "a tool the team uses," you are assembling the same auth plus database plus sharing that every small app needs.

fuast bundles that from the start. It is batteries-included: ctx.db, ctx.auth, ctx.storage, ctx.email, and cron are part of the platform. And it is agent-native, so you can tell your AI "build us a feedback board" and it writes the whole capsule to the published contract.

Where Val Town is the better call

Honest comparison, so here is where Val Town wins outright.

• Glue code and webhooks. A single handler that receives a webhook and forwards it belongs in a val, not a full app. Val Town nails this.
• Snippets and scripts you share as code. Val Town's culture is public, forkable TypeScript. Reading and remixing other people's vals is a real strength.
• The absolute minimum shape. When all you need is one function on a URL or a clock, spinning up a whole app is overkill. Val Town is the leaner fit.

fuast is not trying to be the home for a single function. It is trying to make the whole small app trivial to write and share.

Where fuast wins

• A full app, not a function. Server, client, database, and auth in one capsule, so the thing has a UI your team actually opens.
• Your AI writes it. The contract is small and documented for a model, so a sentence becomes a working app on the first try.
• Share it like a doc. Deploy, send a link, coworkers sign in with their own account and the app sees verified identities.
• Real isolation. Each capsule runs in its own V8 isolate on its own subdomain origin.

The short version

Choose Val Town when the job is a function, a cron, or a webhook you want to write and host in seconds. Choose fuast when the job is a whole small app with a UI, a database, and a signed-in team. See it on your own team: start free, read what a small cloud is, or see the batteries a small app needs.