Client Project Portal: What Clients Should See (and What They Shouldn't)

Most agencies get the client portal decision backwards. They agonize over whether to give clients a portal, then flip every visibility switch to "on" and hope for the best.

The real decision is what clients should see. Show too little and the portal is a brochure — clients go back to emailing "any update?" every Tuesday. Show too much and you leak internal chatter, unreviewed timesheets, and margin data you never intended to publish.

This guide is the missing spec: exactly what belongs in a client project portal, what should stay internal, a permission checklist you can copy into your setup doc, and how the configuration differs for retainer clients versus fixed-scope project clients.

The one rule that decides everything

Before the checklists, one principle:

Show clients anything they would otherwise email you about. Hide anything that is unfinished, internal, or priced.

Every "quick status update?" email is a signal that information a client legitimately needs is trapped inside your tools. Every awkward moment — a client reading an internal task comment about their "impossible feedback" — is a signal that information leaked past its audience.

A portal is not a transparency contest. It is a scoped window. Get the scope right and the portal answers questions before they become emails; get it wrong and it creates new ones.

What clients SHOULD see: the six panels

1. Project progress and milestones

The number-one thing clients check. They want the delivery-tracking-page experience: where are we, what's next, when does it land.

• Overall progress against plan and deadlines
• Milestone status (done / in progress / upcoming)
• The task board with workflow stages — at a granularity you choose

Clients who can see progress stop asking about progress. That is the whole business case, and it's measurable (more below).

2. Tasks — at the right altitude

Clients should see deliverable-level tasks: "Homepage design — in review," "Checkout API — in QA." They should not see every subtask, internal ticket, and refactoring chore. Client-facing task lists work best at the altitude the client actually thinks at: the things they're paying for.

3. Time logs (for hourly and retainer work)

If you bill by the hour, transparent time logs are your best invoice-dispute insurance. Clients don't dispute invoices they watched accumulate. Show:

• Hours logged per project, per week
• What those hours were spent on (task-level descriptions)
• Optionally, screenshots — when the engagement calls for maximum proof

The credibility comes from the audit trail underneath: hours logged in real time via time tracking, correction logs visible, and invoiced time locked against after-the-fact edits.

4. Invoices and payment history

Every invoice, past and present, self-service — with a pay-online button on it. "Can you resend the invoice?" should be a question your team never hears again. Payment history and receipts belong in the same place.

5. Files and deliverables

Deliverables should live where the work happened — attached to the task or project — not in an email thread the client can't find three months later. One canonical location ends the "can you send the final-final version?" loop.

6. Messages tied to the project

A chat thread attached to the project record beats email because context never gets lost: the conversation about revision three sits next to revision three. Email notifications keep clients in the loop without forcing them to live in the portal.

What clients should NOT see

This list matters more than the first one, because these are the mistakes that burn trust instead of building it:

• Internal comments and team chat. Your team needs a space to say "the client's feedback contradicts last week's feedback" without an audience. Keep internal discussion channels strictly separate from client-visible threads.
• Unreviewed time entries. Show time logs after your weekly review, not raw. A mistagged entry ("Personal — dentist") on a client-visible timesheet costs more trust than the transparency earned.
• Cost rates and margins. Clients can see billing rates and totals — never what you pay your team. Budget-vs-actual in client currency (their budget), not yours (your cost).
• Other clients' anything. Obvious, but it's the first thing to verify when you configure per-client access. One cross-client leak ends the relationship.
• Draft work and half-finished tasks. Work-in-progress invites drive-by feedback on things that weren't ready for feedback. Expose stages, not the mess inside them.
• Your internal capacity picture. Who's overloaded, who's on the bench, resourcing debates — none of a client's business, all of it ammunition in a rate negotiation.

The permission checklist (copy this)

Run this table for every new client before you send the portal invite:

Want this as a standalone working document with setup steps? Grab the free client portal requirements checklist — it covers the must-have features and the rollout sequence.

Configuring by client type

The checklist above hints at it: there is no single correct portal configuration. There are two, keyed to how the client pays you.

Retainer clients: show the meter

The recurring retainer question is "what are we getting for the monthly fee?" Answer it with numbers the client can check themselves:

• Time logs on, weekly. Hours consumed against the retainer, visible as they accrue.
• Budget vs actual on. If the retainer is 40 hours and 31 are gone by the 20th, the client should see that before the overage conversation, not during it.
• Rates visible. Hourly retainers have no pricing secret to protect — transparency here is pure upside.

Fixed-scope project clients: show the map

Fixed-price clients don't care that a task took 9 hours instead of 6 — that's your margin problem, not their invoice. They care about milestones, deliverables, and dates:

• Milestones and board view on. Progress at the stage level.
• Time logs off (usually). Hourly detail on a fixed-price job invites hourly-style scrutiny of a price that wasn't built that way.
• Deposit and milestone invoices on, payable online.

Same portal, two different windows. This is exactly what granular per-client, per-project permissions in the Corcava client portal are for — one client sees hours and budgets, the next sees milestones only.

Worked example: what visibility is worth on one retainer

Numbers make the case better than principles. Take a single 40-hour/month retainer at $120/hour ($4,800/month):

Without portal visibility. The client sees hours once — on the invoice, after month-end. Industry-typical outcome: roughly one invoice in four triggers a question ("what were these 6 hours of 'revisions'?"). Each round costs your account manager about 45 minutes of timesheet archaeology and a defensive email, and adds 5–10 days to payment while it's "under review." Over a year: 3 disputes × 45 min = ~2.3 hours of unbillable defense work, plus ~$1,200 of revenue routinely stuck in dispute limbo — on one client.

With portal visibility. The client watches the same meter you do: 31 of 40 hours consumed on the 20th, task descriptions attached to every entry. Month-end invoice arrives as a receipt for work they already saw. Disputes converge toward zero, and the renewal conversation starts from shared numbers — the portal shows 40 hours delivered every month, which is the strongest renewal argument that exists.

Multiply by ten retainer clients and the "should we expose time logs?" debate answers itself.

Rollout: 30 minutes per client

1. Pick the client type — retainer or fixed-scope — and apply the matching column from the checklist above.
2. Sweep for leaks. Before inviting, view the portal as the client: any internal comments, unreviewed entries, or wrong-altitude tasks visible? Fix, then invite.
3. Brand it. A white-label portal on your domain (portal.youragency.com) reads as part of your service, not a third-party tool you bolted on.
4. Introduce it in the kickoff, not in an email footer: "Here's where you'll see progress, hours, and invoices — check it before you email us, it's faster."
5. Review quarterly. Engagements change; a project client who converts to retainer needs the retainer config.

For the feature-by-feature evaluation side (what to demand from any portal tool), see our earlier client portal must-have features checklist.

Get the portal question off your plate

Corcava's client portal ships the exact model this guide describes: per-client, per-project permission controls, reviewed time logs with locked invoiced entries, self-service invoices with online payment, files and chat attached to the project record, and full white-labeling — included in the single $9/user/month plan alongside CRM, projects, time tracking, and invoicing.

Start your free 14-day trial, configure your first client's portal with the checklist above, and watch the "quick status update?" emails stop arriving. No credit card required.