Inventory and asset tracker

Where is the spare laptop? Who has the demo unit? Did the loaner projector ever come back? Every ops team is quietly the custodian of a pile of stuff, and the way most of them track it is a spreadsheet with a "checked out by" column that is wrong by Friday. The moment someone forgets to update the cell, the whole thing is a guess.

The status quo can't tell who actually took the laptop

A spreadsheet does not know who is editing it, so "checked out by: Sam" is just a string someone typed, and typed strings go stale, get misspelled, or get skipped entirely. There is no record of when an item left or came back, so you cannot audit a loss. And because anyone with the link can overwrite any row, the log is only as honest as the busiest person's memory. It is inventory tracking with no idea who is holding the inventory.

The fuast version knows who checked it out

On fuast an asset tracker is one capsule: a list of items with their quantity and status, and a check-out action that stamps the item with the verified identity of the person taking it. Check-in clears it. Because coworkers sign in with their own account, "who has the demo unit" is a fact the app records, not a cell someone remembered to fill in.

Steal this prompt

Paste this to your AI. It reads the fuast contract at /llms.txt and writes the app.

Build a fuast capsule for asset tracking. Each item has a name, a category, and a quantity. A signed-in coworker can check an item out, which records that it is held by them using their verified identity, and check it back in, which clears the holder. Show a list of items with who currently has each one. Only let the person holding an item check it back in. Deploy it and share it with the workspace.

What makes it real on fuast

An asset log is only trustworthy if the platform, not a text field, records who is holding what. That comes from two things fuast builds in:

• Verified identity on every action. Check-out writes ctx.auth.userId, the identity the platform verified when the person signed in, so the holder is a fact and not a guess. The app can also enforce that only the current holder checks an item back in.
• A real database with mutations and queries. A checkOut mutation writes the holder and re-checks ownership before check-in; a query renders the live list. No spreadsheet drift, no manual reconciliation.

A slice of the server half:

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

export default capsule({
  schema: {
    items: table({
      name: string(),
      category: string(),
      quantity: number(),
      heldBy: string(),      // "" when available
    }).index("by_holder", ["heldBy"]),
  },
  queries: {
    all: query(async (ctx) => ctx.db.items.order("asc").collect()),
  },
  mutations: {
    checkOut: mutation(async (ctx, id: string) => {
      if (ctx.auth.isGuest) throw new Error("sign in first");
      const item = await ctx.db.items.get(id);
      if (!item || item.heldBy) throw new Error("not available");
      return ctx.db.items.update(id, { heldBy: ctx.auth.userId });
    }),
    checkIn: mutation(async (ctx, id: string) => {
      const item = await ctx.db.items.get(id);
      if (!item || item.heldBy !== ctx.auth.userId) throw new Error("not yours to return");
      return ctx.db.items.update(id, { heldBy: "" });
    }),
  },
});

That is check-in and check-out with real ownership, on a database you never had to provision.

Know where your stuff is

An asset tracker that records who took what, on verified sign-in, is exactly the small software fuast runs. Read up on the capsule it is built on, then build one for your team.