Project Management for Architecture Firms: From Briefing to Construction

An architecture firm rarely has a talent problem. The problem is usually something else: ten projects open at once, each in a different phase, every client asking for "just a tiny tweak," and nobody knowing exactly how many hours the preliminary design for the Jurerê house really took. Creativity is solved; what's missing is organizing the work around the drawing.

This article shows how to structure the management of an architecture firm around three fronts: the project phases, the client revisions, and the hours per project. First, an honest warning: Tasskee is not drawing or BIM software. You keep drawing in the program you already use. What gets organized here is everything that happens around the file.

Why architecture projects are hard to manage

Four characteristics make this trade behave differently from other services.

• Long, sequential phases. Each stage depends on the previous one, and the client needs to approve before moving on.
• Third parties in the way. City hall, engineering consultants (structural, electrical, plumbing), suppliers. The deadline is not only yours.
• Revisions in cycles. The client looks, asks for a change, you adjust, they look again. Without control, the scope grows silently.
• Paid by stage, effort by the hour. You charge a fixed fee, but you spend variable hours. Without time tracking, you can't know whether the project was profitable.

Phase 1: turn the project stages into a structure

The classic breakdown of an architectural project is already a good work structure. Every firm names it differently, but the skeleton is usually this:

Phase	What happens	Who needs to decide
Briefing and survey	Conversation with the client, site or property visit, measurements	Client approves the program of needs
Preliminary study	First ideas for site layout, massing, and floor plan	Client chooses the direction
Schematic design	Plans, sections, and elevations developed	Client approves the set
City hall approval	Documentation filed and tracked	Public agency
Construction documents	Detailing, coordination with consultants	Client and designers
Construction follow-up	Visits, questions from the site, adjustments	Client and builder

In Tasskee, each client project becomes a project and each phase becomes a workstream, the grouping inside the project. The tasks of each phase live inside their workstream: "measure the living room," "draw the roof plan," "assemble the elevations sheet." Whoever opens the project sees which phase it's in and what's left in it.

A template so you don't start from scratch

Every new-house project repeats more or less the same tasks. Instead of recreating them for each client, define the workstreams and the standard tasks of each phase once, and repeat that same structure when you sign a contract. The time spent once pays back on every new project, and each stage's checklist stops depending on the memory of whoever happens to be free.

Phase 2: the schedule the client understands

Architecture lives on chained dates: city hall only comes in after the schematic design is approved; the construction documents only close after coordination. That chaining is what the Gantt schedule shows well: tasks with dependencies, milestones (like "schematic design approved"), and the critical path, the sequence that, if it slips, delays the whole project.

Two practical uses for a firm:

• Predict the effect of a wait. If the client takes two weeks to reply, the Gantt shows what slips along with it. Instead of a vague conversation about delay, you show the new date and the cause.
• Balance the workload. With all projects in one place, it becomes visible when three sets of construction documents are due in the same week and there are only two architects to produce them.

One note on method: don't promise a city hall approval deadline. It depends on the agency, the city, and the complexity. Treat the stage as a milestone with an estimated date and, when possible, leave an explicit buffer. If a task to follow up on the filing exists, it reminds you to check progress, but it doesn't speed up the stamp.

Phase 3: client revisions without losing control

Revision is where most firms lose money. It starts with a simple request on WhatsApp, turns into a phone call, then an email with three changes mixed together. Months later nobody knows what was agreed or whether it was in the contract.

A routine that fixes this is short:

1. Each revision round is a task. "Revision 1 of the schematic design: client comments." With an intake date and a return date.
2. Each request becomes a subtask or a checklist item. "Enlarge the window in bedroom 2," "change the balcony cladding." When the team checks it off, the client sees what changed.
3. Requests come in through a single channel. Agree that revisions come in through the client portal, as comments on the task itself, and not scattered across conversations.
4. Approval on record. At the end of each phase, the client approves through the portal, and the task records who approved and when.

The portal works like this: you choose, project by project, what the client sees. You can release the deliverables and hide internal tasks, such as checking measurements or a draft that isn't ready to show. The client comments, approves, and follows progress without asking for status updates, and guests don't take a seat on your plan.

How many revisions fit in the contract?

There is no right number, and your contract decides. What the system helps you do is see when you've gone over. If the contract allows two revision rounds on the schematic design and the task for the third has just been created, the firm has a fact in hand to talk to the client: a dated list of what was requested and what was delivered in each round.

Phase 4: hours per project, to know if the project was profitable

Architecture projects are usually billed at a fixed fee or per square meter. That's great for the client and dangerous for the firm: if nobody tracks time, the firm only finds out a project was bad when the month's owner draw no longer adds up.

Tasskee's time tracking lets you log time directly on the task, and the hourly rate is set by project and by type of work. With that, you can answer questions a spreadsheet can't:

• How many hours did the preliminary study for residence X take, and how many were estimated?
• In which phase does the firm spend more than it charges: in revisions? In coordination?
• Which client causes the most rework per real received?

Two notes on what Tasskee does and doesn't do. Hours serve to measure effort and produce the report for the client (in PDF or CSV); Tasskee does not issue invoices, it only lets you record the invoice you issued in your own system. And the permissions to see rate and cost are separate: an intern can log hours without seeing how much the firm charges for them.

Phase 5: construction, the project that keeps going

Construction follow-up changes the rhythm of work: instead of long phases, you get one-off questions from the site, visits, and small design adjustments. A good way to handle this is to keep, inside the same project, a workstream called "Construction" where each question from the builder becomes a short task, with an assignee and a due date, and the weekly visit becomes a recurring task.

Mind the limit: Tasskee is not a construction ERP. Budgeting, service measurement, and the site logbook remain out of scope. Use the tool for what belongs to the firm (design decisions, questions, deadlines, communication with the client) and keep the financial management of the construction in the builder's system.

A week of routine, in practice

To see how the pieces fit together, imagine a small firm in Florianópolis with five active projects and three people.

• Monday morning: a short meeting looking at the board. Each person sees their tasks for the week and what's blocked waiting on the client.
• During the week: the team logs hours as they work and comments project questions on the tasks, instead of opening loose conversations.
• Thursday: deliverables that depend on the client go up to the portal, and the client is notified that there is something to approve.
• Friday: a quick look at the Gantt to see whether any milestone slipped and, if so, the conversation with the client already has a date and a cause.

None of this requires a named methodology. It requires the work to be written down in one place.

Common mistakes when organizing an architecture firm

• Managing by file, not by task. A tidy network folder doesn't say who is doing what or by when.
• Not writing down what the client approved. "He said he liked it" doesn't settle a dispute six months later.
• Logging hours only at the end of the month. Memory distorts, and the data stops being useful for decisions.
• Mixing internal tasks with client tasks. The client doesn't need to see "reorganize the block library," and the team does.

Where to start

Pick a project in progress, create the workstreams for the phases, and move the tasks for the next 30 days over. Log this week's hours. Invite the client to the portal on the next delivery. If it works on that project, replicate it on the next one, using the first as a template.

If you want to see how this looks set up for your type of firm, the page Tasskee for architecture firms has the step-by-step, and the Free plan lets you try organizing by phases without paying anything.