Drive, WhatsApp, or a client portal: what your studio runs on
An honest comparison of the four ways studios run client work, what each costs in hours, the size at which each one breaks, and a checklist for evaluating anything that asks to sit between you and your fee.
- Drive and WhatsApp are genuinely fine for a solo practice with two live projects. Don't let anyone tell you otherwise.
- They stop being fine at roughly three people or six concurrent projects, and the failure is always the same: nobody can say what the current version is or who has it.
- General project tools solve tasks. They don't solve issuing a drawing against a fee, which is what architecture actually needs.
- Whatever you pick, ask where the money settles. A tool that holds your fee is a different kind of dependency from one that doesn't.
Every architect who has run a practice for more than three years has had the same fortnight. Two projects hit working drawings at once, a client asks for something you're fairly sure you sent in April, and you spend a Saturday going through an inbox to work out what you actually issued. Somewhere in that Saturday you decide the studio needs a system.
Then Monday arrives and the decision goes nowhere, because every option looks like a month of setup for a benefit you can't quite name. This is an attempt to name it, including the case for changing nothing.
When Drive and WhatsApp are genuinely fine
If you're one or two people with two or three live projects, the free stack isn't a compromise. It's the correct answer, and adopting software instead would be a straightforward mistake.
The reason is that the whole system fits in one person's head. You know what you sent because you sent it. You know which revision is current because you drew it last Tuesday. There's no coordination problem, so a tool that solves coordination problems is solving something you don't have, in exchange for a monthly fee and an afternoon of setup.
Spend that afternoon on the things that scale with you instead: a numbering convention, a title block that carries status properly, and a drawing register in a spreadsheet. Those habits will be worth more at ten people than any software you could buy today, and they cost nothing.
The four setups
There are four realistic arrangements. Compare them on what each is actually good at rather than on features.
| Setup | Good at | Breaks when | Real cost |
|---|---|---|---|
| Drive + WhatsApp + email | Costing nothing, needing no setup, being understood by every client without explanation | More than one person issues drawings, or a link shared in March is still live in December | Free, plus several hours a month reconstructing what happened |
| General project tool (Notion, Trello, Asana) | Tasks, internal coordination, a studio-wide view of what is due | You need to issue a drawing against a fee, or give a client a view that is only theirs | Modest per seat, plus the ongoing cost of maintaining a structure you invented |
| Construction / AEC platform | Large multi-consultant jobs, RFIs, formal document control at scale | You are five people doing houses and mid-size commercial work, and drown in process | Substantial, and priced for main contractors rather than design studios |
| Purpose-built architect client portal | One private space per client, issuing drawings against payment, a record of what unlocked and when | You need heavy site-management features, or your work is not client-and-fee shaped | Per studio, and only worth it if the fee problem is one you actually have |
No row here is wrong. The mistake is picking a row that solves a problem you don't have while leaving the one you do have untouched.
Most studios end up in the second row, and it's worth understanding why it disappoints. General project tools are built around tasks: something needs doing, someone is assigned, it gets closed. But architecture practice isn't primarily a task problem. It's a document-and-money problem. The drawing is the unit, the fee is what releases it, and the client is a party who should see their own project and nothing else. You can bend a board of cards into that shape. You'll be maintaining the bend forever.
The checklist
Whatever you're evaluating, including staying where you are, these are the questions that separate tools still working in year three from tools you abandon in month four.
- Does each client get a space that is only theirs? Not a folder you remember not to share widely, but genuine separation. Ask whether it is enforced below the interface or is simply a filter the software could get wrong. Workspace isolation that lives in the database is a different guarantee from one that lives in a screen.
- Can a file be held until an invoice is paid? This is the single feature most tools do not have and most practices most need. Without it, your fee schedule is aspirational. With it, issuing on payment is the default rather than an act of willpower.
- Is there a record of who saw what, and when? You will want this exactly once, and by then it is too late to start collecting it. An audit log is unglamorous until the afternoon it settles a dispute.
- Where does the money settle? Straight into your own account, or into a platform wallet that pays out later on someone else's schedule? Settling to your own account means the tool never holds your fee, which is a materially different relationship.
- Does it take your formats without conversion? If drawings have to be flattened or exported to be usable, the tool will be worked around within a month.
- Can links expire and be revoked? Sharing with a consultant should not mean creating something permanent. See sending drawings without losing control.
- What happens to your data if you leave? Ask before you join, not after. A tool that cannot export your records cleanly is a tool with a hostage.
- How long to onboard one client? If it is more than a few minutes, you will stop doing it properly by the fourth client, and a system used inconsistently is worse than none.
Build versus buy
Every second architect has a cousin who writes software, and the thought is reasonable enough: this isn't complicated, it's a folder, a login and a payment link.
It isn't complicated to build badly, which is the trap. The visible part, uploading drawings and showing them to a client, is a weekend. The parts that decide whether the thing is safe to run a practice on are not: tenant isolation that holds against a hand-crafted request, files served through short-lived signed links rather than public URLs, payment status settled by signature-verified webhooks rather than by whatever the browser reports on the way back from checkout, and idempotent handling so a duplicate event never grants access twice. That list is a fair description of what a payment integration has to get right before anyone can trust it with a fee.
Get the webhook handling wrong and a client who abandons a payment can end up with the drawings anyway. Get the isolation wrong and one client can read another's project. Neither failure announces itself. You find out from someone else.
Build if the differentiator is truly yours and you intend to maintain it for years. Buy if what you want is for the thing to work on a Tuesday while you do architecture. Most practices, honestly assessed, are in the second group.
The visible part is a weekend. The load-bearing part is not, and it is the part nobody sees until it fails.
Switching without losing a season
What keeps most studios on a setup they've outgrown isn't loyalty. It's the migration, which looks like a month. Done in the right order it's closer to a week, because you don't move everything.
Start with new projects only
Don't migrate live jobs mid-stage. Every project that starts after the switch begins in the new place, and the old ones finish where they are.
Move the current set, not the archive
Clients need the live revision, not eight months of superseded sheets. The archive can stay where it is and be pulled forward if anyone ever asks, which they rarely do.
Onboard your least difficult client first
The one who replies to emails. Learn the shape of it on a forgiving project before you introduce it to the client who will have opinions.
Move the money last
Get documents and access working before you change how invoices are raised. Two changes at once and you can't tell which one caused the confusion.
Set a hard cutover date for issuing
After this date, no drawing leaves the studio by email attachment. A soft transition means running both systems forever, which is worse than either.
So which row
Solo with two projects: row one, and spend the saved money on better habits. If the problem is internal coordination across a team and fees aren't an issue, row two fits. Large multi-consultant jobs with formal RFI processes: row three exists for you and earns its price.
Row four is for the studio whose actual problem is the one this article has been circling: drawings going out before the fee comes in, no clean record of what was issued to whom, and a different arrangement for every client. That's a narrow description, and if it doesn't fit you then it doesn't fit you.
It's the description AtelierLab is built against. A private workspace per client holding the drawings, the invoices and the thread. Sets that stay sealed until the payment clears and then release themselves. Payments that settle into your own Razorpay account, never a wallet in between. If the fee problem isn't your problem, one of the other three rows will serve you better, and we'd rather say so.
If that last row sounds like your studio
We're onboarding our first studios now, with personal setup for each practice. Set up in minutes, your own Razorpay account, and one home for every client from the first day.
Questions, answered
The questions architects ask most about this, in plain language.
Ask us anythingPossibly not yet. The honest threshold is the point at which the answer to "which is the latest revision?" stops being something you know and becomes something you have to check, which usually arrives around three people or six concurrent projects. Below that, a shared drive, a good numbering convention and a register in a spreadsheet are perfectly sufficient, and the habits you build there are worth more later than any tool you could buy today.
It varies by how it is sold: per user, per project or per studio. The more useful question is what the current arrangement costs, which is rarely nothing. Several hours a month reconstructing what was issued, plus the fees that arrive late because drawings went out ahead of them, tends to add up to more than the software. AtelierLab is in early access and onboarding by invitation at present, so there is no public price to quote.
For internal coordination, yes, and many studios do it well. The mismatch appears at the client boundary. General project tools are organised around tasks, whereas architecture practice is organised around documents and fees: the drawing is the unit, the invoice is what releases it, and each client should see only their own project. You can bend a task tool into that shape, but you will be maintaining the bend indefinitely, and it still will not hold a file back until an invoice is paid.
Build it if it is truly a differentiator you intend to maintain for years. The visible part, uploading drawings and showing them to a client, is a weekend's work. The load-bearing parts are not: tenant isolation that holds against a hand-crafted request, files served by short-lived signed links, and payment status settled by signature-verified webhooks handled idempotently rather than by trusting a browser redirect. Those failures do not announce themselves, and you tend to learn about them from someone else.
Ask this before signing anything, because the answers differ sharply. Some platforms take payments into their own wallet and pay you out on their schedule, which makes them a party to your cash flow. Others connect your own payment account so client payments settle directly to you and the platform never holds funds. AtelierLab works the second way, through Razorpay's official OAuth flow. Ask equally what happens to your records if you leave: a tool that cannot export cleanly is holding a hostage.