How a new organization and project are born¶
Audience: whoever stands up a new customer or a new project — a quality manager or an installation administrator.
A project in LQMS is a scope: a strictly separated space holding one project's documents, records, roles and configuration. A scope belongs to an organization — the customer or operating company that is the hard separation boundary. Both are created in the tool — but they are created by two different acts, and that separation is the first thing to understand about this page.
(The API, the database and the decision records call an organization a mandator. Same thing, internal name — you meet it only if you read those.)
0. Two processes, and why they are not one form¶
Founding an organization and setting up a project are different business processes. One says a new customer exists; the other says we are starting a piece of work for a customer that already exists. They are usually done by different people, on different days, for different reasons — and one of them creates a boundary that can never be moved afterwards.
Until August 2026 the tool merged them: the new-project form's organization picker carried an inline "— new organization —" entry, so founding a whole tenant was one dropdown slip away from routine work. Now the two acts are two entries in the Administration menu, and you choose which one you are doing before you are on either surface:
- Project setup — setting a project up inside an organization that already exists. The routine act.
- Found an organization — its own workflow, on its own page, visible only to whoever holds the founding right. The operator's act.
The project process can no longer create an organization at all, and the founding act is nowhere inside it — not even as an offer. If you need an organization, you found it first from its own menu entry, and the founding workflow then offers to continue straight into its first project.
1. The act sequence¶
This is the order the acts happen in, and most of it is forced: each step depends on the one above it. The first line is a separate act on a separate page; everything under it is one run of the wizard.
- Organization — founded in its own workflow (§1a), or already there and simply named as the project's boundary (§2).
- Project (scope) — its code, its name, its derive-source capability.
- Roles activated in the project (from the installation catalog) — a policy may only name roles the project has activated, and a person may only be assigned a role the project has activated.
- Staffing — people assigned to those roles, you included (staffing & assignments); §3 explains why this one cannot wait.
- Document types activated in the project (from the installation catalog), each before its own configuration.
- Review policies, may-define rights and acknowledgement policies, per type.
- Folders.
- Special elements declared, where the lane wants them (special elements) — last, and deliberately not tolerant of an "already there": a project that already mints items of that kind has its name and prefix frozen, and that must be read, not silently skipped. Declaring a kind also declares what it depends on: risks bring risk controls, a validation case brings the user need and the requirement behind it, in the same audited act.
- The setup check reads complete.
1a. Founding an organization¶
Administration → Found an organization. The menu entry appears for whoever holds the founding right and for nobody else. Where the absence would otherwise be a dead end — the project form of an installation that carries no organization at all — the process is named there instead, with the right that carries it and the roles that hold it, rather than leaving a reader to conclude the tool cannot do it.
The page states what the act creates before the name field, because all three of these outlive the click:
- its own space — every project, document and record of this organization stays inside it, and nothing crosses to another organization;
- its own membership — people are invited into this organization and hold their functions inside it, independently of every other one;
- its own audit trail — what happens there is recorded there, permanently.
Then one field: the organization's name. A name that already exists is refused, never adopted — the server names the existing organization and tells you to pick it instead. Two customers silently collapsing into one tenant is exactly the failure separation exists to prevent. The founding itself is recorded in the installation's audit trail, with your name and the organization's.
It does not end on a success message. A freshly founded organization has no project and nobody in it, so the workflow offers both of its first beats:
- Set up its first project — hands over to the project wizard with this organization already carried and stated (see §2);
- Invite its first member — the ordinary membership invitation on Admin → People; the person answers it themselves, and until they accept they see nothing of the organization.
Underneath, quietly, the undo: while an organization is still completely empty it can be dissolved (§6). Once it holds anything at all — a project, a member, even a single audit entry — it stays.
2. Step 1 in detail — the form¶
- Organization (customer) — the boundary this project will belong to. It is asked for only when there is a real choice, and stated in every case:
- more than one organization → a picker, with no default at all: nothing is preselected and the step will not advance until you choose. The tenant boundary is the one fact this system exists to keep straight, so it is never set by form initialization;
- exactly one → no question. The binding is stated as a prominent fact before anything is committed — "This project will belong to: Acme Corp" — because a question with one possible answer is not a safeguard, and an unstated binding is not either;
- none yet → the form says so and points at the founding workflow (or at the person who holds it). A project cannot exist without an organization, and this form cannot make one.
- Arriving here from the founding workflow, the newborn organization is the stated boundary, and — where others exist — it can still be exchanged for another one. Exchanging clears the binding rather than swapping in the next candidate: from that moment it is a choice again.
- Project code — "Unique and immutable; it prefixes every document id in this project." A code already in use is refused by name.
- Project name — free text.
Neither project CAPABILITY is asked here, and for two different reasons. Whether the project holds its own records is derived by the server from the project type — the form says so: "A project keeps its own records — the server sets that from the project type, so it is not asked here." Whether it may be a derive source is a governed setting on an existing project, changed under Administration → Scopes by a holder of MANAGE_SCOPES at the installation level and recorded in the trail. It left the birth form in July 2026: a brand-new project is never a derive source (base procedures are derived into a project from the operating organization's own project rather than out of it), so asking at birth only offered a wrong answer, while the real decision belongs to a project that already exists.
Nothing is written on this step. The project becomes the first item of the commit plan on Apply & verify, so you can still go back and change everything — and that plan item names its organization in words ("under organization Acme Corp"), because the binding is the one thing here that can never be corrected afterwards.
Two things this surface deliberately does not do: it never deletes or deactivates anything (removing a type activation would strand existing documents), and it cannot create the installation's single base scope — the bootstrap owns that.
3. Staffing comes before policies — and this order is not optional¶
This is the one sequencing constraint worth understanding, even though the wizard now handles it for you.
Creating and configuring the installation-level facts (organization, project, activations, element declarations) is gated on a permission held installation-wide. Configuring a project's review policies is gated inside that project — and a project that was born ten seconds ago has nobody in it, including you. So the first policy write into a newborn project is refused until somebody is staffed there.
The consequence, verified end to end (2026-07-27, driven as carla.fischer): she created the organization
and the project, activated SOP and REC, activated Document Author, Quality Reviewer and Quality Manager,
and declared the lane's special elements — all accepted — and then her first review-policy write into the new project was
refused, because she held no configuration permission there yet. Staffing herself unblocked it; the
setup check then named the one role still empty (Quality Reviewer has no active holder), she staffed
anna.sommer, added a folder, and the check read complete, no findings.
The bridge: "Staff yourself now"¶
You do not have to hit that wall. The configuration step carries a Staff yourself now section in its Roles block: a checkbox per role the run is activating, ticked for the roles you will actually work in. The section states the reason itself — "Activating a role staffs nobody, so a brand-new project leaves even its creator holding nothing in it. Assign yourself the roles you will actually work in and the project's own configuration steps — review policies, folders, acknowledgement policies — are performed in this same run instead of being handed off."
This is the normal path for a birth run. Ticking the boxes adds a Staff yourself —
The section only appears where you can actually staff yourself — your user administration must reach into the new project (held installation-wide, or on the organization the project belongs to). Where a per-project step is blocked for exactly this reason, the wizard says so and points at the checkbox rather than making you work it out: "You are not staffed in this new project yet — that is the cause. Tick 'Staff yourself now' in the Roles section above and this step is planned and performed in the same run."
Without that reach, the fallback is the sequence above: create the project, then staff yourself — or have someone staff you — on Admin → Users, then come back. The wizard names this case too: "You are not staffed in this new project yet — that is the cause. Staff yourself (Admin › Users) once the project exists, then this step unlocks." Nothing you entered is lost; the wizard writes nothing until Apply.
4. Without the installation permission: the hand-off¶
A caller who does not hold it sees the same wizard with the same steps — the provisioning panels of a run already under way simply keep their "Hand this to an administrator" rendering, naming exactly what is missing and who does it. Never a silent skip, never a disabled button with no explanation: the hand-off is the unauthorized rendering.
Read that sentence precisely: a hand-off is what a panel renders for the caller who does not hold the act. Where the act is yours, the same panel is the act — see §4b for the catalog case, which is the one a fresh installation meets first.
The one exception is the doorway. Step 1 is where you pick the project you came to set up, and for a caller who cannot create one, the "Set up a new project" entry is simply absent — with no band in its place. A hand-off belongs to somebody stopped inside a run at a step they cannot perform; on the way in it would greet a reader with a permission they may never need, in front of work that is entirely open to them. The projects you reach are listed and configurable exactly as before. Where a new project really has to exist, that is an installation administrator's act: ask, and come back once it does.
Each of the remaining panels says which permission is the cause, by name, and what happens next: - Founding an organization — a right of its own since the two processes split (MANAGE_MANDATORS). It is not a panel inside the wizard: the menu entry is simply absent for whoever does not hold it. The two rights can be held separately on purpose — an administrator may let a role set projects up inside existing organizations while withholding the power to create new ones. Where that is how the installation is configured, the project process works in full and the founding entry is not offered. The one place the process is still named to such a caller is the project form of an installation that carries no organization yet, because there it would otherwise be a dead end. - Type activation — "…Activating them needs installation-shaping rights (MANAGE_SCOPES), which you do not hold — an administrator activates them, then re-run this wizard to configure them." - Special elements — "Activating these special elements — and saying which document types may define them — needs installation-shaping rights (MANAGE_SCOPES), which you do not hold. An administrator activates them; the wizard reports a missing one as a setup gap in the last step." The lane's proposal is still shown, row by row with its prefix, so you can read the convention you cannot set — and the defining types control beside it stays live where you hold catalog activation in the project, because that is a different authority.
Note what those sentences do and do not say. The cause is always "you do not hold this permission" — never "this feature does not exist". And rather than leaving you to find the right person, the panel lists the roles that carry the permission in this installation: "Roles carrying MANAGE_SCOPES in this installation: …". That is who to ask.
4b. When the missing piece is the CATALOG — and you are the one who governs it¶
Activating a type or a role in a project presupposes that the installation's catalog carries it at all. On a fresh installation it carries almost nothing, so the lane's types and its three role slots are all missing at once — and creating catalog entries is a different permission from provisioning (catalog administration, the surface behind Admin → Document types and Admin → Roles).
The panel therefore follows the reader:
- You do not hold catalog administration — it stays a hand-off, and it distinguishes the two cases rather than lumping them: an empty catalog ("This installation's document-type catalog is empty — it carries no document type at all yet") is a different fact from a partial mismatch ("This installation's document-type catalog has no type for 1 of this lane's prefixes."). The missing entries are listed compactly underneath, and a long list collapses behind "Show the 8 types" — a lane meeting a fresh installation is not a wall of prefixes.
- You do hold it — the panel becomes the act. "Create the 8 missing document type(s) now" creates them, and the roles panel offers the same for the slots ("This installation's role catalog has no role named: … You hold the catalog administration that creates them."). The wizard then carries straight on: each created type appears as a configurable panel marked will be activated, each created role fills its slot and joins the activation list. No second trip, no re-run.
Two things the offer states before you press it, because both outlive this wizard run:
- it is catalog administration, not a project act — "each type is created once for the WHOLE installation and recorded in the audit trail, exactly as on Admin › Document types". Name, prefix and category come from the lane; one type's periodic-review interval is a separate catalog default and stays a hand-off (see the band below it, headlined "Catalog administration — yours to do" for you);
- a created role carries the house permission set for its part in the work, and the note lists it token
by token — "Created in the installation's role catalog, each with the house permission set for its part
in the work:", then one line per role. Those sets are the same ones the demo stack's roles hold, so a
wizard-created project and a seeded one behave alike. Note the deliberate asymmetry inside them:
Document Author does not carry
ORGANIZE_DOCUMENTS— filing is a document-control act, so the Quality Reviewer and the Quality Manager carry it and the Author does not. That is what decides whether the folder skeleton below can be created in this run, and the staffing bridge names the carriers when it cannot. The permission sets are installation-wide and stay editable on Admin → Roles; where a mapping call is refused after the role was created, the note says that role received no permissions rather than repeating a set the installation never got.
This is also the path a brand-new installation's administrator walks: they hold their permissions through their assignment at the global scope and may read no project's content at all, so the project picker on step 1 is honestly empty and "I need a new project" is the way in — while every step that follows works, because the wizard asks the same question the server does (ADR-0106).
5. Everything is attributed¶
Every act writes an audit event — organization created, project created, type activated, role activated, element kind declared (one event per kind, and a prerequisite pulled in with it names what pulled it) — recording the actor by name, with before/after values. The project's own trail then carries its staffing, policy and folder acts. A refusal writes nothing: a denied attempt is not an act.
One entry deserves reading twice: role activation records staffing: unchanged in the event body.
Activating a role makes it bindable and assignable in the project; it staffs nobody. The setup
check will keep reporting the role as unstaffed until a person is actually assigned.
6. Dissolving an organization founded by mistake¶
There is exactly one destructive act on this whole surface, and it exists for one situation: an organization that was founded and should not have been. It lives on Administration → Scopes, at the organization's own heading in the directory.
It is offered only while the organization is provably empty — no project, no member, no configuration, no content, and no audit entry of its own. The check is not a list somebody keeps current: the server derives it from the database's own structure and counts on the true state, not on what the person asking can see. Where anything at all is in the way, the refusal names it in words — the projects by name, everything else as a counted noun ("…it still has 1 membership record") — and the organization stays.
That rule has a sharp edge and it is deliberate: the organization's own audit trail counts as content. An organization that has ever recorded anything stays permanent, because dissolving it would destroy a trail. A freshly founded one can go only because its own birth entries are recorded at the installation level and survive it — which is what makes the honest pair possible: organization created … organization dissolved, both in the installation's trail, naming the same organization, neither pretending it never happened.
The directory also states the dead end while it lasts: an organization with no project and nobody in it is marked as such at its heading, with the three ways out — found its first project, invite its first member, or dissolve it if it was a mistake. A founded-and-forgotten organization is never left sitting invisible.
(The tutorial's Part 0 — "Register a new project" walks this path hands-on, once, on the demo stack: the new-project form, the lane, "Staff yourself now", Apply & verify and the setup check. This topic is the reference behind it — the act sequence, the refusals, and what happens when you hold fewer rights.)
Governing decisions: ADR-0097 (the governed provisioning surface — every act audited), ADR-0109 (founding an organization is its own process, with its own right, its own workflow and its narrow undo), ADR-0002 (the scope hierarchy and the capability flags), ADR-0010 (the operating organization's own internal record), ADR-0004 (global catalogs with per-scope activation — why activation and staffing are different acts), ADR-0096 (the policy model the newborn project is configured into), ADR-0112 (the element-kind catalog a project declares from) and ADR-0095 (the freeze that governs those declarations at birth), ADR-0106 (the reflection every permission question on this surface is asked over — why a fresh installation's administrator sees the wizard work).