Signature requests

You need one person to sign one document. So you email the PDF, ask them to "reply to confirm," and now the record of a legal agreement is a sentence in an inbox. Or you pay for a full e-signature product with a per-envelope price and a seat for everyone who touches it, to send three documents a month. The gap between "reply to confirm" and enterprise DocuSign is exactly the shape of a small app nobody wants to build from scratch.

The reason nobody builds it: a signature flow needs verified identity, file storage, and a way to email people. That is a week of plumbing for an afternoon of app, so it never happens.

What it is on fuast

One capsule. You upload a document and request a signature from someone by email. They open the link, sign in as themselves, read the document, and click sign. You get emailed the moment they do, and the record, who signed, when, and the file, is stored in the app. It is a small app you deploy once and share like a doc, not a product you rent per envelope.

Steal this prompt

Paste this to your AI. It writes the capsule; you run fuast deploy.

Build a signature-request capsule on fuast. The owner uploads a document file and creates a request naming the signer by email and a title. The signer opens the app, sees requests addressed to them, views the document, and clicks "Sign", which records their verified identity and a timestamp and flips the status to "signed". Email the owner when a request is signed, and email the signer when a new request is created for them. Store the uploaded file with fuast storage. Use built-in auth, never trust a signer identity passed from the client.

What makes it real

The signature is only worth anything because fuast knows who signed. The capsule records ctx.auth.userId and ctx.auth.email at the moment of signing, verified by the platform, not typed into a form. That is the difference between "reply to confirm" and a real record.

The document itself lives in built-in file storage. The client calls uploadFile(file) and stores the returned key; the server hands back an access-controlled URL, so the file is only visible to people the app is shared with. Email notifications and the database come from the same import. You never wire up a bucket or an SMTP provider.

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

export default capsule({
  schema: {
    requests: table({
      title: string(),
      fileKey: string(),        // the stored document
      signerEmail: string(),
      status: string(),         // pending | signed
      signedById: string(),
      signedAt: string(),
    }).index("by_signer", ["signerEmail"]),
  },
  mutations: {
    sign: mutation(async (ctx, id: string) => {
      if (ctx.auth.isGuest) throw new Error("sign in first");
      const req = await ctx.db.requests.get(id);
      if (!req || req.signerEmail !== ctx.auth.email) throw new Error("not your request");
      await ctx.db.requests.update(id, { status: "signed", signedById: ctx.auth.userId, signedAt: new Date().toISOString() });
      await ctx.email.send({ to: "owner@you.com", subject: `${req.title} signed`, text: "The document was signed." });
    }),
  },
});

A capsule is the whole thing: upload, request, sign, notify, store. No envelopes, no per-seat wall, no product to learn.

Send your first signature request today. Build it on fuast.