Team directory

Who owns billing? Who is the on-call for data? What is the new designer's name again? Every growing team needs a directory, and almost none of them have a good one. What they have is a wiki page that went stale in March, a spreadsheet only HR edits, or an org chart in a slide deck from the last all-hands.

The status quo goes stale the day it ships

The problem with the wiki page and the spreadsheet is the same: one person keeps them, so everyone else's changes never land. The new hire is not in it for two weeks. Someone's role changed and nobody updated the cell. And because a spreadsheet has no idea who is looking at it, you cannot tell "editable by the team" from "editable by anyone with the link." It drifts out of date because keeping it current is somebody's chore instead of everybody's.

The fuast version is a directory the team keeps

On fuast a team directory is one capsule: a searchable list of people, their role, and what they own, that anyone in the workspace can edit. Because coworkers sign in with their own account, the app knows who each person is, so someone can claim and update their own entry without an admin in the loop. It stays current because everyone can fix it, not just the one person who owns the spreadsheet.

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 a team directory. Each entry has a name, role, team, and a short "what I own" note. Any signed-in coworker can add an entry or edit one, and searching by name, team, or keyword filters the list. Tie each entry to the verified identity of the person who created it so people can update their own. Deploy it and share it with the whole workspace.

What makes it real on fuast

A directory is only useful if it is trusted and current, and both of those come from the platform:

• Verified identities, not typed-in names. Coworkers open the link and sign in with their real account, so the directory is built on ctx.auth, the identity the platform verifies, not a text field. No fake or duplicate people.
• The workspace can edit it. Sharing a fuast app like a doc with --visibility workspace means every signed-in coworker can open and update it. The directory is a shared surface, so it stops being one person's job to maintain.
• A real database and search back it, so the list is live and filtering is a query, not a find-in-page on a frozen document.

A slice of the server half:

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

export default capsule({
  schema: {
    people: table({
      name: string(),
      role: string(),
      team: string(),
      owns: text(),
      claimedBy: string(),   // verified userId who manages this entry
    }).index("by_team", ["team"]),
  },
  queries: {
    all: query(async (ctx) => ctx.db.people.order("asc").collect()),
  },
  mutations: {
    upsert: mutation(async (ctx, name: string, role: string, team: string, owns: string) => {
      if (ctx.auth.isGuest) throw new Error("sign in first");
      return ctx.db.people.insert({
        name, role, team, owns, claimedBy: ctx.auth.userId,
      });
    }),
  },
});

The client renders a search box over the all query and a small form to add or edit an entry. No auth to build, no server to keep alive.

Give your team a directory they trust

A who's-who that the whole workspace keeps current, on verified sign-in, is exactly the kind of small tool fuast exists to run. Learn how sharing works in share like a doc, then build one.