What “Contracts” are for

Contracts help you send a clear, professional agreement to your client and collect a legally meaningful confirmation.

Use Contracts to:

Define the scope of work and expectations (deliverables, timelines, terms)
Reduce misunderstandings and protect both sides
Share a link the client can read from any device
Collect required information and a signature when needed
Track the full lifecycle: drafted → sent → signed (or declined)

Contracts are typically linked to a Project (and optionally a Client), so everything stays organized.

1) Contracts list (overview)

The Contracts list shows all your contracts with:

Title
Status (Draft / Sent / Signed / Declined)
Sent date and Signed date (when applicable)

Archived Contracts

You can archive old contracts to keep the main list clean.
Archived contracts can be opened and unarchived.

2) Contract statuses (Draft → Sent → Signed / Declined)

Draft

You are still preparing the contract.
The contract is editable.

Sent

The contract is ready for the client.
A public/portal link can be shared.
You can send it by email or copy the link.

Signed

The client has completed the required fields and signed.
Important: signed contracts are locked (not editable and not deletable), to preserve integrity.

Declined

The client declined the contract.
You still keep the record for history.

3) Editing a Contract (what you can do)

Contract content (rich text)

You write the contract body using a rich editor (so you can format text properly).

Variables (smart placeholders)

Contracts support variables like:

Client info (name, email, phone)
Project info (name, dates, location, type)
Brand/user info (brand name, address, email, VAT, user name)
Custom fields (client and project custom fields)

This means you can write a template once and reuse it while still having the right details automatically filled in.

4) Fillable fields inside the Contract (interactive signing)

A contract can contain fillable fields, such as:

Text fields (e.g. “Full name”)
Checkbox fields (e.g. “I accept the terms”)
Date fields
Signature fields (signature pad)

Required fields

Some fields can be marked as required.
The client can sign only once all required fields are completed.

“Filled by client” vs “filled by you”

Some fields can be configured to be filled by the client, or filled by you (useful when you want to lock certain details and only ask the client for confirmation/signature).

5) Sending a Contract (email + copy link)

Send by email

You can send a contract via email directly from the editor.

The system can suggest a default recipient based on the linked client.
Sending marks the contract as Sent and saves the sent timestamp.
When a contract is sent, the system can also trigger a client notification (“Contract ready”).

Copy link

You can also copy the contract link and send it via WhatsApp/DM/etc.

If the contract is still Draft, copying the link can also mark it as Sent (so it behaves like a real shared contract).

6) Client portal view (client experience)

Clients open the contract through a portal link where they can:

Read the contract
Fill required fields
Add signature (if required)
Submit/sign

Once signed:

The contract becomes read‑only
The signature and filled data remain visible as a record

7) Printable / PDF

Contracts have a printable view for:

Printing
Saving as PDF using the browser print dialog

This is useful for:

Client copies
Internal archiving
Sharing offline

8) Contract Templates (Settings) — reuse your contract structure

You can create and manage Contract Templates from:

Settings → Contract Templates

Templates are the recommended way to work if you reuse similar contracts (weddings, commercial shoots, portrait sessions, etc.).

What templates include

A template can include:

The full contract body (formatted)
Variables/placeholders (client/project/brand)
Fillable fields (checkboxes, signature, etc.)
Field rules (required, who fills it)

System templates vs your templates

Some templates may be system templates (read‑only).
You can duplicate a system template to create your own editable version.
You can create your own templates from scratch and save them.

Why templates matter

Templates help you:

Save time
Stay consistent
Reduce mistakes
Improve the client experience (same structure every time)

Best practices (simple + effective)

Keep contracts readable: short sections, clear headings, minimal legal jargon.
Always include at least one required confirmation field (checkbox and/or signature).
Use variables instead of retyping details (client name, project name, dates).
Don’t edit after signing: if you need changes, create a new contract version and send again.
Archive old contracts to keep the active list clean.