AI for Architecture Firms: How to Implement It (5 Workflows Worth Standardising First)

Most architecture firms have tried AI. ChatGPT or Claude for writing. Otter or Fathom for meeting notes. Maybe a plug-in inside Revit or AutoCAD. Some have paid for a tool that promised to write proposals or speed up drawings. And when you look at the numbers that should have moved after a year of using these tools (hours per project, project margin, days waiting to get paid), most firms look about the same as they did before.

The reason isn’t the tool. AI for architecture firms has mostly meant adding tools on top of work that isn’t written down. The principal writes each proposal a little differently. New projects start a little differently every time. Drawing updates depend on whichever project architect is closest to the work that week. Builder questions during construction get answered the way the project architect feels like answering them that day. Pile AI on top of that and you save a few minutes per task. You don’t change how the practice runs.

This is the practical playbook. The five workflows worth attacking first in an architecture practice. How to actually write each one down before you automate it. What AI takes over. What stays human. And what changes in the numbers when you run the loop three or four times in a year.

---

The Implementation Framework

The order is the whole game. Write it down first. Automate second.

AI tools don’t make a messy workflow good. They make it messy faster. Writing things down is the step that has to come first. It is not optional clean-up you do later.

AI is a power tool. A power drill. A circular saw. A nail gun. Fast and strong. It can do in minutes what hand tools take hours to do. But without a blueprint, a power tool just builds a faster mess. AI is the same. Without a workflow written down underneath it, you just speed up whatever chaos was already there.

What “writing it down” actually means: take the workflow and break it into six to twelve steps. Each step has an input (what you start with) and an output (what you end with). Each step has one owner. The test: a brand new hire could run the workflow from the document without asking questions.

What “automate” actually means: once the workflow is written down, separate the pattern steps from the judgment steps. Pattern work looks like drafting, summarising, formatting, comparing, copying. Judgment work looks like design calls, client conversations, sign-off, picking which direction the project goes. AI takes the first pass on the pattern work. People review. Judgment stays human.

This is the practical version of a bigger argument. If you want the deeper version on why the order matters for every kind of services firm, we wrote that here. The rest of this post is what to actually do inside an architecture practice.

For context: the Australian Bureau of Statistics classifies professional, scientific and technical services as one of the most labour-intensive sectors in the economy. McKinsey’s 2024 State of AI shows two-thirds of organisations now use AI in at least one part of their business, but only a small share have rebuilt the underlying workflows. The firms pulling ahead aren’t the ones with the most tools. They’re the ones who got the order right.

The 5 Workflows Worth Standardising First

These are the five workflows that show up in almost every architecture practice, eat the most senior hours per week, and have the highest share of pattern work. Ranked by where most firms should start.

Workflow 1: Writing Project Proposals

What a proposal actually contains.

Strip away the cover page and every project proposal an architecture firm writes has five things in it:

1. What the client wants to build.
2. What stage they’re at and what they need from you.
3. How you’d approach the project, broken into phases.
4. Who from your team would work on it.
5. The fee, the timeline, and what’s included or not.

Everything else is wrapper.

Where the time goes today.

The principal or a senior project architect writes each proposal a little differently. They listen to notes from the first client meeting or work from memory. They write up what the client wants and what stage they’re at by hand. They pull past project photos that feel similar. They guess at the fee using an old spreadsheet and adjust by gut feel. Six to twelve hours per proposal. Across four to eight proposals a month, that’s 30 to 90 senior hours a month buried in proposal writing.

What standardising actually means here.

You write down three things:

• A library of every kind of project you do. Residential renovations, new builds, mixed-use, healthcare fit-outs, whatever your practice does. For each one: what stage you take it from and to, the team it needs, the typical fee range, the photos and past projects that prove you can do it.
• A standard fee structure. What each phase costs, how the fee scales with the size or complexity of the building, what your minimums are, what triggers extra fees.
• A standard proposal layout. The five sections above, with sub-templates for each section.

What full automation looks like once those three are written down.

AI runs the whole proposal:

• Pulls the notes from every meeting and call with the client (Otter, Fathom, or whatever tool the practice records on).
• Drafts the what they want to build and what stage they’re at sections straight from those notes.
• Matches the project to the right kind of project in your library, pulls the matching past projects and photos.
• Generates the fee from your standard pricing logic, sized to the project.
• Assembles the whole document in Word, Google Docs, or InDesign using your standard template.

The proposal is sitting in the principal’s inbox the morning after the last client meeting.

What stays human.

The principal (or senior project architect, on smaller jobs) reviews the design approach and the fee before it goes out. A 20 to 30 minute read. No drafting. No formatting.

What this looks like in real life.

Project proposals that look on brand and hit the same standard no matter who prepared them, with prep time cut by 60 to 80%.

Workflow 2: Starting a Project with a New Client

What starting a project actually contains.

Every new project, no matter the type, starts with the same five things:

1. The kickoff call with the client.
2. Collecting what you need from them (site survey, existing drawings, planning consents, budget confirmation, key contacts on their side).
3. The internal kickoff brief that gets your design team aligned on what they’re actually building.
4. Setting up the project in your tools (project management software, file folders, drawing templates, billing setup).
5. The first design milestone plan with dates, owners, and what gets shown to the client when.

Where the time goes today.

Starting a project usually runs as “however the senior project architect with the most context does it.” Intake forms exist but get half-filled by email. The kickoff call is scheduled by hand. Site surveys, existing drawings, and planning paperwork trickle in over two or three weeks of back-and-forth. The internal kickoff brief is written from scratch every time. Total cost: 10 to 20 hours of senior project architect time per new project, and the first invoice goes out later than anyone admits.

What standardising actually means here.

You write down three things:

• A standard kickoff sequence. Every step from contract-signed to design-work-starting, with clear owners, message templates, and a checklist that has to be complete before the design team picks up the project.
• A standard intake list. Everything you need from every client at the start (site survey, existing drawings, planning consents, budget, key contacts), in the same format every time.
• A standard internal kickoff brief. What your design team needs to know to start work, written the same way for every project.

What full automation looks like once those three are written down.

AI runs the kickoff:

• Drafts and sends the welcome messages from the proposal and the signed contract, spread across the first week.
• Generates the intake checklist sized to the specific project, and chases the client on what’s still missing.
• Drafts the internal kickoff brief from the proposal, the contract, and the recorded client meetings.
• Sets up the project in your project management tool (Monograph, Asana, ClickUp, or whatever you run on), creates the file folders, and schedules the kickoff call on the senior project architect’s calendar.
• Drafts the first design milestone plan from the scope with proposed dates.

What stays human.

The senior project architect runs the kickoff call. They make the call on whether the client’s stated brief matches what came out of the first meetings, and they adjust the plan if it doesn’t.

What this looks like in real life.

Every new project starts the same way no matter who runs it, with time-to-first-billable-hour cut by 40 to 60%.

Workflow 3: Sending Regular Client Updates

What a regular client update actually contains.

Every update an architecture firm sends has six things in it:

1. What we delivered since the last update.
2. What’s in progress and when it’ll be ready.
3. What’s stuck and what we need to unstick it.
4. What’s coming next period.
5. The drawings or visuals showing the design progress.
6. Anything we need from the client (decisions, sign-offs, info).

Where the time goes today.

Project architects pull together drawing progress, write the narrative, format the update, send it. One to two hours per project per update. Across ten active projects, that’s 40 to 80 hours of project architect time a month going into updates. And the firms that don’t send regular updates pay for it differently: clients get nervous, ask for unscheduled meetings, and start asking questions about scope and fee.

What standardising actually means here.

Two things:

• A single update template. Same six sections, same order, same format, every project.
• A list of where to pull drawing progress from per project type. What the design team puts into Revit, AutoCAD, or Bluebeam, and what the standard view looks like for the client.

What full automation looks like once those two are written down.

AI runs the update every period, automatically:

• Pulls activity from the project management tool, the drawing files, the team’s messaging tool, and the meeting notes.
• Drafts each of the six sections from that data.
• Pulls the latest drawing views or renders as the visuals.
• Flags risks where the timeline is slipping, items are stuck, or there’s a pattern of late client decisions.
• Formats and queues the update to the client on the same day every two weeks (or whatever cadence the practice picks).

The project architect scans the draft before it goes out. Two to five minutes.

What stays human.

The project architect’s read on how the client is feeling. Anything that needs to be said carefully. Tough conversations that need a phone call, not a line in an update. The principal only gets pulled in when something needs to escalate. Hours-per-project (how many of your team’s hours each project actually eats) and project margin (the share of fee left after the cost of doing the work) are the financial lines that move when project architect hours come back.

What this looks like in real life.

Every project gets a consistent, professional update every two weeks, automatically, with project architect time per update cut from 1-2 hours to under 10 minutes.

Workflow 4: Answering Builder and Contractor Questions During Construction

What a builder question actually contains.

During construction, the builder or contractor sends questions when something on site doesn’t match the drawings, or when they need a decision the drawings didn’t cover. Every question has the same five parts:

1. What part of the building they’re asking about.
2. What the drawings say.
3. What they’re seeing on site or what they want to do.
4. What they need from you to keep building.
5. When they need it by.

Where the time goes today.

A typical construction project generates 50 to 200 of these questions over the build. The project architect reads each one. They open the drawings, find the section, check the spec, write a response. Two or three a day. Across a busy practice with three or four projects in construction at once, that’s 10 to 15 hours of senior architect time a week just answering questions. The bigger problem: questions sit waiting for a response. The builder stops. The job slows. Nobody bills for the wait.

What standardising actually means here.

Three things:

• A standard format for incoming questions. What you require from the builder before a question is “complete enough” to answer. Question-ready format means the architect can respond fast.
• A response template. Same structure for every answer. What the drawings say. What the answer is. What it changes about the spec or drawings. Any cost or time impact for the contract.
• A documented library of past answers. Tagged by part of the building (foundations, structure, services, finishes, joinery) so the practice can look up how a similar question was answered before.

What full automation looks like once those three are written down.

AI runs the first draft of every response:

• Pulls the question and the relevant drawing section.
• Matches it against past questions answered on this project or earlier projects.
• Drafts a response that quotes what the drawings say and proposes the answer.
• Flags anything that looks like a real design change, a cost impact, or a structural concern.
• Sends the draft to the project architect for review.

The project architect reads the draft, checks the drawings, signs off. Five minutes instead of thirty. Builders get answers same-day instead of waiting three or four.

What stays human.

Any answer that changes the design intent. Anything with a cost or timeline impact. Anything where the contractor is pushing back and a relationship conversation is needed. The principal gets pulled in on anything that touches structure or safety.

What this looks like in real life.

Builder questions answered same-day every time, with senior architect time per question cut from 30 minutes to 5, and projects moving through construction faster because nothing waits on you.

Workflow 5: Invoicing and Getting Paid

What an invoice actually contains.

Every invoice an architecture firm sends has five things in it:

1. The phase or work done that period (phase-based, hourly, or both).
2. Any pass-through costs (engineering consultants, planning fees, printing, renderings, models).
3. The right amount per the contract.
4. Sent to the right billing contact on the client’s side.
5. A plain summary so the client knows what they’re paying for.

Where the time goes today.

A phase wraps or the month closes. Admin or office manager pulls time data and consultant invoices. The principal or senior project architect reviews. Invoice goes out. The lag between the work being done and the invoice being sent is typically 5 to 10 business days. That lag is cash the practice could already have in the bank.

What standardising actually means here.

Three things:

• A standard billing day. The 25th of every month, every month, no exceptions.
• Invoice templates per project type. Phase-based, hourly, or hybrid. Each with the same structure.
• A written review-and-send sequence. Admin knows what triggers each step. The principal knows when their sign-off is required and when it isn’t.

What full automation looks like once those three are written down.

AI runs the invoicing cycle end-to-end:

• Pulls time data from the time tracker or project management tool.
• Pulls pass-through costs from the accounting system (engineer invoices, planning fees, printing, renderings).
• Cross-references the contract for fee structure and rates.
• Drafts the invoice with line items plus a plain summary for the client.
• Sends to the billing contact on the standard billing day, automatically.
• Follows up on overdue invoices on a written sequence (reminder at day 7, escalation at day 14, principal flagged at day 21).

What stays human.

Principal sign-off on anything where the scope went sideways, the amount looks unusual, or the client needs a real conversation instead of an email. If your books are set up right so accounts receivable (money clients owe you that hasn’t landed yet) is visible in real time, the gain compounds.

What this looks like in real life.

Invoices going out on the same day every month, every time, with the time-to-bill cycle cut from 5-10 days to same-day. Debtor days (how many days, on average, between sending the invoice and the money landing in the bank) drop 10 to 25% in the first year, building the cash buffer (the months of operating costs your available cash covers) without anyone chasing it.

What This Looks Like in the Numbers

Three effects, in sequence, when you run this loop properly. They don’t happen as separate wins. Capacity reclaimed in quarter one is what makes the project margin lift in quarter two possible, which is what builds the cash buffer in quarter three. Growth, profit, and cash flow are three sides of the same engine. Each move shows up in more than one.

Capacity reclaimed first (within a quarter, once the first workflow is written down). The team finishes the same work in fewer hours. Either revenue lifts because the practice can take on more projects at the same team size, or margin lifts because the same projects now cost fewer hours to deliver. Most firms take a mix of both.

Project margin lifts second (within two quarters). The margin gain compounds because the standardised workflow saves time on every project from then on, not just the first one. The lift is permanent, not a one-time bump.

Cash flow stabilises third (within three quarters). When the invoicing workflow is in the loop, debtor days drop 10 to 25% in the first year. Sometimes more. The cash buffer builds without anyone chasing it.

There are knock-on effects most principals don’t price in until they show up. Project management tools that were holding non-standard work together come off the software line. Reporting tools whose output now generates upstream come off the software line. Workflow tools whose use got absorbed come off the software line. Five-figure annual software savings are realistic by year two for most firms running this loop seriously.

These numbers are directional, not exact. Your practice’s mix and team shape will shift the picture. Firms doing big residential one-off projects see capacity gains compound differently than firms running lots of smaller fit-outs. Firms with longer billing cycles see cash flow gains land later than the three-quarter window. The benchmark is the framework, not the specific percentage.

Implementation Timeline

Month 1. Pick the workflow eating the most senior hours this week. Probably proposals or builder questions. Write it down as it actually runs today, not as you wish it ran. Six to twelve steps with inputs, outputs, and owners. Don’t add AI yet.

Months 2-3. Standardise the workflow with the team that runs it. Layer AI on the pattern steps. Check how long it takes before and after. If it didn’t get at least 40% faster, the workflow wasn’t written down well enough. Go back, tighten, retry. Don’t add more AI on top of a half-documented process.

Months 4-6. Move to the second workflow. Then the third. Around the third or fourth workflow, the compounding starts to show in the numbers.

Months 6-12. Visible in the P&L. Hours per project are down. Project margin is up. The software line is down. Debtor days are down. The senior team has hours back that they’re spending on the work the practice actually needs them in.

Where AI Backfires in an Architecture Firm

Three workflows that look automatable but where AI usually backfires.

Design and concept development. Design taste is the product. AI can help explore options, but it can’t lead. The firms that hand design direction to AI watch their work converge with everyone else’s.

Drawing review and red-lining. This needs senior eyes even when drafting is AI-assisted. The drafting can be AI. The judgment on whether the drawing is right cannot.

Scope creep conversations. AI can flag when a project is going over scope. It can’t have the conversation with the client about it. That’s relationship work.

The pattern across all three: judgment-heavy, relationship-heavy, taste-heavy. AI in those workflows gives you faster output and worse outcomes.

What to Do This Week

Three things you can start before Friday.

Pick the workflow. Look at last month’s senior timesheets. Where did the most senior hours go? That’s your first workflow.

Write it down. Six to twelve steps, inputs, outputs, owners. One afternoon.

Mark the steps. Pattern work gets a star. Judgment work gets a different mark. The starred steps are your AI list for next month.

Skip the tool conversation until you’ve done these three. The firms that compound from AI are the ones that get the workflow written down before they buy anything new. The Financial Performance Check covers which workflow tends to move the biggest financial line based on your practice’s stage and fee band.

---

AI implementation in an architecture firm isn’t a tool problem. It’s a discipline problem. The firms pulling ahead are the ones that picked one boring, repeatable workflow at a time, wrote it down, decided which steps deserved a person, and let software handle the rest.

If you’ve never mapped your most-repeated workflow end to end, that’s the place to start. The real returns sit in the unglamorous work, the part that’s been running on senior memory for years.