Core grammar relationships · StartupBuilder

Each Relationship below starts from one of these Nouns and reads from both ends: its predicate one way, its inverse the other. Relationships lists the most connected Nouns and every area.

Action actsOn one Thinginverse actedOnByThe Thing an Action changes; a Thing’s history is the Actions that acted on it.
Action asks many Questionsinverse actionA pending Action asks Questions and waits `awaitingInput` until each is answered or its deadline passes.
Action emits many Eventsinverse emittedByA completed Action emits its Events, which Triggers, Watches and Metrics read.
Action invokes one Verbinverse invokedAsEach Action performs one Verb, which fixes its inputs, the Event it emits and its delay window.
Action posts many Costsinverse postedByEvery Cost an Action causes posts to the Startup it ran in, so each Startup’s P&L is complete.
Action runsIn one Modeinverse modeOfThe Mode the caller chose: `try` stores nothing, `send` returns a pending Action, `do` waits for the result.
Approval gates one Actioninverse approvalsAn Approval holds one pending Action that exceeds a Limit or Mandate until someone allows or refuses it.
Capability exposes many Nounsinverse exposedByA Capability exposes Verbs on one Noun family, metered, limited and logged under one key.
Collection contains many Thingsinverse memberOfMembers are listed one by one or matched by the Collection’s saved query; a Thing can belong to many Collections.
Comment annotates one Thinginverse commentsA Comment is an internal note on one Thing, never sent to a Contact.
Decision decides one Thinginverse decidedByA Decision records one choice about a Thing and stays on that Thing’s record forever.
Document exportsTo many Filesinverse exportOfEach rendering of a Document to a format, such as PDF, is stored as a File.
Entry fallsIn one Periodinverse entriesAn Entry posts to the month its Event happened; closing the Period locks it.
Entry postsTo one Accountinverse entrieseach Entry posts to one Account, and an Account’s balance is the sum of its Entries.
Event causes many Entriesinverse causedByEvery ledger Entry traces to the one Event that caused it, such as `Order.paid`.
Function implements one Verbinverse implementedByA Function is how a Verb runs: code, a generative model, an Agent or a Human, and the caller never sees which.
Function uses many Secretsinverse usedByA Function declares the Secrets it reads; deploying to `live` fails when one is missing there.
Guard screens many Messagesinverse screenedByGuards check every outbound Message before it goes out.
Integration connects one Systeminverse connectedViaAn Integration connects an outside Source to one System, with credentials at Studio, Startup or Customer scope.
Integration wraps one Sourceinverse integrationsan Integration binds one wrapped Source to a System with credentials.
Interface mountedOn many Domainsinverse mountsAn Interface answers requests on the hostnames it is mounted on.
Interface reaches one Productinverse reachedViaEach Interface exposes one Product; a Product is reached through many Interfaces.
Interface speaks many Standardsinverse spokenByCallers in a Standard’s shape reach the Interface’s Verbs through the platform’s one translator for that Standard.
Noun movesThrough one Lifecycleinverse governsA Noun’s Lifecycle lists the states its Things move through and the Verbs that move them.
Process carriesOut one Playinverse carriedOutByA Process runs the steps of a Play each time the Startup runs it.
Process uses many Workflowsinverse usedInA Process does its work through Workflows, each the durable, executable part of the Process.
Question postedIn one Threadinverse questionsEach Question posts in the Thread of the record it concerns, where free-text replies land.
Relationship typedBy one Verbinverse typesA Relationship reads through a Verb whose forms name it from each side, such as `makes` and `madeBy`.
Resource livesAt one Sourceinverse resourceseach Resource lives at one Source, and a Source holds many Resources.
Setting configures one Thinginverse configuredByThe Thing whose choice a Setting holds; everything below it inherits the value unless it sets its own.
System defines many Nounsinverse definedInThe Nouns a System keeps records of; several Systems can share one Noun.
System runsOn many Capabilitiesinverse runsA System is built on Capabilities, such as Workflows or Search, that every Startup reaches with one key.
Task assignedTo one Workerinverse tasksThe Worker a Task waits on; the Task sits in that Worker’s inbox until it is done.
Tenant signsInVia many SSO Connectionsinverse servesA Tenant’s people sign in through its SSO Connections; the Customer’s admin owns each one.
Tenant verifies many Domainsinverse verifiedByA Tenant proves control of its Customer’s email domain, so sign-ins on that domain follow the Tenant’s policy.
Thing aimsFor many Goalsinverse heldByEvery Thing pursues Goals, such as a Startup’s quarterly objective or a Team’s weekly target.
Thing instanceOf many Nounsinverse instancesA Thing takes the properties, relationships and Verbs of every Noun it is an instance of.
Thing versionedAs many Versionsinverse versionOfEvery published change to a Thing’s definition is an immutable Version, kept forever.
Thread groups many Messagesinverse threadA Thread groups Messages that reply to one another.
Tool exposes one Verbinverse exposedAsA Tool is one Verb under one name on every Interface, such as `Contact.create`.
Trigger firesOn many Eventsinverse firesA Trigger fires each time an Event matching its selector happens.
Trigger starts many Workflowsinverse startedByWhen a Trigger fires, each Workflow it starts runs as a new Action.
Verb actsOn one Nouninverse actedOnByEvery Verb acts on one Noun, which names it: `Startup.launch` acts on Startup.
Verb defaultsTo one Modeinverse defaultForThe Mode a call uses when the caller names none: `try`, `send` or `do`.
Watch delivers many Eventsinverse deliveredByA Watch delivers each matching Event to its URL, signed, retried and replayable.
Workflow executes one Actioninverse executedByA Workflow is the durable body of one Action: its steps, retries and waits.