Solutions / Agencies & studios
A client portal that runs the business
Every client gets their own walled space — files, status, deliverables — while retainers bill themselves and your project tools stay in sync.
The case for building it
Why build this instead of client-portal SaaS?
Portal SaaS is priced per seat and shaped for the average agency — which yours isn't. You end up renaming your delivery stages to match its labels, exporting to spreadsheets for the parts it can't model, and paying again every time the team grows. Kliv builds the portal around your studio instead: your stages, your language, your client experience, on your domain.
Your delivery process is the differentiator — brief, concepts, revision rounds, sign-off — so the portal should model it literally. Each client is an organization with its own people, projects, and files, walled off at the database. When you refine how you deliver, the portal follows in a sentence, not in a feature request to a vendor.
Anatomy of the system
What the portal actually knows
An agency portal has to separate two things that generic project tools blur together: how your team works internally, and what each client is allowed to see. A marketing director at one client can see their campaign calendar, brand files, invoices, and revision threads — and cannot discover another client's project by changing a URL or guessing an ID. Here is the shape of the system Kliv would build.
Clients
Each client is an organization — its users, projects, files, approvals, and billing history live inside that wall.
Projects
Carry your stages — brief, concepts, revision rounds, sign-off — with the files and threads that belong to each.
Deliverables
Source files, presentations, and finals — shared per client, private by default.
Approvals
Sign-off is a recorded state on the work, not a buried email thread.
Retainers & invoices
The commercial relationship — subscription status, invoices, purchase history — attached to the same client record.
Requests
A queue of incoming client asks, scoped to the client that raised them.
Who sees what
Rules the database enforces
- A client user can only read rows that belong to their organization — guessing a URL or an ID returns nothing.
- Files are private by default; sharing is per client, not per link.
- Billing details are visible to the client owner, not to every member of their team.
- When a retainer lapses, entitlements close the gated areas — no one has to remember to revoke access.
The result is not “a portal” as a generic category. It is your delivery model turned into software: clients, stages, files, approvals, payments, and permissions all describing the same relationship.
What Kliv assembles
A shopping list of platform pieces — each one built in, each one composing with the rest.
One portal, walled per client
Each client is an organization: their people see their projects and files, never another client's. Enforced at the database, not in your page logic.
Retainers on autopilot
Monthly retainers with proration and pause — and dunning chases the expired card so you don't have to.
Deliverables, shared safely
Per-client file sharing for briefs, assets, and finals — private by default.
Your team's tools, wired in
A new client request becomes a Trello card; a Slack ping goes out when they approve.
An assistant that knows the account
Clients ask “where's my project?” and the agent answers from their own data — scoped to their organization.
Ways to charge
Three ways an agency can charge
Agencies rarely sell one thing. The same client might start with a strategy sprint, move into a monthly retainer, then buy extra production capacity during a launch. The portal should understand those shapes directly instead of forcing every relationship into the same invoice template.
Monthly retainer
$6,000/month
The growth client on an ongoing engagement
A request queue, monthly reporting, a shared file vault, and two strategy calls.
- Unlocks
- The active subscription opens the parts of the portal that belong to the relationship: open requests, active deliverables, reporting, and approved assets.
- Billing
- Renews monthly with fair proration on changes. If the card fails, recovery emails go out and access can narrow until billing is fixed.
- Refunds
- Refund requests route through an approval step before money moves.
Fixed-scope project
$18,000 one-time
The brand-refresh client with a defined scope
A project timeline, source-file uploads, concept presentations, revision rounds, and final delivery.
- Unlocks
- The purchase opens that project's space — the client sees the work tied to their scope, not your internal workspace.
- Billing
- One charge, one receipt, full purchase history on the client's billing page. When the project completes, the space shifts to archive mode.
- Refunds
- The same approval flow — a refund is a decision, not an accident.
Usage-based add-on
$250 per extra brief
The content client whose volume spikes during launches
A base retainer plus metered extras — landing-page briefs, additional edited videos — beyond the included volume.
- Unlocks
- Metering runs against the client's signed-in activity, so what's included, what's used, and what will be billed is visible to both sides.
- Billing
- Extras accrue on the meter and bill with the subscription — no side spreadsheet of approved extras.
- Refunds
- Disputed line items resolve through the same approval-gated refund flow.
Before launch
The first week, before you launch
You don't launch a client portal and hope. This is what the first week actually looks like — and it ends with the portal having already lived a year.
Shape the portal
Describe how the studio works: how clients arrive, your delivery stages, who's on the team. Kliv builds the first preview — client organizations, projects in your language, the walls already in place.
Make it yours
Refine in conversation and by pointing at things: your stage names instead of generic labels, your brand, your domain. Every change lands in the preview before anyone else sees it.
Load the real thing
Create the actual offers — the retainer plan, the project products — invite your team, and move one real client brief in to see the portal with true content.
Try to break it
Sign in as a test client and check the walls: can they see another client's project? Run a checkout, fail the card on purpose, request a refund — watch the recovery emails and the approval step do their jobs.
Then rehearse a year
This is the part no other way of building gives you: in the Sandbox, with simulated money and simulated time, fast-forward twelve months. Watch retainers renew, a card expire in March and recover in April, a cancellation close the right doors. When you publish, you're not shipping a guess — you're shipping a portal that has already run a year of your business.
Bespoke, without the bespoke risk
Custom software used to mean a budget, a contractor, and a maintenance contract. This is a different deal.
Enterprise-grade parts
Sign-in, permissions enforced at the database, billing, audit, email — the components under your bespoke system are the same hardened pieces every Kliv app runs on. You compose proven infrastructure; you don't commission code from scratch.
Changes ship in order
When your process changes, say so — the change is built in conversation, you review it in a live preview, and nothing reaches your users until you publish. Commerce changes can even be rehearsed in the Sandbox with simulated money and time.
Nobody can sunset it
Off-the-shelf tools get re-priced, redesigned, and retired on a vendor's schedule — and your workflow goes with them. Your Kliv app changes only when you change it. It's your product, not a seat in someone else's.
Say it in one sentence
“Build a client portal where each client sees only their own projects and files, retainers bill monthly, and a new client request creates a Trello card for my team.”
This is genuinely how it starts — describe it, then refine in conversation.
Build or buy
Why not just buy a portal?
| Off the shelf | With Kliv | |
|---|---|---|
| Client separation | Workspaces and permission checkboxes — configured by hand, re-checked every time someone joins. | Each client is an organization; row-level database rules make cross-client reads impossible, not just hidden. |
| Your delivery stages | Their pipeline labels; you adapt your process to fit them. | Your words — brief, concepts, rounds, sign-off — modeled the way you already deliver. |
| Cost structure | Per seat, per month — the bill grows with your team, not your revenue. | You own the system — and charge clients through it: retainers, projects, metered add-ons. |
| Changing how you work | A feature request, a roadmap vote, a wait. | A sentence in conversation, a preview, a publish. |
| Your data | Exportable, in the formats their plan allows. | Projects, files, approvals, and billing history are rows in your own database. |
Client separation
Off the shelf: Workspaces and permission checkboxes — configured by hand, re-checked every time someone joins.
With Kliv: Each client is an organization; row-level database rules make cross-client reads impossible, not just hidden.
Your delivery stages
Off the shelf: Their pipeline labels; you adapt your process to fit them.
With Kliv: Your words — brief, concepts, rounds, sign-off — modeled the way you already deliver.
Cost structure
Off the shelf: Per seat, per month — the bill grows with your team, not your revenue.
With Kliv: You own the system — and charge clients through it: retainers, projects, metered add-ons.
Changing how you work
Off the shelf: A feature request, a roadmap vote, a wait.
With Kliv: A sentence in conversation, a preview, a publish.
Your data
Off the shelf: Exportable, in the formats their plan allows.
With Kliv: Projects, files, approvals, and billing history are rows in your own database.
Common questions
How is client separation actually enforced?
At the database. Every client is an organization, and row-level rules mean their users can only ever read their own projects and files — isolation is a property of the data, not of which links you remembered to hide.
Can clients pay retainers through the portal?
Yes — monthly retainers with proration and pause, one-time project fees, and a self-serve billing page. Expired cards get retried and chased automatically.
Does it connect to the tools my team already uses?
Yes. A new client request can create a Trello card, an approval can ping Slack — your team keeps its tools while clients get one clean portal.
Can contractors get limited access?
Yes — roles are part of the same identity system, so a contractor sees the projects they're assigned to and nothing else: no billing, no retainer terms, no other clients. The rule lives at the database, so it holds everywhere.
What happens to a client's space when the engagement ends?
Whatever your offboarding says. A common pattern: when the retainer ends, the space shifts to archive — final files, invoices, and approvals stay readable, while new requests and revision rounds close until a new scope is purchased.
We bill some clients monthly and some per project. Can one portal handle both?
Yes — retainers are subscriptions and projects are one-time purchases in the same catalog, and a client can hold both at once. Each unlocks its part of the space, and the invoices land on one billing page.
