diff --git a/app/Domains/Metadata/Concerns/HasCustomFields.php b/app/Domains/Metadata/Concerns/HasCustomFields.php
new file mode 100644
index 00000000..a3b89bd2
--- /dev/null
+++ b/app/Domains/Metadata/Concerns/HasCustomFields.php
@@ -0,0 +1,72 @@
+<?php
+
+namespace App\Domains\Metadata\Concerns;
+
+use App\Domains\Metadata\Models\CustomFieldValue;
+use Illuminate\Database\Eloquent\Relations\MorphMany;
+
+/**
+ * Gives a record the custom-field answers held against it.
+ *
+ * Mixed into every type that can carry them -- customers, documents, the
+ * lines on a document, payments, expenses, users. Answers are reachable
+ * either as a relation or one at a time by the slug a template names them
+ * with, and they are cleared when the record they hang off is deleted.
+ *
+ * That clean-up is registered from `booted()` rather than from the per-trait
+ * boot method the framework calls, which means a model declaring its own
+ * `booted()` replaces this one and quietly keeps its answers after deletion.
+ * Payments are in exactly that position today.
+ */
+trait HasCustomFields
+{
+    /**
+     * The answers recorded against this record.
+     */
+    public function fields(): MorphMany
+    {
+        return $this->morphMany(
+            CustomFieldValue::class,
+            'custom_field_valuable',
+        );
+    }
+
+    /**
+     * Drop the answers when the record that owns them goes.
+     *
+     * The existence check spares the delete statement when there is nothing
+     * to remove, at the price of a query that asks first.
+     */
+    protected static function booted()
+    {
+        static::deleting(function ($record) {
+            if ($record->fields()->exists()) {
+                $record->fields()->delete();
+            }
+        });
+    }
+
+    /**
+     * The answer this record holds for the field with the given slug, with
+     * the definition already loaded alongside it.
+     *
+     * Null when this record never answered that field -- and equally when no
+     * field carries the slug at all.
+     */
+    public function getCustomFieldBySlug($slug)
+    {
+        return $this->fields()
+            ->with('customField')
+            ->whereHas('customField', fn ($definition) => $definition->where('slug', $slug))
+            ->first();
+    }
+
+    /**
+     * The answer itself, read from the column its type maps to. This is what
+     * a document placeholder naming the slug resolves to.
+     */
+    public function getCustomFieldValueBySlug($slug)
+    {
+        return $this->getCustomFieldBySlug($slug)?->defaultAnswer;
+    }
+}
diff --git a/app/Domains/Metadata/Http/Controllers/CustomFieldsController.php b/app/Domains/Metadata/Http/Controllers/CustomFieldsController.php
new file mode 100644
index 00000000..4b02ed28
--- /dev/null
+++ b/app/Domains/Metadata/Http/Controllers/CustomFieldsController.php
@@ -0,0 +1,119 @@
+<?php
+
+namespace App\Domains\Metadata\Http\Controllers;
+
+use App\Domains\Metadata\Application\CustomFieldService;
+use App\Domains\Metadata\Http\Requests\CustomFieldRequest;
+use App\Domains\Metadata\Http\Resources\CustomFieldResource;
+use App\Domains\Metadata\Models\CustomField;
+use App\Platform\Http\Controller;
+use Illuminate\Http\Request;
+
+/**
+ * The definitions behind the extra questions a company asks on its records.
+ *
+ * A definition carries its own default answer, which arrives beside the
+ * validated attributes rather than among them: the form request never lists
+ * `default_answer`, because the column it belongs in follows from the field's
+ * input type and is settled by the service.
+ */
+class CustomFieldsController extends Controller
+{
+    public function __construct(
+        private readonly CustomFieldService $customFieldService,
+    ) {}
+
+    /**
+     * A page of the company's definitions, newest first.
+     *
+     * The raw input goes to the filter scope untouched, so `type` (matched
+     * against the model the field is attached to) and `search` are both read
+     * there. A `limit` of "all" makes the pagination scope hand back the whole
+     * collection instead of a paginator; with no `limit` a page holds five.
+     */
+    public function index(Request $request)
+    {
+        $this->authorize('viewAny', CustomField::class);
+
+        $perPage = $request->has('limit') ? $request->limit : 5;
+
+        $definitions = CustomField::applyFilters($request->all())
+            ->whereCompany()
+            ->latest()
+            ->paginateData($perPage);
+
+        return CustomFieldResource::collection($definitions);
+    }
+
+    /**
+     * Define a new field. The company comes from the request header rather
+     * than the body, and the slug is minted once, here, from the model type
+     * and the name.
+     */
+    public function store(CustomFieldRequest $request)
+    {
+        $this->authorize('create', CustomField::class);
+
+        $companyId = (int) $request->header('company');
+
+        $customField = $this->customFieldService->create(
+            $request->validated(),
+            $request->input('default_answer'),
+            $companyId,
+        );
+
+        return new CustomFieldResource($customField);
+    }
+
+    public function show(CustomField $customField)
+    {
+        $this->authorize('view', $customField);
+
+        return new CustomFieldResource($customField);
+    }
+
+    /**
+     * Rewrite a definition in place. The slug is not among the attributes the
+     * service touches, so a renamed field answers to the name it was born
+     * with — which is what keeps existing formatting placeholders working.
+     */
+    public function update(CustomFieldRequest $request, CustomField $customField)
+    {
+        $this->authorize('update', $customField);
+
+        $this->customFieldService->update(
+            $customField,
+            $request->validated(),
+            $request->input('default_answer'),
+        );
+
+        return new CustomFieldResource($customField);
+    }
+
+    /**
+     * Delete a definition together with every answer ever recorded against it.
+     *
+     * The payload publishes `in_use`, but this endpoint never consults it:
+     * stored answers are swept first, the definition goes second, and there is
+     * no guard and nothing to confirm. Warning the operator is left to the
+     * interface. The probe in front of the sweep is redundant — an
+     * unconditional delete would remove the same rows — and is kept so the
+     * query trace stays what callers have always seen.
+     */
+    public function destroy(CustomField $customField)
+    {
+        $this->authorize('delete', $customField);
+
+        $answers = $customField->customFieldValues();
+
+        if ($answers->exists()) {
+            $answers->delete();
+        }
+
+        $customField->forceDelete();
+
+        return response()->json([
+            'success' => true,
+        ]);
+    }
+}
diff --git a/app/Domains/Metadata/Http/Controllers/NotesController.php b/app/Domains/Metadata/Http/Controllers/NotesController.php
new file mode 100644
index 00000000..609c1897
--- /dev/null
+++ b/app/Domains/Metadata/Http/Controllers/NotesController.php
@@ -0,0 +1,114 @@
+<?php
+
+namespace App\Domains\Metadata\Http\Controllers;
+
+use App\Domains\Metadata\Http\Requests\NotesRequest;
+use App\Domains\Metadata\Http\Resources\NoteResource;
+use App\Domains\Metadata\Models\Note;
+use App\Platform\Http\Controller;
+use Illuminate\Http\Request;
+
+/**
+ * The company's library of reusable note templates.
+ *
+ * Reading answers to one ability and writing to another, which is why the
+ * gates below are named rather than resolved from the model: a member may be
+ * allowed to pick a note for a document without being allowed to edit the
+ * library it came from.
+ */
+class NotesController extends Controller
+{
+    /**
+     * A page of the company's notes, newest first, ten to a page unless the
+     * caller asks for a different size. The `type` and `search` narrowings are
+     * read off the raw input by the filter scope.
+     */
+    public function index(Request $request)
+    {
+        $this->authorize('view notes');
+
+        $perPage = $request->limit ?? 10;
+
+        $notes = Note::latest()
+            ->whereCompany()
+            ->applyFilters($request->all())
+            ->paginate($perPage);
+
+        return NoteResource::collection($notes);
+    }
+
+    /**
+     * Add a note to the library. The 201 comes from the resource itself, which
+     * notices it is wrapping a model that was only just created.
+     */
+    public function store(NotesRequest $request)
+    {
+        $this->authorize('manage notes');
+
+        $note = Note::create($request->getNotesPayload());
+
+        $this->demoteRivalDefaults($note);
+
+        return new NoteResource($note);
+    }
+
+    public function show(Note $note)
+    {
+        $this->authorize('view notes', $note);
+
+        return new NoteResource($note);
+    }
+
+    /**
+     * Edit a note. The demotion sweep runs on the saved state, so switching a
+     * note's type and its default flag in one request promotes it inside the
+     * type it has just moved to.
+     */
+    public function update(NotesRequest $request, Note $note)
+    {
+        $this->authorize('manage notes', $note);
+
+        $note->update($request->getNotesPayload());
+
+        $this->demoteRivalDefaults($note);
+
+        return new NoteResource($note);
+    }
+
+    /**
+     * Drop a note from the library. Nothing looks for references first —
+     * whether a document still names this note is not this endpoint's concern.
+     */
+    public function destroy(Note $note)
+    {
+        $this->authorize('manage notes', $note);
+
+        $note->delete();
+
+        return response()->json([
+            'success' => true,
+        ]);
+    }
+
+    /**
+     * A type can only have one default, so promoting one note clears the flag
+     * on the rest.
+     *
+     * KNOWN DEFECT, reproduced on purpose: "the rest" is narrowed by type and
+     * by "not this row" and by nothing else — no company narrowing — so saving
+     * a default note here also clears the default flag on other tenants' notes
+     * of the same type. The correction is scheduled to reach every install at
+     * once and is deliberately not made here.
+     */
+    private function demoteRivalDefaults(Note $note): void
+    {
+        if (! $note->is_default) {
+            return;
+        }
+
+        Note::where('id', '!=', $note->id)
+            ->where('type', $note->type)
+            ->where('is_default', true)
+            ->update(['is_default' => false]);
+    }
+}
diff --git a/app/Domains/Metadata/Http/Requests/CustomFieldRequest.php b/app/Domains/Metadata/Http/Requests/CustomFieldRequest.php
new file mode 100644
index 00000000..4fce300e
--- /dev/null
+++ b/app/Domains/Metadata/Http/Requests/CustomFieldRequest.php
@@ -0,0 +1,42 @@
+<?php
+
+namespace App\Domains\Metadata\Http\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+
+/**
+ * A custom-field definition as the admin screen submits it.
+ *
+ * Two absences are deliberate. `model_type` is checked for presence only, so
+ * any string at all reaches the column — the handful of model names the UI
+ * offers is a convention, not a constraint. And the default answer never
+ * appears below: which value column it belongs in follows from `type`, so the
+ * controller reads it off the request untouched and lets the service place it.
+ */
+class CustomFieldRequest extends FormRequest
+{
+    /**
+     * Every caller is welcome here; the controller is what consults the policy.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * @return array<string, array<int, string>>
+     */
+    public function rules(): array
+    {
+        return [
+            'name' => ['required'],
+            'label' => ['required'],
+            'model_type' => ['required'],
+            'order' => ['required'],
+            'type' => ['required'],
+            'is_required' => ['required', 'boolean'],
+            'options' => ['array'],
+            'placeholder' => ['string', 'nullable'],
+        ];
+    }
+}
diff --git a/app/Domains/Metadata/Http/Requests/NotesRequest.php b/app/Domains/Metadata/Http/Requests/NotesRequest.php
new file mode 100644
index 00000000..10d2ac9f
--- /dev/null
+++ b/app/Domains/Metadata/Http/Requests/NotesRequest.php
@@ -0,0 +1,62 @@
+<?php
+
+namespace App\Domains\Metadata\Http\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Validation\Rule;
+
+/**
+ * A reusable note template on its way in.
+ *
+ * A name only has to be free inside its own company and its own document
+ * type, so the uniqueness lookup carries both narrowings. Editing excludes the
+ * row being edited from that lookup — but only under PUT: a PATCH builds the
+ * plain rule and so collides with the note's own name.
+ */
+class NotesRequest extends FormRequest
+{
+    /**
+     * Every caller is welcome here; the controller is what consults the gate.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * @return array<string, array<int, mixed>>
+     */
+    public function rules(): array
+    {
+        $company = $this->header('company');
+
+        $nameIsFree = $this->isMethod('PUT')
+            ? Rule::unique('notes')
+                ->ignore($this->route('note')->id)
+                ->where('type', $this->type)
+                ->where('company_id', $company)
+            : Rule::unique('notes')
+                ->where('company_id', $company)
+                ->where('type', $this->type);
+
+        return [
+            'type' => ['required'],
+            'name' => ['required', $nameIsFree],
+            'notes' => ['required'],
+            'is_default' => ['required'],
+        ];
+    }
+
+    /**
+     * The validated attributes, stamped with the company from the request
+     * header. A `company_id` sent by the client is not among them — it is not
+     * a validated key, so it never survives this far.
+     */
+    public function getNotesPayload()
+    {
+        $attributes = $this->validated();
+        $attributes['company_id'] = $this->header('company');
+
+        return $attributes;
+    }
+}
diff --git a/app/Domains/Metadata/Http/Resources/CustomFieldResource.php b/app/Domains/Metadata/Http/Resources/CustomFieldResource.php
new file mode 100644
index 00000000..2eff2864
--- /dev/null
+++ b/app/Domains/Metadata/Http/Resources/CustomFieldResource.php
@@ -0,0 +1,72 @@
+<?php
+
+namespace App\Domains\Metadata\Http\Resources;
+
+use App\Domains\Accounts\Http\Resources\CompanyResource;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+/**
+ * A custom-field definition as the admin API publishes it.
+ *
+ * The definition describes an extra input an operator fills in: what it is
+ * called, which record family it hangs off, where it sits in the form, which
+ * widget renders it, whether an answer is mandatory, and the choices a
+ * dropdown offers. Its slug is the handle the document-formatting engine
+ * matches on -- minted once at creation and never reissued, so it outlives a
+ * rename and existing templates keep resolving.
+ *
+ * Every typed answer column is published side by side, and only one of them
+ * is ever populated: the one the declared input type maps to. `default_answer`
+ * is that column read back through the mapping, so a consumer wanting the
+ * prefilled answer takes the single derived key instead of guessing which
+ * column to look in.
+ *
+ * Two keys are worked out at read time rather than stored. `in_use` asks the
+ * database whether any answer has ever been recorded against the definition,
+ * and the owning company is published only when its relation resolves, which
+ * is a second probe followed by a third read to fetch the row. All of that
+ * runs per serialised row, so a page of definitions pays for it once per row.
+ * That is the payload's established shape and is kept deliberately.
+ *
+ * Nothing here is gated on the caller: `in_use` is reported but carries no
+ * weight, and the delete path ignores it entirely.
+ */
+class CustomFieldResource extends JsonResource
+{
+    /**
+     * Transform the resource into an array.
+     *
+     * @param  Request  $request
+     */
+    public function toArray($request): array
+    {
+        $field = $this->resource;
+
+        return [
+            'id' => $field->id,
+            'name' => $field->name,
+            'slug' => $field->slug,
+            'label' => $field->label,
+            'model_type' => $field->model_type,
+            'type' => $field->type,
+            'placeholder' => $field->placeholder,
+            'options' => $field->options,
+            'boolean_answer' => $field->boolean_answer,
+            'date_answer' => $field->date_answer,
+            'time_answer' => $field->time_answer,
+            'string_answer' => $field->string_answer,
+            'number_answer' => $field->number_answer,
+            'date_time_answer' => $field->date_time_answer,
+            'is_required' => $field->is_required,
+            'in_use' => $field->in_use,
+            'order' => $field->order,
+            'company_id' => $field->company_id,
+            'default_answer' => $field->default_answer,
+            'company' => $this->when(
+                $field->company()->exists(),
+                fn () => new CompanyResource($field->company)
+            ),
+        ];
+    }
+}
diff --git a/app/Domains/Metadata/Http/Resources/CustomFieldValueResource.php b/app/Domains/Metadata/Http/Resources/CustomFieldValueResource.php
new file mode 100644
index 00000000..8e82ecdf
--- /dev/null
+++ b/app/Domains/Metadata/Http/Resources/CustomFieldValueResource.php
@@ -0,0 +1,106 @@
+<?php
+
+namespace App\Domains\Metadata\Http\Resources;
+
+use App\Domains\Accounts\Http\Resources\CompanyResource;
+use App\Domains\Accounts\Models\CompanySetting;
+use App\Platform\Persistence\ModelIdentityMap;
+use Carbon\Carbon;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+/**
+ * One recorded answer to a custom field, as the admin API publishes it.
+ *
+ * A row here belongs to whatever it was filled in against -- a customer, a
+ * document, one line of a document, a payment, an expense. The owner is
+ * reported as a pair: the record's id, and a discriminator translated out of
+ * the stable database identity into the long class name the v1 API has always
+ * published, so consumers written against that shape keep working.
+ *
+ * As on the definition, every typed answer column travels and only the one
+ * the field's type maps to holds anything; `default_answer` is that column
+ * read back through the mapping. `default_formatted_answer` is the same datum
+ * rendered for a human -- see the method below for the three ways that goes.
+ *
+ * Both associations are gated on an existence probe run against the database,
+ * so they are correct whether or not anything was eager loaded, at the price
+ * of a query apiece per serialised row plus a second to fetch the record once
+ * the probe says there is one. Eager loading does not spare the probe. This is
+ * the payload's established shape and is kept deliberately.
+ */
+class CustomFieldValueResource extends JsonResource
+{
+    /**
+     * Transform the resource into an array.
+     *
+     * @param  Request  $request
+     */
+    public function toArray($request): array
+    {
+        $value = $this->resource;
+
+        return [
+            'id' => $value->id,
+            'custom_field_valuable_type' => ModelIdentityMap::publicType($value->custom_field_valuable_type),
+            'custom_field_valuable_id' => $value->custom_field_valuable_id,
+            'type' => $value->type,
+            'boolean_answer' => $value->boolean_answer,
+            'date_answer' => $value->date_answer,
+            'time_answer' => $value->time_answer,
+            'string_answer' => $value->string_answer,
+            'number_answer' => $value->number_answer,
+            'date_time_answer' => $value->date_time_answer,
+            'custom_field_id' => $value->custom_field_id,
+            'company_id' => $value->company_id,
+            'default_answer' => $value->defaultAnswer,
+            'default_formatted_answer' => $this->dateTimeFormat(),
+            'custom_field' => $this->when(
+                $value->customField()->exists(),
+                fn () => new CustomFieldResource($value->customField)
+            ),
+            'company' => $this->when(
+                $value->company()->exists(),
+                fn () => new CompanyResource($value->company)
+            ),
+        ];
+    }
+
+    /**
+     * The stored answer rendered the way a reader should see it.
+     *
+     * The field's type decides the treatment. A moment in time is fixed to a
+     * minute in an ISO-looking layout that ignores the company's preferences
+     * entirely; a plain date goes through the owning company's configured date
+     * format; everything else -- text, numbers, switches, times, and any type
+     * the mapping does not recognise -- is handed back exactly as stored.
+     *
+     * An answer that reads as empty short-circuits to null before any of that,
+     * which sweeps up more than blanks: a switch turned off and a numeric zero
+     * are both falsy, so neither ever reaches this key. Two rough edges are
+     * preserved as they are. The column the type maps to is resolved before
+     * the emptiness check, so a row carrying no type at all fails here rather
+     * than returning null; and a company with no date format on file hands a
+     * null format down to the formatter, which rejects it -- a dated answer
+     * belonging to such a company cannot be serialised at all.
+     */
+    public function dateTimeFormat()
+    {
+        $value = $this->resource;
+
+        $column = getCustomFieldValueKey($value->type);
+        $answer = $value->default_answer;
+
+        if (! $answer) {
+            return null;
+        }
+
+        return match ($column) {
+            'date_time_answer' => Carbon::parse($answer)->format('Y-m-d H:i'),
+            'date_answer' => Carbon::parse($answer)->format(
+                CompanySetting::getSetting('carbon_date_format', $value->company_id)
+            ),
+            default => $answer,
+        };
+    }
+}
diff --git a/app/Domains/Metadata/Http/Resources/CustomerPortal/CustomFieldResource.php b/app/Domains/Metadata/Http/Resources/CustomerPortal/CustomFieldResource.php
new file mode 100644
index 00000000..4f3bfaa9
--- /dev/null
+++ b/app/Domains/Metadata/Http/Resources/CustomerPortal/CustomFieldResource.php
@@ -0,0 +1,64 @@
+<?php
+
+namespace App\Domains\Metadata\Http\Resources\CustomerPortal;
+
+use App\Domains\Accounts\Http\Resources\CustomerPortal\CompanyResource;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+/**
+ * A custom-field definition as the customer portal publishes it.
+ *
+ * Key for key this is the administrative payload: the naming, the record
+ * family the field hangs off, the widget, the ordering, whether an answer is
+ * mandatory, the dropdown choices, the frozen slug the formatting engine
+ * matches on, every typed answer column, and the prefilled answer resolved out
+ * of whichever column the type maps to. What differs is the company nested
+ * underneath, which is the portal's narrower view of the business rather than
+ * the administrative one.
+ *
+ * The read-time costs come across unchanged too: `in_use` asks the database
+ * whether any answer exists against the definition, and the nested company
+ * costs a probe plus a read. Both run per serialised row. The shape is the
+ * established contract and is kept as it is -- including the fact that a
+ * portal consumer is told how the field is configured internally, `in_use`
+ * and the administrative defaults included.
+ */
+class CustomFieldResource extends JsonResource
+{
+    /**
+     * Transform the resource into an array.
+     *
+     * @param  Request  $request
+     */
+    public function toArray($request): array
+    {
+        $field = $this->resource;
+
+        return [
+            'id' => $field->id,
+            'name' => $field->name,
+            'slug' => $field->slug,
+            'label' => $field->label,
+            'model_type' => $field->model_type,
+            'type' => $field->type,
+            'placeholder' => $field->placeholder,
+            'options' => $field->options,
+            'boolean_answer' => $field->boolean_answer,
+            'date_answer' => $field->date_answer,
+            'time_answer' => $field->time_answer,
+            'string_answer' => $field->string_answer,
+            'number_answer' => $field->number_answer,
+            'date_time_answer' => $field->date_time_answer,
+            'is_required' => $field->is_required,
+            'in_use' => $field->in_use,
+            'order' => $field->order,
+            'company_id' => $field->company_id,
+            'default_answer' => $field->default_answer,
+            'company' => $this->when(
+                $field->company()->exists(),
+                fn () => new CompanyResource($field->company)
+            ),
+        ];
+    }
+}
diff --git a/app/Domains/Metadata/Http/Resources/CustomerPortal/CustomFieldValueResource.php b/app/Domains/Metadata/Http/Resources/CustomerPortal/CustomFieldValueResource.php
new file mode 100644
index 00000000..af749777
--- /dev/null
+++ b/app/Domains/Metadata/Http/Resources/CustomerPortal/CustomFieldValueResource.php
@@ -0,0 +1,66 @@
+<?php
+
+namespace App\Domains\Metadata\Http\Resources\CustomerPortal;
+
+use App\Domains\Accounts\Http\Resources\CustomerPortal\CompanyResource;
+use App\Platform\Persistence\ModelIdentityMap;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+/**
+ * One recorded answer to a custom field, as the customer portal publishes it.
+ *
+ * The owner is reported as an id plus a discriminator translated out of the
+ * stable database identity into the long class name the v1 API has always
+ * published. Every typed answer column travels, and `default_answer` is
+ * whichever of them the field's type maps to, read back through that mapping.
+ *
+ * One key from the administrative payload is absent here: the human-rendered
+ * form of the answer. The portal receives the raw stored value and formats it
+ * itself, which also means it is spared the administrative payload's habit of
+ * failing outright on a dated answer whose company has no date format on file.
+ *
+ * The definition and the company are each gated on an existence probe against
+ * the database, so both are correct whether or not anything was eager loaded
+ * and cost a query apiece per serialised row, plus a second to fetch the
+ * record once the probe says there is one. The nested definition is the
+ * portal's own view of the field; the nested company is the portal's narrower
+ * view of the business. This is the payload's established shape and is kept
+ * deliberately.
+ */
+class CustomFieldValueResource extends JsonResource
+{
+    /**
+     * Transform the resource into an array.
+     *
+     * @param  Request  $request
+     */
+    public function toArray($request): array
+    {
+        $value = $this->resource;
+
+        return [
+            'id' => $value->id,
+            'custom_field_valuable_type' => ModelIdentityMap::publicType($value->custom_field_valuable_type),
+            'custom_field_valuable_id' => $value->custom_field_valuable_id,
+            'type' => $value->type,
+            'boolean_answer' => $value->boolean_answer,
+            'date_answer' => $value->date_answer,
+            'time_answer' => $value->time_answer,
+            'string_answer' => $value->string_answer,
+            'number_answer' => $value->number_answer,
+            'date_time_answer' => $value->date_time_answer,
+            'custom_field_id' => $value->custom_field_id,
+            'company_id' => $value->company_id,
+            'default_answer' => $value->defaultAnswer,
+            'custom_field' => $this->when(
+                $value->customField()->exists(),
+                fn () => new CustomFieldResource($value->customField)
+            ),
+            'company' => $this->when(
+                $value->company()->exists(),
+                fn () => new CompanyResource($value->company)
+            ),
+        ];
+    }
+}
diff --git a/app/Domains/Metadata/Http/Resources/NoteResource.php b/app/Domains/Metadata/Http/Resources/NoteResource.php
new file mode 100644
index 00000000..ab57efcf
--- /dev/null
+++ b/app/Domains/Metadata/Http/Resources/NoteResource.php
@@ -0,0 +1,47 @@
+<?php
+
+namespace App\Domains\Metadata\Http\Resources;
+
+use App\Domains\Accounts\Http\Resources\CompanyResource;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+/**
+ * A reusable note template as the admin API publishes it.
+ *
+ * Deliberately thin: which document family the template belongs to, the name
+ * an operator picks it out by, the body itself, and whether it is the one
+ * offered first for that family. The body travels exactly as stored, markup
+ * and all -- nothing is escaped or stripped on the way out, so a consumer
+ * that renders it as HTML renders whatever was saved.
+ *
+ * The owning company is published only when the relation resolves, which is
+ * asked of the database every time rather than read off whatever the caller
+ * eager loaded, and so costs a query per serialised row plus a second to fetch
+ * the row once the probe says there is one. That is the payload's established
+ * shape and is kept deliberately.
+ */
+class NoteResource extends JsonResource
+{
+    /**
+     * Transform the resource into an array.
+     *
+     * @param  Request  $request
+     */
+    public function toArray($request): array
+    {
+        $note = $this->resource;
+
+        return [
+            'id' => $note->id,
+            'type' => $note->type,
+            'name' => $note->name,
+            'notes' => $note->notes,
+            'is_default' => $note->is_default,
+            'company' => $this->when(
+                $note->company()->exists(),
+                fn () => new CompanyResource($note->company)
+            ),
+        ];
+    }
+}
diff --git a/app/Domains/Metadata/Models/CustomField.php b/app/Domains/Metadata/Models/CustomField.php
new file mode 100644
index 00000000..f9c15e1d
--- /dev/null
+++ b/app/Domains/Metadata/Models/CustomField.php
@@ -0,0 +1,199 @@
+<?php
+
+namespace App\Domains\Metadata\Models;
+
+use App\Domains\Accounts\Models\Company;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+
+/**
+ * An extra question a company attaches to one of its record types.
+ *
+ * The definition holds the question -- label, input type, option list,
+ * placeholder, position in the form, whether an answer is compulsory -- and
+ * the answer to fall back on when none is given. That fallback is kept in
+ * whichever of the six typed columns the input type maps to, exactly the way
+ * a record's own answer is, so a single mapping helper serves both.
+ *
+ * Two things are looser than they look. The record type is a free string:
+ * nothing checks it against the handful of types the interface offers. And
+ * the slug a template addresses the field by is stamped once, at creation,
+ * and never recomputed, so renaming a field leaves every placeholder that
+ * already names it working.
+ */
+class CustomField extends Model
+{
+    protected $table = 'custom_fields';
+
+    use HasFactory;
+
+    /**
+     * Everything but the key may be mass assigned.
+     *
+     * @var array
+     */
+    protected $guarded = [
+        'id',
+    ];
+
+    /**
+     * Inert. The framework stopped reading this property, so the two columns
+     * named here are handed out as the plain strings the driver returns, not
+     * as date objects. Kept because it is part of the class as published.
+     *
+     * @var array
+     */
+    protected $dates = [
+        'date_answer',
+        'date_time_answer',
+    ];
+
+    /**
+     * The fallback answer travels with every serialized definition, under the
+     * camel-cased name it is computed from.
+     *
+     * @var array
+     */
+    protected $appends = [
+        'defaultAnswer',
+    ];
+
+    /**
+     * @return array<string, string>
+     */
+    protected function casts(): array
+    {
+        return [
+            'options' => 'array',
+        ];
+    }
+
+    /**
+     * Reduce a time-of-day fallback to H:i:s.
+     *
+     * An empty value never reaches the attribute bag -- not even as null --
+     * so clearing the time on a definition that already has one silently
+     * leaves the old time in place. A value the parser cannot read becomes
+     * midnight rather than an error.
+     */
+    public function setTimeAnswerAttribute(mixed $value): void
+    {
+        if ($value) {
+            $this->attributes['time_answer'] = date('H:i:s', strtotime($value));
+        }
+    }
+
+    /**
+     * Encode the option list on the way in.
+     *
+     * A set mutator wins over the array cast, so this runs in its place and
+     * encodes whatever arrives: null is stored as the four characters "null",
+     * and a string that is already JSON is encoded a second time and reads
+     * back as a string rather than as the structure it spells.
+     */
+    public function setOptionsAttribute(mixed $value): void
+    {
+        $this->attributes['options'] = json_encode($value);
+    }
+
+    /**
+     * The fallback answer, read from the column this field's input type maps
+     * to. A type outside the mapping reads the string column.
+     */
+    public function getDefaultAnswerAttribute()
+    {
+        $answerColumn = getCustomFieldValueKey($this->type);
+
+        return $this->{$answerColumn};
+    }
+
+    /**
+     * Whether any record has an answer on file for this field.
+     *
+     * Serialized with the definition so the interface can warn before a
+     * delete; nothing on the delete path itself consults it.
+     */
+    public function getInUseAttribute()
+    {
+        return $this->customFieldValues()->exists();
+    }
+
+    /**
+     * The company the field was defined in.
+     */
+    public function company(): BelongsTo
+    {
+        return $this->belongsTo(Company::class, 'company_id');
+    }
+
+    /**
+     * Every answer recorded against this field, whatever record type holds it.
+     */
+    public function customFieldValues(): HasMany
+    {
+        return $this->hasMany(CustomFieldValue::class, 'custom_field_id');
+    }
+
+    /**
+     * Narrow to the company the current request is acting on.
+     *
+     * The company is read from the request header; the scope takes no
+     * argument and cannot be pointed at a different company.
+     */
+    public function scopeWhereCompany($query)
+    {
+        $company = request()->header('company');
+
+        return $query->where('custom_fields.company_id', $company);
+    }
+
+    /**
+     * Partial match on either name the field goes by, grouped so it stays one
+     * condition when it is combined with others.
+     */
+    public function scopeWhereSearch($query, $search)
+    {
+        $needle = '%'.$search.'%';
+
+        $query->where(function ($grouped) use ($needle) {
+            $grouped->where('label', 'LIKE', $needle)
+                ->orWhere('name', 'LIKE', $needle);
+        });
+    }
+
+    /**
+     * Fields attached to one record type.
+     */
+    public function scopeWhereType($query, $type)
+    {
+        $query->where('custom_fields.model_type', $type);
+    }
+
+    /**
+     * Apply the listing filters that carry a value. An empty string, a zero
+     * or a null counts as a filter that was not sent.
+     */
+    public function scopeApplyFilters($query, array $filters)
+    {
+        $wanted = collect($filters);
+
+        if ($type = $wanted->get('type')) {
+            $query->whereType($type);
+        }
+
+        if ($search = $wanted->get('search')) {
+            $query->whereSearch($search);
+        }
+    }
+
+    /**
+     * A page of the requested size, or the whole set for the sentinel limit
+     * "all".
+     */
+    public function scopePaginateData($query, $limit)
+    {
+        return $limit == 'all' ? $query->get() : $query->paginate($limit);
+    }
+}
diff --git a/app/Domains/Metadata/Models/CustomFieldValue.php b/app/Domains/Metadata/Models/CustomFieldValue.php
new file mode 100644
index 00000000..34b49bb2
--- /dev/null
+++ b/app/Domains/Metadata/Models/CustomFieldValue.php
@@ -0,0 +1,109 @@
+<?php
+
+namespace App\Domains\Metadata\Models;
+
+use App\Domains\Accounts\Models\Company;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\MorphTo;
+
+/**
+ * One record's answer to one custom field.
+ *
+ * The row names the definition it answers and the record that owns it -- a
+ * customer, a document, a line on a document, a payment, an expense -- and
+ * keeps the answer in the column the definition's input type maps to.
+ *
+ * The type name is copied onto the row rather than read from the definition,
+ * so an answer can be rendered without loading the definition, and so
+ * changing a definition's input type later leaves answers already on file
+ * reading the column they were written to.
+ */
+class CustomFieldValue extends Model
+{
+    protected $table = 'custom_field_values';
+
+    use HasFactory;
+
+    /**
+     * Everything but the key may be mass assigned.
+     *
+     * @var array
+     */
+    protected $guarded = [
+        'id',
+    ];
+
+    /**
+     * Inert. The framework stopped reading this property, so the two columns
+     * named here are handed out as the plain strings the driver returns, not
+     * as date objects. Kept because it is part of the class as published.
+     *
+     * @var array
+     */
+    protected $dates = [
+        'date_answer',
+        'date_time_answer',
+    ];
+
+    /**
+     * The answer travels with every serialized row, under the camel-cased
+     * name it is computed from.
+     *
+     * @var array
+     */
+    protected $appends = [
+        'defaultAnswer',
+    ];
+
+    /**
+     * Reduce a time-of-day answer to H:i:s.
+     *
+     * Unlike the definition's copy of this mutator, an empty value is written
+     * through as null instead of being dropped, so an answer here can be
+     * cleared. A value the parser cannot read becomes midnight.
+     */
+    public function setTimeAnswerAttribute(mixed $value): void
+    {
+        $this->attributes['time_answer'] = $value ? date('H:i:s', strtotime($value)) : null;
+    }
+
+    /**
+     * The answer, read from the column this row's type maps to. A type
+     * outside the mapping reads the string column.
+     *
+     * The name is inherited from the definition the row was stamped from:
+     * there is nothing "default" about an answer a record actually gave.
+     */
+    public function getDefaultAnswerAttribute()
+    {
+        $answerColumn = getCustomFieldValueKey($this->type);
+
+        return $this->{$answerColumn};
+    }
+
+    /**
+     * The company the answer was stamped with.
+     */
+    public function company(): BelongsTo
+    {
+        return $this->belongsTo(Company::class, 'company_id');
+    }
+
+    /**
+     * The definition this answers.
+     */
+    public function customField(): BelongsTo
+    {
+        return $this->belongsTo(CustomField::class, 'custom_field_id');
+    }
+
+    /**
+     * The record the answer belongs to, whatever type it is.
+     */
+    public function customFieldValuable(): MorphTo
+    {
+        return $this->morphTo();
+    }
+}
diff --git a/app/Domains/Metadata/Models/Note.php b/app/Domains/Metadata/Models/Note.php
new file mode 100644
index 00000000..860355d3
--- /dev/null
+++ b/app/Domains/Metadata/Models/Note.php
@@ -0,0 +1,72 @@
+<?php
+
+namespace App\Domains\Metadata\Models;
+
+use App\Domains\Accounts\Models\Company;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+
+/**
+ * A note template a company keeps for reuse, tied to one document family
+ * through `type` and optionally marked as that family's default.
+ *
+ * Nothing is cast: `is_default` leaves for the payload exactly as the driver
+ * handed it over, and the body is stored and served as written.
+ */
+class Note extends Model
+{
+    use HasFactory;
+
+    protected $table = 'notes';
+
+    protected $guarded = ['id'];
+
+    public function company(): BelongsTo
+    {
+        return $this->belongsTo(Company::class);
+    }
+
+    /**
+     * The two narrowings the notes screen offers. Each is taken for its truth
+     * value, so a filter of "0" cannot be told apart from one never sent.
+     *
+     * @param  array<string, mixed>  $filters
+     */
+    public function scopeApplyFilters(Builder $query, array $filters): void
+    {
+        $type = $filters['type'] ?? null;
+
+        if ($type) {
+            $query->whereType($type);
+        }
+
+        $search = $filters['search'] ?? null;
+
+        if ($search) {
+            $query->whereSearch($search);
+        }
+    }
+
+    public function scopeWhereSearch(Builder $query, string $search): void
+    {
+        $query->where('name', 'LIKE', "%{$search}%");
+    }
+
+    public function scopeWhereType(Builder $query, string $type): Builder
+    {
+        return $query->where('type', $type);
+    }
+
+    /**
+     * Restrict to the company the request is acting for. The column is
+     * table-qualified so the scope survives being hung off a joined query.
+     */
+    public function scopeWhereCompany(Builder $query): void
+    {
+        $company = request()->header('company');
+
+        $query->where('notes.company_id', $company);
+    }
+}
diff --git a/app/Domains/Metadata/Policies/CustomFieldPolicy.php b/app/Domains/Metadata/Policies/CustomFieldPolicy.php
new file mode 100644
index 00000000..4213efec
--- /dev/null
+++ b/app/Domains/Metadata/Policies/CustomFieldPolicy.php
@@ -0,0 +1,74 @@
+<?php
+
+namespace App\Domains\Metadata\Policies;
+
+use App\Domains\Accounts\Models\User;
+use App\Domains\Metadata\Models\CustomField;
+use Illuminate\Auth\Access\HandlesAuthorization;
+use Silber\Bouncer\BouncerFacade;
+
+/**
+ * Who may work with custom-field definitions.
+ *
+ * Every decision aimed at a definition has two halves: the Bouncer ability,
+ * and membership of the company that definition belongs to, so an ability
+ * held in one company never reaches another company's fields. The two
+ * class-level decisions -- listing and creating -- have no row to check
+ * membership against and rest on the ability alone.
+ *
+ * Bouncer answers for the user it currently has scoped, not for the $user
+ * handed in; that argument only feeds the membership half.
+ */
+class CustomFieldPolicy
+{
+    use HandlesAuthorization;
+
+    public function viewAny(User $user): bool
+    {
+        return BouncerFacade::can('view-custom-field', CustomField::class);
+    }
+
+    public function view(User $user, CustomField $customField): bool
+    {
+        return BouncerFacade::can('view-custom-field', $customField) && $this->sameCompany($user, $customField);
+    }
+
+    public function create(User $user): bool
+    {
+        return BouncerFacade::can('create-custom-field', CustomField::class);
+    }
+
+    public function update(User $user, CustomField $customField): bool
+    {
+        return BouncerFacade::can('edit-custom-field', $customField) && $this->sameCompany($user, $customField);
+    }
+
+    public function delete(User $user, CustomField $customField): bool
+    {
+        return $this->mayRemove($user, $customField);
+    }
+
+    /**
+     * Restoring and erasing are governed by the delete ability as well;
+     * definitions are not soft-deleted, so neither is reachable in practice.
+     */
+    public function restore(User $user, CustomField $customField): bool
+    {
+        return $this->mayRemove($user, $customField);
+    }
+
+    public function forceDelete(User $user, CustomField $customField): bool
+    {
+        return $this->mayRemove($user, $customField);
+    }
+
+    private function mayRemove(User $user, CustomField $customField): bool
+    {
+        return BouncerFacade::can('delete-custom-field', $customField) && $this->sameCompany($user, $customField);
+    }
+
+    private function sameCompany(User $user, CustomField $customField): bool
+    {
+        return $user->hasCompany($customField->company_id);
+    }
+}
diff --git a/app/Domains/Metadata/Policies/NotePolicy.php b/app/Domains/Metadata/Policies/NotePolicy.php
new file mode 100644
index 00000000..51d64b91
--- /dev/null
+++ b/app/Domains/Metadata/Policies/NotePolicy.php
@@ -0,0 +1,51 @@
+<?php
+
+namespace App\Domains\Metadata\Policies;
+
+use App\Domains\Accounts\Models\User;
+use App\Domains\Metadata\Models\Note;
+use Illuminate\Auth\Access\HandlesAuthorization;
+use Silber\Bouncer\BouncerFacade;
+
+/**
+ * Notes divide their permissions in two: reading the library answers to one
+ * ability, changing it to another. Handed an actual note, either check also
+ * becomes a tenancy check — holding the ability is not enough when the row
+ * belongs to a company the user is not a member of.
+ */
+class NotePolicy
+{
+    use HandlesAuthorization;
+
+    public function manageNotes(User $user, ?Note $note = null)
+    {
+        return $this->passes($user, $note, 'manage-all-notes');
+    }
+
+    public function viewNotes(User $user, ?Note $note = null)
+    {
+        return $this->passes($user, $note, 'view-all-notes');
+    }
+
+    /**
+     * Bouncer is asked about the note itself where there is one and about the
+     * class otherwise. Membership is only meaningful in the first case: a
+     * class-level question carries no company to test the user against.
+     *
+     * Note that the ability is resolved for whoever is logged in rather than
+     * for `$user`, which is what the facade does; only the membership half of
+     * the decision actually reads the argument.
+     */
+    private function passes(User $user, ?Note $note, string $ability): bool
+    {
+        if (! BouncerFacade::can($ability, $note ?? Note::class)) {
+            return false;
+        }
+
+        if ($note === null) {
+            return true;
+        }
+
+        return $user->hasCompany($note->company_id);
+    }
+}