It landed without ceremony, somewhere between a fix to how multi-page drawing revisions are matched and a tidy-up of the support inbox. Which is fitting, because that is what a thousand versions actually looks like: not one big moment, but a long run of small ones.

Doclio went live in April. We thought this was a good excuse to look back at what has been built since, and to say thank you to the people who have been using it while we did.

The drawing set, online

The core has always been the drawing set. Upload a multi-page PDF and Doclio splits it into individual sheets, reading the drawing number and title off each one where there is a text layer. Revisions track themselves, and you can compare two on screen to see exactly what changed rather than squinting between two tabs.

Cross-references between sheets are detected and turned into live links, so a callout on a plan opens the detail it points to.

Over the past few months that set has gained a lot of small conveniences that came almost entirely from user requests: favourites, downloading a single sheet or a whole selection as one zip, downloading a superseded revision as easily as the current one, and — a fiddly one this — uploading a new revision from a multi-page file, where Doclio now asks which page is the drawing and shows you a preview so you pick the right sheet.

Take-offs that measure

In July the take-off tools changed in a way worth calling out. Areas are now measured, not estimated: the AI finds the region, and the app traces the drawing's own vector linework at the set scale and measures it, typically within about a percent on a vector drawing with the scale set. Openings are deducted automatically. Scans, which have no linework to trace, are still labelled estimates.

You can adjust any measured area and the totals recompute immediately, and export take-offs for one drawing or the whole project. Lengths are read from the drawing's own dimension callouts rather than traced, so check those with the measure tool before you rely on them.

You can also just ask. "You missed the right side of the south elevation" now sends the assistant back to that region rather than starting over.

Quality records that live with the drawings

Inspection and Test Plans arrived in June and have been steadily built out since: a per-project register with groups, sections and tasks, a sign-off matrix across the responsible parties, hold and witness points, per-row photo evidence and reusable digital signatures. Lock and approve a plan and it stops drifting. The assistant will draft a first-cut ITP from your project documents, which you review and refine — a starting point, not a rubber stamp.

Reports and the mailbox

Reports render as clean tables with automatic subtotals and totals, and any row jumps straight to its drawing. Share one by link and the recipient needs no account.

The project mailbox has had the most steady attention of anything this year. Threads now have a Files tab with every attachment in one place, tick boxes to grab just the ones you want, and a download-all-as-zip. Formatting survives the round trip in both directions — bold, lists and links you write reach the recipient's inbox intact, and formatting in their reply is kept too, including answers typed inline. Replies go out the moment you hit send instead of a minute or two later. And people you share a thread with can do all of it from the emailed link, without signing in.

The unglamorous half

A fair share of those thousand versions will never show up in a feature list, and we think that is worth saying out loud.

There have been security reviews that closed real gaps before anyone hit them. There is a warning when you are approaching your storage limit, and a clear message with a way to add capacity when an upload will not fit, instead of a failure you have to decode. Asking to delete your account now schedules it thirty days out and requires a code emailed to you, so nobody can wipe an account just by getting at an open laptop.

And a long tail of fixes for things that were simply wrong. The assistant used to report a drawing as corrupted when the sheet just had no readable text layer. That sort of thing.

What has not changed

Every plan still includes unlimited users and unlimited viewers. Your subcontractors, consultants and clients cost nothing to add, which is the only way a single source of truth actually works — per-seat pricing quietly encourages you to leave people out, and then the drawing set is not the source of truth any more.

Doclio still runs in any browser on desktop, tablet and phone with nothing to install. Drawings you have opened stay readable without a connection, though offline is read-only — changes are not queued while you are disconnected, and we would rather say so than let you find out on site.

And the focus has not moved. Doclio is for drawings, quality records, approvals, reporting and project correspondence — the document and quality side of a job, done properly, rather than a little of everything.

Thank you

Most of the thousand exist because somebody told us something was awkward. The multi-page revision picker, the zip downloads, the formatting that kept getting mangled in email replies, the takeoff that needed correcting rather than redoing — none of those came from a roadmap. They came from people who took the time to write in when something got in their way, often about a detail small enough that it would have been easier to just work around it.

Thank you for that. It is genuinely the most useful thing you can send us, and it is why the next thousand will be worth more than the first.

If something is annoying you right now, tell us. We read all of it.

That's the situation most project managers are trying to control when they search what is the critical path method. They're not looking for a classroom definition. They're trying to work out why a delay that looked minor on paper has started to drag the whole job.

The Critical Path Method, or CPM, is the discipline that brings order to that problem. It shows which sequence of activities controls the project finish date, which tasks have room to move, and which “small” delays aren't small at all. On a live construction project, that matters far more than a pretty bar chart.

Table of Contents

• Why a Small Delay Can Derail Your Entire Project
  • What this looks like in practice
• The Core Concepts of the Critical Path Method
  • The building blocks
  • Why logic matters more than task lists
  • A useful site mindset
• Calculating the Critical Path Step by Step
  • Start with activities and logic
  • Run the forward pass
  • Run the backward pass
  • Identify the critical path
• How to Interpret Your CPM Results
  • Read the path, not just the bars
  • Understand total float and free float
  • Watch for near-critical paths
• Applying CPM on Construction and Capital Projects
  • Treat the programme as a control model
  • Use updates to support decisions
• Common Pitfalls and How to Avoid Them
  • Where CPM gets misused
  • What to do instead
• CPM vs PERT vs Gantt Charts
  • CPM vs PERT vs Gantt Chart
  • Which one should you use

Why a Small Delay Can Derail Your Entire Project

A steel delivery slips. On its own, that doesn't sound catastrophic. But the steel needs to arrive before installation. Installation needs to finish before deck works. Deck works need to finish before follow-on services can start safely. By the time the delay shows up in the site meeting, four crews are affected and the completion milestone is under pressure.

That's why experienced planners don't judge delay by how annoying it feels. They judge it by where it sits in the logic.

A project always has many activities happening in parallel. Some can absorb movement. Others can't. If an activity sits on the chain that determines the finish date, any delay to it pushes the whole project unless something else changes. That chain is the critical path.

On site, a delay becomes dangerous when it hits a dependency that no one can work around.

This is exactly the problem CPM was built to solve. The method was first developed in the late 1950s and first used in 1958 on a chemical plant construction project by DuPont and Remington Rand, which is why it became closely associated with large industrial and construction scheduling problems rather than simple task lists, as outlined in EBSCO's overview of the critical path method.

That history matters. CPM didn't come out of lightweight admin work. It came out of environments where sequencing errors, missed interfaces, and trade coordination failures had real cost and time consequences. That's close to the situation of major building and infrastructure work in Australia.

What this looks like in practice

On a real job, the early warning signs are usually familiar:

• A design release slips and procurement can't place an order.
• A workfront doesn't open because predecessor trades are incomplete.
• An approval sits unresolved and downstream crews burn available float.
• Teams resequence informally without updating the programme logic.

Once that starts happening, a static schedule stops being useful. You need a model that shows cause and effect. CPM does that. It tells you which delay is local noise and which one threatens handover.

The Core Concepts of the Critical Path Method

If you want a practical answer to what is the critical path method, start with the parts that drive it. CPM isn't magic. It's a logic model built from activities, durations, and dependencies.

Think about a small shed build. You can't install cladding before the frame is up. You can't frame before the slab is ready. You may be able to order materials while approvals are being finalised, but only if the design is sufficiently settled. CPM maps those relationships properly.

The building blocks

Here are the core concepts in plain language:

• Activity. A defined piece of work. Pour slab, install formwork, issue shop drawings, inspect reinforcement.
• Duration. How long that activity is expected to take.
• Dependency. The relationship between tasks. One task starts only after another finishes, or sometimes in controlled overlap.
• Path. A chain of linked activities from project start to project finish.
• Critical activity. An activity with zero float. If it slips, the project finish slips.

A concise definition comes from Wikipedia's entry on the Critical Path Method, which describes CPM as a scheduling technique that identifies the sequence of activities determining project duration, with critical tasks having zero float and therefore no ability to slip without extending the overall timeline.

Why logic matters more than task lists

A task list tells you what exists. A CPM schedule tells you what controls what.

That distinction catches newer project managers out. They create a detailed list of activities, then assume detail equals control. It doesn't. If the dependencies are wrong, the programme may look complete while still telling you the wrong completion story.

Practical rule: A schedule with weak logic is worse than a shorter schedule with clear logic. At least the second one tells the truth.

A good CPM network answers a few hard questions quickly:

A short visual helps if you want to see the sequence from task list to critical path.

A useful site mindset

Don't think of CPM as software output. Think of it as a map of constraints. If the map is accurate, you can make decisions earlier. If it isn't, the programme becomes decoration.

That's why the strongest schedules are built around real interfaces: design issue dates, procurement release points, access constraints, inspections, hold points, authority approvals, and trade handovers. Those are the things that stop work.

Calculating the Critical Path Step by Step

CPM is comprehensible once one works through a small example. The arithmetic isn't complicated. The discipline is in setting the logic correctly.

Use this simple renovation example:

Start with activities and logic

Before doing any pass calculation, sense-check the sequence.

Demolition must follow site setup. Rough-in services and framing both depend on demolition. Plasterboard can't start until both are complete. Painting follows plasterboard, and final fit-off follows painting.

That gives you two parallel streams after demolition:

• Path 1. A → B → C → E → F → G
• Path 2. A → B → D → E → F → G

The path through rough-in services is longer than the path through framing, so it's already the likely critical path. The forward and backward pass confirm it.

Run the forward pass

The forward pass calculates the earliest time each activity can start and finish.

Use this simple logic:

• Early Start (ES) is the earliest an activity can begin
• Early Finish (EF) = ES + Duration
• If an activity has more than one predecessor, its ES is the latest EF of those predecessors

Now apply it:

The earliest completion time for the whole project is 16 days. That duration comes from the longest dependent path through the network.

Run the backward pass

The backward pass tells you the latest each activity can start or finish without delaying project completion.

Use this logic:

• Start from the project finish
• Late Finish (LF) for the last activity equals its EF
• Late Start (LS) = LF - Duration
• If an activity has more than one successor, its LF is the earliest LS of those successors

Now work backwards:

Now compare early and late dates.

• A ES 0, LS 0
• B ES 2, LS 2
• C ES 5, LS 5
• D ES 5, LS 7
• E ES 9, LS 9
• F ES 12, LS 12
• G ES 14, LS 14

Identify the critical path

The activities where early and late dates are the same have zero float. In this example, those are:

• A
• B
• C
• E
• F
• G

So the critical path is:

A → B → C → E → F → G

Activity D is not critical because it has room to move.

If a task can slip and the project finish still holds, it isn't controlling the job today.

This is the point many teams miss. The result isn't just a line through a diagram. It's a management priority list. The critical path tells you where supervision, procurement follow-up, design coordination, and daily reporting should focus first.

How to Interpret Your CPM Results

Calculating the path is the easy part. The value comes from interpreting what the schedule is telling you.

A CPM programme is not just a finish date calculator. It's a risk map. It shows which work packages control time, which tasks have flexibility, and where a small change is likely to become a wider disruption.

Read the path, not just the bars

Using the example above, the obvious conclusion is that A → B → C → E → F → G controls completion. But a better reading goes further.

It tells you demolition and rough-in services deserve tight management because they sit early on the controlling path. If rough-in services start drifting, the downstream effect is immediate. Framing, by contrast, has some tolerance.

That doesn't mean framing is unimportant. It means it is not currently the task that sets the finish date.

Understand total float and free float

Two float concepts matter in practice.

In the renovation example, D Framing has total float because it can finish later than its early finish and still not delay plasterboard, provided it finishes before E must start.

That distinction matters when you're trying to recover time. A superintendent may be comfortable using some float on a non-critical activity if it protects a constrained critical activity. That can be a smart move. It can also become dangerous if nobody tracks how much float has already been consumed.

Non-critical doesn't mean safe. It often means safe for now.

Watch for near-critical paths

One of the easiest mistakes in CPM interpretation is to focus only on the current critical path and ignore paths that are close behind.

In the example, the path through D Framing is shorter, but not by much. If framing stretches, or if rough-in services finishes earlier than expected, the balance can change. That's how teams get surprised by a new critical path halfway through the job.

A useful review habit is to ask:

• Which activities have zero float right now
• Which path is close enough to become critical if one task shifts
• Which procurement, approval, or access issues could change the path
• Which assumptions in the programme are no longer true on site

If you read CPM this way, the schedule stops being an administrative file and becomes a live decision tool.

Applying CPM on Construction and Capital Projects

The biggest mistake teams make with CPM is treating it as a planning deliverable instead of a control system. On a live project, the critical path is not fixed. It moves when logic changes, when progress differs from plan, and when site conditions force resequencing.

That matters in Australia because construction activity is large and interconnected. The Australian Bureau of Statistics reported construction work done of about A$65.4 billion in the March 2025 quarter, as referenced in the AHRQ discussion of the critical path method as a tool for identifying scheduling and resource problems. On projects at that scale and complexity, a static CPM explanation doesn't match real controls practice.

Treat the programme as a control model

A useful site programme does four things repeatedly:

• Updates actual progress so logic reflects reality, not last month's assumptions.
• Tests delay impact by recalculating the path after slippage, design changes, or changed access.
• Shows resequencing effects before the team commits to a recovery plan.
• Supports evidence for extension of time analysis, subcontract coordination, and stakeholder reporting.

A common pitfall for junior PMs is thinking “the critical path” is one permanent chain established at baseline. It isn't. It is the chain that controls completion now, based on the current logic and current status.

Use updates to support decisions

On active construction and capital projects, CPM helps most when it is tied to decisions people need to make.

For example:

• Procurement follow-up. If a long-lead item sits on a live critical chain, the team needs faster escalation, not routine status notes.
• Trade coordination. If two subcontractors are consuming the same float from opposite sides, the PM needs to intervene before the clash turns into delay.
• Change assessment. If a design change affects a controlling activity, you need to test the programme impact immediately.
• Recovery planning. If the team proposes overlap or acceleration, run it through the logic first. Some recovery ideas only move work around visually. They don't shorten the controlling path.

A programme update is only useful if it changes someone's decision.

The strongest project controls teams keep schedule logic close to site reality. They speak with foremen, services managers, design managers, and procurement leads. They don't just collect dates. They check whether the sequence still reflects how the job will be built.

That's the practical difference between schedule administration and schedule control.

Common Pitfalls and How to Avoid Them

CPM is reliable when the model reflects reality. It becomes misleading when teams use it as a neat planning exercise and ignore uncertainty, resource constraints, or shifting site conditions.

Where CPM gets misused

A common mistake is assuming every duration is solid because it was entered into software. On many projects, durations involve judgement, crew assumptions, supply assumptions, approval assumptions, and weather assumptions. If those are weak, the output will still look precise, but it won't be trustworthy.

Another problem is missing logic. Teams often link the obvious construction sequence but leave out design approvals, authority hold points, procurement release dates, access restrictions, or commissioning prerequisites. The result is a schedule that looks buildable but isn't.

A third issue is overconfidence in a single critical path. On paper, one path may control completion today. In reality, a near-critical path may be one delay away from taking over.

What to do instead

The smarter approach is to treat CPM as one tool, not the whole answer. A more nuanced view is reflected in Harvard Business Review's discussion of the ABCs of the critical path method, which points to cost and schedule trade-offs and helps explain why CPM should be supplemented when durations are uncertain.

Use practical safeguards:

• Add risk thinking early. Where durations are uncertain, don't pretend they are fixed facts. Flag assumptions and review them regularly.
• Use rolling-wave planning. Keep near-term work detailed and realistic. Leave later work at the right level of certainty until information improves.
• Check resource reality. A valid logic path can still fail if the same crew, crane, or engineer is assumed to be in two places at once.
• Review near-critical work. Don't wait until a second path becomes critical before managing it.

A polished schedule can still be wrong. Logic quality beats presentation quality every time.

Used properly, CPM is strong. Used carelessly, it gives false confidence. That isn't a flaw in the method. It's a modelling failure.

CPM vs PERT vs Gantt Charts

Project teams often use these terms as if they are interchangeable. They aren't. Each does a different job.

CPM is best when you need to determine the controlling sequence of work and understand which tasks drive completion. PERT is more useful when durations are uncertain and you want a planning method that reflects that uncertainty. A Gantt chart is primarily a visual timeline. It can display critical path information, but it is not the same thing as the method that calculates it.

CPM vs PERT vs Gantt Chart

Which one should you use

In practice, most construction teams don't choose one and ignore the others.

They usually:

• use CPM to build the schedule logic
• present that schedule in a Gantt chart for reporting and site communication
• borrow PERT-style thinking when durations are highly uncertain, especially in early planning or high-risk work packages

That combination is usually stronger than rigid loyalty to one format. The main thing is knowing what each tool is for.

If your project has firm dependencies, multiple trades, procurement interfaces, and a contractual completion date, CPM should be at the centre of schedule control. If your durations are highly variable, supplement it. If you need to show the plan clearly to the team, a Gantt view helps. Just don't mistake the picture for the analysis.

Doclio helps construction teams keep the information behind the programme aligned with what's happening on site. With Doclio, teams can manage drawings, revisions, approvals, field markups, and project documents in one place, so schedule conversations are tied to the latest project information rather than outdated files and scattered email chains.

That's why a letter of transmittal matters. On a large capital project, it isn't admin for admin's sake. It's the formal handover record that tells the next party exactly what is being issued, why it is being issued, and what they're expected to do with it. If you treat it like a casual cover email, you'll create ambiguity. If you treat it like a control point, you'll prevent a lot of rework.

New project engineers often focus on the attached drawing, report, submittal, or response. Experienced document controllers focus just as hard on the wrapper around it. The wrapper is what makes the issue traceable.

Table of Contents

• What a Letter of Transmittal Is and Why It Matters
  • Why email alone doesn't hold up
  • The risk management function
• The Core Components of an Effective Transmittal
  • The non-negotiable fields
  • What the wording should do
  • Where new engineers go wrong
• Common Transmittal Variations in Construction
  • Tender submission versus shop drawing issue
  • RFI responses and revised drawings
  • External stakeholders and formal acceptance
• Annotated Examples and Ready-to-Use Templates
  • Example one revised architectural drawings for construction
  • Example two material submittal from a subcontractor
  • Copy and paste template
• Modernising Transmittals with Digital Document Control
  • What goes wrong in manual workflows
  • What a digital system changes
  • The practical standard to aim for
• Best Practices for Routing Compliance and Traceability
  • Set routing rules before the pressure starts
  • Make version naming match the transmittal record
  • Build an audit trail that survives personnel changes
  • Use transmittals to support compliance, not just communication
• Conclusion The Transmittal as a Project Control Tool

What a Letter of Transmittal Is and Why It Matters

A letter of transmittal is the formal front page that sits before a report, drawing package, submittal, or other project document. In Australian-facing business writing guidance, it's treated as a short, formal business letter that explains what is enclosed, why it's being sent, and what the recipient should do next. That guidance also stresses that it should be brief, usually no more than one page, often organised into about three short paragraphs, with the date and recipient details in standard business-letter format, as outlined in Lumen Learning's letter of transmittal guidance.

In construction, I explain it to new engineers as the packing slip for project information. The attachment is the product. The transmittal is the formal record of delivery.

Why email alone doesn't hold up

An email can carry files, but it usually fails as a control document. Subject lines are inconsistent. Attachments get stripped out in forwarding. People reply on old threads. Someone saves the files locally and renames them. Six months later, the project team can't reconstruct the exchange cleanly.

A proper transmittal fixes that by answering the essential questions up front:

• What was sent
• Who sent it
• Who received it
• Why it was sent
• What action is required

Those five points sound basic. They're also what people argue about when a project goes off track.

Practical rule: If a third party can't understand the issue without opening the attachment, the transmittal is too thin.

The risk management function

The mistake beginners make is assuming the letter of transmittal is just etiquette. It isn't. It reduces ambiguity and creates an auditable trail. That matters when you're issuing design revisions, forwarding subcontractor submittals, responding to RFIs, or sending material for approval.

On live projects, the difference between “sent” and “formally transmitted” is significant. A casual message says communication happened. A controlled transmittal shows exactly what moved through the workflow.

Here's what works in practice:

• Use transmittals for formal exchanges: drawings, reports, calculations, submittals, manuals, and contractual correspondence.
• Keep the message lean: enough context to remove doubt, not a second report.
• Make action explicit: for review, for approval, for information, for construction, or for record.
• File the transmittal with the attached package: never separate the wrapper from the content.

What doesn't work is sending critical project information with no register, no revision reference, and no stated purpose. That's how teams end up building from superseded information while everyone thinks they're covered.

The Core Components of an Effective Transmittal

A good transmittal is short, but it's never vague. For formal reporting and project documentation, guidance from MIT aligns around a concise structure. It's typically one page and around three paragraphs. The opening identifies what is enclosed and why, the middle gives a brief overview only, and the close requests follow-up or offers contact details. The letter sits before the report as a separate page, as described in MIT's guidance on letters of transmittal.

That structure works well on construction projects because it keeps the communication fast while preserving the metadata that makes the package clear.

The non-negotiable fields

If any of these are missing, the transmittal is weaker than it should be.

What the wording should do

The wording doesn't need to be clever. It needs to be exact.

A weak purpose line says: “Please see attached.”

A strong purpose line says: “Please find enclosed revised structural drawings issued for review.”

A weak action line says: “Let us know your thoughts.”

A strong action line says: “Please review and return comments through the submittal workflow.”

Keep the narrative short. The register carries the detail. The body text carries the intent.

Where new engineers go wrong

Most transmittal mistakes aren't formatting errors. They're control errors.

• They describe the package loosely: “latest drawings” is not a document list.
• They omit revision identifiers: that invites people to compare the wrong files.
• They bury the required action: recipients then treat an approval package as information only.
• They overload the letter: the transmittal becomes a mini-report and no one reads it properly.

A reliable mental checklist is simple. Can an auditor, contract administrator, or replacement team member understand the handover without guessing? If yes, the transmittal is doing its job.

Common Transmittal Variations in Construction

A generic template is fine for office training. It's not enough for project delivery. The content of a letter of transmittal should change with the use case. Discipline-specific practice shows that transmittals can accompany very different types of material, including regulatory submissions, technical reports, and signed-and-sealed drawing sets. That's why one universal template often fails in real workflows, as noted in this discussion of how transmittals vary by use case.

On a construction project, the shift in purpose changes what the transmittal needs to emphasise.

Tender submission versus shop drawing issue

A tender transmittal is formal and controlled. It usually emphasises completeness, submission identity, and the fact that the package forms part of a commercial or contractual process. The tone is restrained because the exchange may be scrutinised later.

A shop drawing transmittal is more operational. It needs to show the subcontractor, package reference, revision status, and required review path. The critical point is routing. Who reviews first, and what status can they assign?

Here's the practical comparison:

RFI responses and revised drawings

An RFI response transmittal should be quick to read. The recipient usually wants one thing answered. The transmittal should point directly to the RFI number, the attached response, and any revised drawing or sketch linked to it.

A revised drawing issue needs stronger version discipline. If you're sending Revision C and Revision B is already in circulation, the transmittal must remove doubt about what is current and what has been superseded. If it doesn't, site teams may keep both sets and use whichever one they find first.

Different packages need different wrappers. If the wording doesn't match the workflow, the record won't either.

External stakeholders and formal acceptance

Some transmittals are internal routing tools. Others are external handovers to clients, authorities, certifiers, or consultants. External issues usually need cleaner language, stronger references, and more disciplined enclosure lists because the receiving party isn't working inside your internal shorthand.

That's where rigid templates break down. A transmittal for a regulatory submission won't read like a subcontractor material submittal, and it shouldn't. Good document control adapts the format without compromising the core record.

Annotated Examples and Ready-to-Use Templates

Templates are useful, but examples are what make the logic stick. Below are two practical models. They're not fancy. They're built the way working teams can use them.

A point many teams miss is that a letter of transmittal isn't always just an introduction. In formal workflows, it can also function as a receipt or acknowledgement of delivery, sometimes with a client signature and even two copies, as discussed in Portland State material on cover letters and transmittal practice. That's especially relevant where chain-of-custody matters.

Example one revised architectural drawings for construction

Scenario: the architect is issuing a revised drawing set for construction after coordinated updates.

Subject: Transmittal of Revised Architectural Drawings Issued for Construction
Project: Central Plant Upgrade
To: Site Project Manager, Head Contractor
Date: [insert date]

Please find enclosed the revised architectural drawing package issued for construction. This issue supersedes the previous architectural issue for the affected sheets and is being transmitted for use in the current construction sequence.

Enclosed documents:

• A-101 Ground Floor Plan Rev C dated [insert date]
• A-201 Reflected Ceiling Plan Rev C dated [insert date]
• A-501 Door Schedule Rev B dated [insert date]

Please distribute to relevant site and subcontractor teams and ensure superseded revisions are removed from active use. If any discrepancy is identified between this issue and previously received documents, advise the design team through the document control process.

Why this works:

• Clear issue purpose: issued for construction
• Specific enclosure register: each sheet listed individually
• Action required: distribute current set and remove superseded information
• Risk control language: directs discrepancies back through a formal path

Example two material submittal from a subcontractor

Scenario: the mechanical subcontractor is forwarding a product data package for review.

Subject: Material Submittal for Review
Project: Hospital Expansion Works
To: Design Consultant via Head Contractor
Date: [insert date]

Please find enclosed the material submittal package for the nominated mechanical equipment item for consultant review. The package includes product data, technical literature, and supporting compliance information relevant to the specification requirement.

Enclosed documents:

• Submittal cover sheet [reference]
• Manufacturer product data [reference]
• Technical compliance statement [reference]
• Supporting certificates [reference]

Please review and return status through the approved submittal workflow. This transmittal does not authorise procurement or installation unless and until the package is returned with the required status.

What makes this stronger is the final line. It prevents a common failure. Teams assume submission equals approval.

Copy and paste template

[Your company letterhead]
Date: [insert date]
To: [recipient name, company, role]
From: [sender name, company, role]
Project: [project name and reference]
Subject: [clear transmittal subject]

Please find enclosed the following documents for [review/approval/information/construction/record]. They are being transmitted in connection with [brief reason].

Enclosures

• [document title, number, revision, date]
• [document title, number, revision, date]
• [document title, number, revision, date]

Please [state required action]. If there are any discrepancies, missing items, or issues with the enclosed documents, please advise through the project document control process.

Regards,
[name]
[position]
[contact details]

Acknowledgement of receipt
Received by: __________________
Name: _______________________
Date: ________________________

Modernising Transmittals with Digital Document Control

Manual transmittals break down for the same reason spreadsheets break down. Too many people touch them, too many copies exist, and nobody is fully sure which record is the authoritative one. On a complex project, the risk isn't only that a file gets lost. It's that the wrong file is treated as current.

In construction document control, a transmittal is more than a cover note. It's the auditable record of what was sent, to whom, and for what purpose, and it can be linked back to budgets, contracts, and change orders to preserve traceability across the project lifecycle. Mastt's construction guidance also recommends generating the transmittal with project details and a document list, then exporting and filing it with related records, as described in Mastt's explanation of construction transmittals.

What goes wrong in manual workflows

I've seen the same pattern repeatedly:

• Attachments drift: one recipient gets the complete package, another gets a partial forward.
• Registers split from files: the transmittal PDF sits in one folder, the drawings in another.
• Revisions become arguable: the team knows a later issue exists but can't prove who received it.
• Approval paths blur: comments come back by email, marked PDF, and phone call, all outside the record.

A manual system can still work. But only if the team is disciplined, the folder structure is rigid, and everyone follows the same naming and filing rules. On large projects, that level of discipline is hard to maintain over time.

What a digital system changes

A proper document management platform turns the transmittal from a document into a workflow event. That's the key shift.

Instead of drafting a letter separately, attaching files manually, sending them by email, and then trying to archive the evidence, the system logs the issue, links it to the exact files, records recipients, and preserves the issue history in one place. That creates a single source of truth.

The best transmittal record is the one no one has to reconstruct later.

That matters when someone asks any of these questions:

• Who issued this revision?
• Was it for review or for construction?
• Which subcontractors received it?
• What was attached at the time of issue?
• Was there any acknowledgement or response?

A digital workflow can answer those questions cleanly because the metadata, attachments, and routing history are tied together.

Here's a short product walk-through that shows how modern construction platforms approach this problem:

The practical standard to aim for

Whether your team uses a dedicated platform or a tightly managed common data environment, the standard is the same. Every formal issue should be searchable, attributable, and recoverable without relying on one person's inbox.

If your current process can't do that, your transmittals are administrative. They aren't yet project controls.

Best Practices for Routing Compliance and Traceability

Most transmittal failures happen after issue, not at issue. The document gets sent, but it doesn't move through the right path, doesn't return with a usable status, or doesn't stay linked to the record that explains it. That's where routing discipline matters.

A strong process combines document control, commercial awareness, and practical site behaviour. You're not just sending information. You're controlling how it enters the project.

Set routing rules before the pressure starts

Don't leave routing to individual judgement on a busy day. Define it in advance.

• Subcontractor submissions: route through the head contractor before consultant review if that's the agreed path.
• Consultant design issues: send to the controlled distribution list, not whoever asked for the file informally.
• Client-facing packages: check contractual addressees and any approval authority before issue.
• Superseding revisions: issue to every party holding the earlier revision, not only the party who requested the update.

Teams often fail here by taking shortcuts for speed. The shortcut then creates an off-register issue that no one can fully defend later.

Make version naming match the transmittal record

Your file naming and your transmittal register should tell the same story. If the transmittal says Drawing S-402 Rev D but the attached PDF has a different filename or an incomplete title, confusion starts immediately.

I tell engineers to treat naming as part of the contractual record, not a drafting preference.

If the filename, register, and title block don't align, someone will trust the wrong one.

Build an audit trail that survives personnel changes

Projects run for long periods. People leave, roles change, and external parties rotate. Your transmittal system has to survive that turnover.

Good habits help:

1. Store the issued transmittal with the exact issued package. Don't keep them in separate informal folders.
2. Capture the purpose clearly. “For review” and “for construction” cannot sit in the same grey area.
3. Retain receipt or acknowledgement where required. This matters for formal handover and disputed delivery.
4. Record superseded status visibly. Don't rely on teams to infer it.
5. Keep comments and responses tied back to the originating issue. Detached review comments weaken the chain.

Use transmittals to support compliance, not just communication

On regulated projects, transmittals often become evidence. They help show that the right document was issued, through the right path, to the right party. That matters in audits, claims, quality reviews, and practical completion handover.

A project engineer usually sees the immediate task. Send the package. Get the review. Move on.

A document controller sees the longer horizon. If a dispute lands months later, the transmittal trail may be the cleanest record the project has.

Conclusion The Transmittal as a Project Control Tool

A letter of transmittal looks simple because it's short. That's exactly why people underestimate it. On construction projects, its value isn't in elegant wording. Its value is in control.

Used properly, the transmittal tells the receiving party what the package is, how it should be treated, and what happens next. More importantly, it leaves a record that can be checked later without guesswork. That's what protects the job when revisions overlap, approvals stall, or someone questions whether an issue was properly made.

The strongest teams don't treat transmittals as clerical output. They use them as part of a disciplined issue process. The document list is exact. The revision status is clear. The routing path is controlled. The resulting record is easy to retrieve and hard to dispute.

That approach saves time, but time saving is only part of it. The bigger win is reduced ambiguity. Fewer arguments about status. Fewer missed actions. Fewer situations where site, design, and commercial teams are each working from a different understanding of the same package.

Digital systems make that standard easier to maintain because they keep the files, metadata, routing, and history together. But the principle is older than the software. Clear communication, clean records, and traceable handover are what keep complex projects under control.

If you're a new project engineer, learn this early. The attachment may carry the technical content. The transmittal is what makes that content usable, defensible, and properly managed.

If you want a cleaner way to manage transmittals, revisions, approvals, and searchable project records in one place, Doclio gives construction teams a single source of truth across drawings and documents without relying on scattered inboxes and folder workarounds.

Security of payment laws matter because they give contractors and subcontractors a statutory path to recover progress payments. But on live projects, that path only works if the records underneath the claim hold up. Late payment is common in Australian construction. The businesses that recover faster usually are not the ones making the biggest noise. They are the ones with dated site records, clear variation instructions, valid service records, and a payment claim that matches the job history.

That is the part many teams miss. Security of payment is tied directly to day-to-day project administration.

If the contract notice was stored in one inbox, the site diary lives in a notebook, delivery dockets are in a ute, and the variation approval sits in a text message, the claim is exposed before adjudication even starts. A workable process is different. Daily records, correspondence, photos, approvals, and claim schedules need to be captured as the job runs, not rebuilt after payment is withheld.

Strong claims are built month by month. The law helps, but the paperwork wins.

Table of Contents

• The High Cost of Getting Paid Late in Construction
  • Cash flow damage shows up on site first
• What Security of Payment Laws Really Mean for You
  • A statutory right that sits beside the contract
  • Who these laws protect
• Your Toolkit for Enforcing Payment
  • Progress claims and adjudication
  • Retention regimes and other practical protections
  • What works and what usually fails
• Practical Steps to Bulletproof Your Payment Claims
  • At the contract stage
  • During project execution
  • Before you serve a claim
• How Digital Workflows Create an Ironclad Evidence Trail
  • Why paper and email chains break down
  • What a defensible digital record looks like
• Your Security of Payment Compliance Checklist
  • Before the project starts
  • During each payment cycle
  • If a dispute arises

The High Cost of Getting Paid Late in Construction

Friday afternoon. Payroll is due, a supplier is asking whether the next delivery should leave the yard, and the progress claim is still sitting with the client team because someone wants backup for a variation raised three weeks ago. That is how late payment hits a job in practice. It does not stay in the accounts inbox for long.

On site, the first signs are usually operational, not legal. Crews get shuffled to better-funded work. Suppliers stop extending favours on lead times. The project team spends its time chasing paperwork instead of closing out instructions, quantities, and approvals while the facts are still fresh.

Practical rule: Late payment is a project control problem before it becomes a legal dispute.

The actual cost shows up in places teams often underestimate. Margin gets eaten by financing pressure and rework in the paperwork. Bargaining position weakens because the party waiting on cash is more likely to accept discounts, defer entitlement, or stay quiet about a defective payment schedule just to keep money moving. Once that happens, the argument is no longer only about what was built. It is about what can still be proved.

Cash flow damage shows up on site first

When a project starts slipping financially, the warning signs are usually easy to spot:

• Supplier strain: Credit gets tighter, staged deliveries get harder to secure, and minor account issues turn into hold points.
• Labour pressure: Supervisors and subcontract crews get distracted when payment uncertainty starts affecting wages, overtime, or resourcing.
• Admin backlog: Site instructions, dockets, variation records, and daily reports stop being chased properly because the team is stuck reacting.
• Weak claims: Entitlements that may have been recoverable become harder to press because the supporting record is incomplete, late, or inconsistent.

That last point is the one many teams miss. Security of payment legislation can give a contractor or subcontractor a path to recover money quickly, but the claim still stands or falls on the documents behind it. If the site diary does not match the variation log, if the delivery records are incomplete, or if the instruction exists only in someone's memory, the payment claim is exposed before it even goes out.

This is why late payment and documentation discipline are tied together. The jobs that recover faster are usually not the jobs with the best arguments in theory. They are the jobs where the team can show, day by day, what work was done, who directed it, what records were issued, and when the other party received them.

What Security of Payment Laws Really Mean for You

Security of payment works best when you treat it as a statutory safety net that sits beside your contract. Your subcontract, purchase order, or consultancy agreement still matters. But if payment is delayed or manipulated, the legislation gives you a separate path to pursue what's due.

Security of payment legislation was first introduced in New South Wales in 1999 and now exists in every Australian State and Territory, creating a statutory right to payment for construction work and invalidating unfair contract terms that hinder cash flow, as outlined in this guide to security of payment in the Australian construction industry.

A statutory right that sits beside the contract

Many payment fights aren't about whether work happened. Instead, they often revolve around one party's strategic advantage. One party knows the other side needs cash flow and uses delay, form defects, or contract wording to hold funds back.

Security of payment changes that balance. The legislation broadly gives eligible parties a right to make progress payment claims for construction work or related goods and services, and it imposes payment timeframes and dispute pathways. It also pushes back against terms that try to shut down that entitlement unfairly.

Think of it this way:

That doesn't mean every claim succeeds. It means the other side doesn't control the field as easily.

Who these laws protect

These laws are built for the commercial reality of construction. They protect participants down the contract chain, including contractors, subcontractors, and suppliers performing work or supplying related goods and services. The wording and mechanics vary across jurisdictions, but the protective intent is consistent.

Security of payment exists because construction businesses can perform real value long before they receive real cash.

For project managers, contract administrators, and commercial leads, the practical meaning is straightforward. You need to know three things on every job:

1. Which Act applies based on the project location.
2. What the timing rules are for claims, schedules, and responses.
3. What evidence is needed to prove the claim was validly made and validly served.

Teams often spend too much time debating legal theory and not enough time locking down process. Most failed claims aren't lost because the work had no value. They're weakened because someone can't clearly show what was done, when it was done, what supported the amount claimed, and how the claim moved through the required channel.

That's why security of payment is as much an operations discipline as a legal remedy.

Your Toolkit for Enforcing Payment

When payment starts to wobble, you need to know which lever to pull and when. Not every issue calls for adjudication. Not every claim should escalate immediately. Sometimes the strongest move is a clean, properly prepared progress claim that leaves the respondent with very little room to dispute form, timing, or scope.

The core tools work differently, and each has trade-offs.

Progress claims and adjudication

A progress claim is your starting point. It's the formal claim for payment tied to the work completed, goods supplied, services provided, approved variations, or other contractual entitlements that are claimable under the applicable regime.

A strong progress claim does four jobs at once:

• States the amount claimed
• Identifies the work or basis of entitlement
• Complies with contract and statutory form requirements
• Creates a record that can support escalation if needed

An adjudication is different. It's the fast-track dispute mechanism used after a payment dispute has crystallised under the relevant legislation. It isn't casual correspondence with extra legal language. It's a structured process with short deadlines, detailed submissions, and a decision-maker who will usually work from the documents placed before them.

Here's the practical comparison:

If your records are loose, adjudication can punish you quickly. If your records are organised, it can force a stalled payment issue into a defined process.

Retention regimes and other practical protections

Depending on the jurisdiction and project setup, you may also be dealing with retention money regimes, project trust structures, or other statutory account and fund-handling obligations. These aren't interchangeable with a payment claim, but they matter because withheld funds and poor fund administration can create a second layer of commercial risk.

From a project controls perspective, treat these as evidence-sensitive areas. Keep clear records of:

• Amounts withheld
• Contract basis for retention
• Dates of withholding and release
• Any notices or account records tied to the retention regime

Don't rely on someone in accounts to reconstruct this later from ledger notes. If a retention issue turns contentious, the commercial team will need project-side records that match the financial records.

What works and what usually fails

The most effective enforcement approach is rarely the most aggressive one. It's the one that is hardest to attack on process.

What works:

• Claims tied to identifiable work fronts
• Supporting records attached at the time of claim
• Variation evidence linked to instructions and pricing history
• Service records that show exactly when and how the claim was sent
• A consistent narrative across site diary, programme, correspondence, and claim documents

What fails:

• Backfilled records created after the dispute starts
• Loose variation language such as “as discussed on site”
• Competing versions of the same attachment
• Claims sent through the wrong channel
• Teams assuming merit will overcome non-compliance

Commercial lesson: If the other side can turn your payment claim into an argument about process, they've already improved their position.

One more practical distinction matters. Security of payment is not the same as payment security in the PCI sense. If your business also handles card-present or browser-based transactions, PCI-aligned controls require regular scanning, testing, wireless access point checks, and payment page tamper detection, as summarised in this PCI DSS overview. That's important for transaction security, but it won't rescue a construction claim that lacks approval history, service evidence, or document provenance.

For construction teams, the payment battle is usually won or lost in the project file.

Practical Steps to Bulletproof Your Payment Claims

Most payment claims don't fall over because the work wasn't done. They fall over because the entitlement can't be proved cleanly enough under pressure. For smaller subcontractors and suppliers in particular, security of payment is less about fraud controls and more about documented evidence, especially in a sector with persistent insolvency risk, as noted in this discussion of secure payments for your business.

At the contract stage

Before work starts, read the contract like someone who expects a payment dispute, not like someone eager to mobilise.

Check these items first:

• Reference dates and claim dates: Make sure the team knows exactly when claims can be made.
• Notice requirements: Variations, delay notices, and claim notices often have separate triggers.
• Service requirements: Email may be allowed, or it may not. Named recipients matter.
• Supporting document requirements: Some contracts require breakdowns, statutory declarations, or specific annexures.

A practical contract review meeting should include the PM, CA, and site lead. If only the commercial team understands the notice regime, site records will drift out of alignment within weeks.

The best time to prepare for adjudication is before the first toolbox talk, because that's when you can still shape the record-keeping habits that decide the dispute.

A few habits help immediately:

1. Build a claim calendar for the project.
2. Create variation numbering rules before the first instruction lands.
3. Agree who can issue, approve, and receive formal notices.
4. Lock a document naming standard that works across site and office.

During project execution

Most claims are strengthened or weakened by their practical execution. Daily administration sounds dull until the payment schedule arrives and the respondent says the work wasn't instructed, the variation wasn't approved, or the value can't be tracked.

The file you want is simple to use and hard to challenge.

Records that matter most

• Daily site records: Labour, plant, areas worked, weather impacts where relevant, and key events.
• Photographic evidence: Dated, identifiable, and linked to location or work package.
• Instructions: Emails, meeting minutes, RFIs, site directions, and marked-up drawings.
• Variations: Scope change, pricing basis, approval status, and any provisional direction to proceed.
• Delivery and supply records: Dockets, receipts, and confirmation of incorporation where needed.
• Communications trail: Who said what, when, and in response to which issue.

Not every record carries equal weight. A signed instruction or traceable approval usually beats a recollection in a meeting note. A dated photo linked to a drawing location is stronger than a folder of unnamed site images. A variation register that matches the claim line items is far more persuasive than a spreadsheet maintained only at month end.

What project teams should stop doing

Some habits create avoidable holes:

• Using personal phones with no upload discipline
• Approving changes verbally and assuming trust will carry the day
• Saving final files as “latest”, “latest2”, or “use this one”
• Leaving subcontract claims support in individual inboxes
• Treating site diaries as a compliance task instead of evidence

If the record lives in five inboxes, two WhatsApp threads, and a ute glovebox, it isn't a record. It's a future argument.

Before you serve a claim

Do a pre-issue check. Not a legal memo. A practical audit.

Ask these questions:

If one answer is shaky, fix it before service. Teams often rush the claim because they're focused on the due date. That's understandable, but a fast defective claim is usually worse than a carefully prepared one served correctly within time.

How Digital Workflows Create an Ironclad Evidence Trail

At 4:30 pm on claim day, the contract administrator asks for the instruction that supports a disputed variation. The site team has a photo on one phone, a markup in an email thread, a revised drawing in a downloads folder, and a supervisor who remembers the conversation but did not record it. That is how payment claims start to come apart. Not because the work was not done, but because the record is fragmented.

Security of payment law rewards teams that can prove sequence, authority, scope, and service with clean records. In practice, that means the job is won or lost long before adjudication. It is won in the daily habit of capturing instructions, tying them to the right drawing revision, recording who approved what, and keeping the claim pack consistent with the project record.

Why paper and email chains break down

The common failure is loss of continuity.

A PM gets an instruction by phone, confirms it by email, attaches a markup from a tablet, then receives a revised PDF through another thread. Site builds from version B. Commercial prices version A. The claim goes out with version C because that is what sat in the folder at month end. Once authority, scope, or timing is challenged, the team is arguing about record quality instead of payment entitlement.

Digital workflows help only when they preserve context, not just files. The system needs to show where a document came from, who touched it, what changed, and what record supports the claim line item. If it cannot do that, it is a storage tool, not an evidence system.

A workable setup should support:

• Version control for drawings and claim documents
• Structured approval paths for variations and site instructions
• Time-stamped activity history
• Searchable communications tied to the relevant record
• Controlled sharing with consultants, principals, and subcontractors
• Clear links between claim items, source documents, and completion evidence

A claim is easier to enforce when each attachment has a visible origin, a revision history, and a record of who issued or approved it.

Data discipline matters too. Keep claim evidence in the systems your team controls and can audit. Do not spread key records across personal devices, chat apps, shared drives, and inboxes unless you are prepared to explain the gaps later.

What a defensible digital record looks like

A defensible record lets the team answer dispute questions fast and with documents that line up:

• What was instructed?
• Which drawing revision applied at the time?
• When was the variation priced and submitted?
• Who approved it, or who received the request for approval?
• What evidence shows the work was done?
• Which exact documents were served with the claim?

Construction document control platforms can support that standard if they centralise drawings, registers, approvals, and field records in one controlled workflow. Doclio, for example, includes versioned drawings, linked documents, structured approvals, and an AI Assistant that can help locate project records and compare plan changes. Used properly, that kind of setup does not replace legal advice. It gives the team a cleaner evidence trail from instruction to execution to claim.

The trade-off is simple. Digital systems demand discipline up front. People need to upload records on time, use the right workflows, and stop treating email as the master file. But that effort is minor compared with the cost of rebuilding a claim from scraps after a dispute starts.

Build the evidence trail while the work is happening. Reconstruction after relationships deteriorate is slow, expensive, and often incomplete.

Your Security of Payment Compliance Checklist

A payment claim usually fails long before adjudication. It fails on site, in the contract review, in the way instructions are recorded, or in the scramble to pull attachments together at the end of the month. Teams that get paid consistently do the routine work early and do it the same way every time.

Before the project starts

• Review the contract carefully: Confirm claim dates, notice periods, service requirements, and required supporting documents.
• Map the governing legislation: Identify which jurisdiction's security of payment regime applies.
• Assign formal responsibilities: Decide who issues notices, who maintains registers, and who signs off claim support.
• Set up the record system: Use one controlled workflow for drawings, instructions, variations, and claim attachments.

During each payment cycle

• Update site records daily: Keep labour, plant, progress, and event records current.
• Capture variation evidence immediately: Link instruction, scope change, pricing, and approval status.
• Check version integrity: Make sure the documents attached to the claim are the current and correct ones.
• Serve claims properly: Use the required channel, recipient, and timing every time.

If a dispute arises

• Freeze the evidence set: Preserve the exact documents, communications, and versions relevant to the claim.
• Build a chronology: Put events, instructions, submissions, and responses in date order.
• Match every amount to proof: Each line item should point to a document trail.
• Act quickly on statutory deadlines: Delay is often more damaging than the original underpayment.

Security of payment laws reward disciplined contract administration. The parties with the best records are usually the parties in the strongest position. If your team can show what changed, when it changed, who received it, and how the amount was calculated, the claim is harder to dismiss and easier to enforce.

That is the day-to-day link many contractors miss. The legal right to claim only gets you so far. The outcome often turns on whether your project documentation is organised, current, and traceable from site instruction through to formal service.

If your projects still rely on inboxes, shared drives, and scattered PDFs to support payment claims, Doclio is one practical document control option. It centralises drawings, documents, approvals, and field collaboration so the team can maintain a cleaner evidence trail from instruction through to claim.

What shipped

Save for offline. Pin a whole project with one button. Doclio downloads its drawings, images and annotations to your device and keeps them current whenever you reconnect. Pinned projects show a green ⬇ SAVED OFFLINE badge in the header so you know what's ready.

Per-file pins. Don't need the whole project saved? Open any drawing and click the ⬇ icon in the viewer header. That single file is saved locally, the rest streams as usual.

Install as an app. Doclio is now a full Progressive Web App. On iOS, tap the share icon and "Add to Home Screen". On Android or desktop Chrome, you'll see an install prompt. Launched this way, Doclio runs in its own window — no browser chrome, no tabs to lose, opens in two seconds.

Automatic delta sync. When you come back online, Doclio checks for new drawings or revisions on your pinned projects and quietly downloads the diffs. A small chip in the corner shows progress. No manual refresh, no full re-download.

Passive caching. Every drawing you view while online is automatically cached for 30 days. So even without pinning, the last set you opened is usually still there when signal drops.

What works offline

• View drawings you've pinned or opened while online
• View annotations, comments and attachments
• Review revision history on pinned projects
• Open cached reports
• Navigate between drawings, groups, tags and projects

What doesn't (yet)

Offline mode is read-only and changes are not queued — wait until you have signal before editing. These need a connection:

• Creating or editing annotations
• Posting comments or uploading attachments
• Uploading new drawings
• Approvals
• Using the AI assistant
• Opening drawings you haven't viewed or pinned, and large files (point clouds, videos) unless you marked them to sync

When you reconnect, a red banner drops from the top so you know what hasn't synced.

Storage management

Each pinned project shows a size estimate. A new Offline tab in Settings lists everything you've cached, a storage-usage bar against your device quota, and a one-click "Clear all offline data" button if you ever need to reclaim space. Large files — videos, point clouds, huge CAD exports — are excluded from pins by default to keep things light. You can opt them in per-file if you really need them on the device.

How to try it

1. Open any project.
2. Click the ⬇ SAVE FOR OFFLINE button in the project header.
3. Go to Settings → Offline and check the green size bar grow.
4. Switch your phone to airplane mode and re-open Doclio — it's all there.

Offline Mode works on every Doclio plan. If you have issues, visit docl.io/?kill-sw=1 to reset everything cleanly. You can also contact support to get assistance

---

Offline mode is a v1 release. Write-while-offline queueing and background sync are on the roadmap. Tell us what you'd like us to prioritise next.

What shipped

Token-based approval pages. Add anyone as an approver on any annotation. Doclio generates a magic link and emails it through your org's branding. When they click through, they see the annotation in context, the drawing preview, existing comments and attachments, and a clean APPROVE / REJECT panel — all without signing in.

Attachments from approvers. External reviewers can upload supporting files (photos, marked-up PDFs, spec sheets) alongside their decision. Uploads are rate-limited and scoped to the approval token, so there's no risk of credential-free write access to the rest of your project.

Approver comments promoted to the record. When an approver responds, their decision is saved as a permanent [Approved] or [Rejected] comment on the annotation, signed with their email. The audit trail survives every future revision.

Resend + reminder button. If someone hasn't responded, the pending-approver row in the Drawing Viewer now shows a one-click resend. No need to re-add them.

Multi-drawing shares. Need a client to review a subset of your project? Share specific drawings rather than the whole project — one invite, one link, the client sees only what you selected. Works for tagged or hand-picked drawing groups.

Why it matters

Most construction approval tools still require your external stakeholders to sign up, verify email, set a password, then learn a new UI just to click APPROVE. That friction kills response times.

Doclio's token flow means your project engineer, local authority contact, or client-side PM can respond from their phone while stuck in traffic. No app, no login, no fuss. You still get the full audit trail: who approved, when, from which IP, with what comments or attachments.

Security posture

Approval tokens are single-annotation and scoped. A token lets the holder view the annotation, drawing preview, and add a decision — nothing more. Uploads are capped at 25 MB per file and 10 uploads per hour per token. File types are allowlisted. The whole flow runs on a dedicated anonymous Supabase client so a logged-in user's session never interferes with the anonymous RLS policies.

How to try it

1. Open any drawing and create an approval-type annotation (or convert an existing one).
2. Click ADD APPROVER and enter an email.
3. Doclio sends the branded invitation automatically.
4. You'll see their response land back in the annotation the moment they click APPROVE or REJECT.

---

External approvals are available on every Doclio plan. Start a free project to send your first approval in under two minutes.

What's new

Automatic revision comparison. When a new revision lands, Doclio renders both pages, sends them to the Doclio AI, and saves a structured summary — categorised as design changes, title block only, or no changes. Ask the assistant "what changed in the latest revisions?" and it pulls the cached answer instantly, no re-rendering, no wait.

Drawing-aware chat. Ask about your project in plain English. "What are my overdue RFIs?"  "Find the annotation about the slab reinforcement." "Who's approved the latest cladding drawings?" The assistant answers using your real project data and links back to the specific drawing or annotation it pulled from.

Pro mode. For sheets where a standard comparison isn't enough, flip the Pro mode toggle. Doclio runs a more thorough investigation on the pair, plus a pixel-level diff overlay, catching subtle changes a default scan might miss.

Web search fallback. When the assistant can't find something in your data or knowledge base, it offers to search the web , returning results with source links so you can verify. If the install manual for the oven is not in your project, the electrician can use the model number from your drawings to find a result on the web. 

Search Support for free: Doclio knows when you are asking for support. The assistant can answer any questions about using the app too. Support questions are not counted against your AI credits.

Why it matters

Projects contain weeks, months or even years of information. Sorting through the stack of drawings and documents can be time consuming and often lead to errors and oversights because of outdated information or sheer information overload. The AI assistant can assist your team in finding the relevant information when they need it

Revision reviews are the single most time-consuming  job on most jobs. Go from hours of manual overlay work (or being overlooked)  to fifteen minutes of spot-checking the sheets the AI flagged as design changes. Title-block-only updates get filtered out automatically, so your team isn't chasing ghost changes.

Credits, not seats

Every Doclio plan includes a monthly AI credit grant — 20 a month on Starter (60 in your first month) through 10,000 on Professional, unlimited on Enterprise. Text questions cost 1 credit. A standard revision comparison costs 3 credits per drawing pair, a Pro mode (deep dive) comparison 15. Cached lookups are free. 

You can also ask the assistant for help with the app, and all support queries are free.

If you burn through your monthly allocation, top-up packs are available as one-time purchases from Settings → Billing → AI Credits. No subscription add-on, no surprise bills.

How to try it

1. Open any project and click the lightbulb icon in the top-right corner to open the assistant  (AI Assistant), or if you're logged in, click the AI assistant on this page.
2. Ask it something about your project — "what's overdue?", "summarise recent revisions", "find annotations about waterproofing".
3. Watch the credit balance in the header. It turns amber when you're running low so there are no nasty surprises.

The assistant is available on every Doclio plan, including the free Starter tier. If you haven't tried it yet, open your project and give it a question — you'll see why it's become our most-used feature.

---

This article skips the hype and focuses on where AI is actually earning its keep in construction today. What's working, what isn't, and how to pilot it on a live project without breaking workflows that already function. It's written for working project managers, estimators, site leads and builders — not for conference-keynote audiences.

The state of AI in construction, honestly

Two broad categories of AI are relevant to construction work.

Multimodal large language models (Claude, GPT, Gemini) — the general-purpose models that can read drawings, answer questions, summarise documents, draft emails, and so on. These are where most of the recent progress has come from. The step change over the last 18 months is that they can now look at a rasterised drawing and reason about what they see, not just read the text layer.

Specialist construction ML tools — narrower systems trained on specific construction data. Object detection for takeoffs, computer vision on site cameras for progress and safety monitoring, predictive models for scheduling or cost overruns. These have been around longer but are often more brittle outside the exact scope they were trained on.

Most working AI in construction today combines the two: a specialist layer for detection/classification, a general-purpose LLM for reasoning and user interaction.

Seven jobs where AI is already working

1. Drawing revision comparison

Arguably the most mature AI workflow in construction right now. Vision models can look at old and new revisions of the same sheet and produce a structured summary of what changed — and, critically, categorise changes (design-impacting vs title-block-only) so the team can triage. On big consultant packages this turns a five-hour review into a fifteen-minute spot-check.

This is working today, it's cost-effective (fractions of a dollar per drawing), and the accuracy is high enough to trust as a first pass. It's still a first pass — a senior reviewer signs off — but the time savings are real.

2. Drawing-aware project search

Natural language Q&A over your project data. "Find all overdue RFIs." "What did the consultant change in Rev C of the hydraulic set?" "Show me the approval status of the lobby details." Grounded against your actual drawings and annotations, these queries now return answers in seconds.

The keyword is "grounded". A generic chatbot without project context will guess. A properly-built project assistant will cite the specific drawing or annotation its answer came from, and should refuse to answer when it can't find relevant data.

3. Automatic drawing classification on import

When a consultant sends a bundle of 200 PDFs with drawing numbers hidden in title blocks, the fiddliest part of the upload is keying in numbers, titles and disciplines. Vision models now do this well enough to pre-fill 70–90% of the fields, leaving you to review rather than transcribe.

4. RFI drafting and summarisation

Not replacing the RFI process — accelerating it. AI is good at turning three bullet points into a properly-structured RFI with the right context, and at summarising long RFI threads into a decision log. Still needs a human approver, but saves meaningful time.

5. AI takeoffs (in specific scopes)

Dedicated tools (Togal, Kreo, Stack) now do credible first-pass takeoffs for scopes where symbols are standard and drawings are clean. Fixture counts, door/window schedules, straightforward linear measurements — real time savings here. Complex services drawings and non-standard symbology still struggle. See the AI takeoffs article for a fuller take.

6. Site photo analysis and progress tracking

Computer vision on site imagery to monitor progress, detect safety violations (missing PPE, unsafe scaffold), and match built work to the drawings. Works well on repeat scopes (high-rise floor plates, modular builds), weaker on bespoke work.

7. Schedule risk prediction

ML models trained on historical project data to flag tasks that are likely to run late. Useful on large, data-rich projects with thousands of similar historical tasks. Less useful on smaller or more bespoke jobs where the model can't generalise from few examples.

Seven jobs where AI isn't ready (yet)

It's as important to be clear about this as the positive list, because overreach is what burned a lot of early AI pilots.

1. Anything safety-critical that stands alone. Egress compliance, structural adequacy, fire sizing — AI can assist a qualified engineer but cannot replace them.
2. Contract drafting and legal language. Generative models produce plausible but often wrong contract clauses. Don't use them as primary drafting.
3. Cost estimating at final pricing stage. Takeoffs for bid/no-bid decisions, fine. Final tendering without a human estimator reviewing line by line, not yet.
4. Regulatory interpretation. Building codes, standards interpretation — the LLM will give you a confident answer that's subtly wrong. Use it for drafting, not for decisions.
5. Negotiating with people. Claims, variations, disputes — these are human conversations that depend on relationship and context AI doesn't have.
6. Generating construction drawings from scratch. Design generation is active research. Generating a buildable set of plans from a brief isn't a product yet; treat anything marketed that way with scepticism.
7. Autonomous site robotics. Autonomous layout, autonomous demolition, autonomous bricklaying — real research, not mainstream production. A few niche products are emerging; most are pilots.

How to introduce AI without breaking your workflow

Teams that succeed tend to share a few habits.

Start with one workflow. Pick the single highest-pain, highest-frequency task and pilot AI there. Usually that's either revision comparison (if you deal with lots of drawings) or RFI management (if you deal with lots of questions).

Keep humans in the approval loop. For anything that affects cost, compliance or contract, the AI's output is an input to a human decision, not the decision itself.

Measure cycle time, not accuracy. Accuracy debates are endless. The honest question is "did this AI tool reduce the time to complete workflow X?" If yes, keep it. If no, bin it.

Pay attention to data governance. Which model is being used? Where is your data processed? Does the vendor retain it? Does it train on it? For most commercial work, cloud-hosted models are fine. For secure or government work, those questions matter a lot.

Don't build on the cutting edge of the cutting edge. The tool that just shipped last week isn't the one to bet a project on. Wait for at least a couple of months of real-world use before committing a live job.

How Doclio uses AI

We're opinionated about where AI fits and where it doesn't. Two places in Doclio use AI today.

Drawing revision comparison. When you upload a new revision, Doclio runs a Claude Sonnet vision model over the old and new sheets in the background and pre-computes a structured summary of what changed. Results are categorised as "design changes" versus "title block only" so you can triage quickly. Because it's cached at import time, the comparison is instantly available when you open the drawing.

Drawing-aware AI assistant. A chat assistant that answers questions about your project using your actual drawings, annotations, and reports. Grounded in your project data with a Supabase-authenticated scope, it cites back to the specific drawing or annotation it used. When it can't find the answer in your project or our knowledge base, it can optionally search the web (via Tavily) and cite sources. Built on Claude Haiku 4.5 for text queries.

Both run on a monthly credit system so you're not paying for AI you don't use.

What we don't claim to do:

• Generative design.
• Autonomous site operations.
• Financial forecasting.

We focus AI on the two places it reliably pays back — reading drawings and answering project questions — and leave the rest to specialist tools.

What's next

The interesting frontier over the next 12–18 months is in workflow automation: AI not just answering questions, but taking actions on your behalf. "Draft an RFI about this detail and send it to the architect." "Update all open defects on Level 2 and generate a punch report." "Compare this new revision and notify the trades whose scope is affected."

The underlying model capability is already there; the constraint is product design — making sure AI actions are transparent, reviewable and reversible. That's the next wave, and it's close enough that teams should be building the muscle now, not in two years.

---

Try Doclio's AI features on a free project — drawing revision comparison and the AI assistant are included on every plan, starting from Starter.

Construction projects usually have a variety of roles: Clients, Designers, Contractors and other Stakeholders. Different roles have different requirements and often the tools for one group aren;t relevant to another. Too many tools can lead to information overload and can act as a barrier rather that a solution.

This article walks through where Procore is the right choice, where it isn't, and how Doclio compares on the features that matter most to smaller and mid-sized teams.

What Procore is good at

Let's be fair before we talk about alternatives. Procore's strengths are real:

• Breadth. Procore covers drawings, RFIs, submittals, finances, scheduling, quality & safety, bidding, labour productivity, and a lot more, all in one platform.
• Enterprise integrations. Deep integrations with accounting (Sage, QuickBooks, Foundation, Viewpoint), ERP, HR systems and most of the construction stack.
• Financial controls. Cost management, budgets, change orders, commitments, invoicing — this is where Procore really pulls away from simpler tools.
• Compliance and reporting. Strong reporting for regulated environments and a long track record with large contractors.
• Ecosystem. Trained users, certified implementation partners, conference circuit, big customer community.

If you're a $50M+ contractor running multiple concurrent enterprise projects, Procore's features are probably what you need.

Where teams look for a Procore alternative

Five recurring reasons teams start shopping.

Cost. Procore's typical pricing is tied to annual construction volume and runs into tens of thousands (sometimes hundreds of thousands) per year. For a small or mid-sized builder with $5–50M in annual revenue, that's a significant line item relative to what gets used.

Complexity. Procore has a lot of modules. Most teams don't use most of them. The UI reflects that surface area, and the onboarding curve reflects the UI. Most subcontractors don't have time to learn a new another tool (or do yet another induction!)

Per-user licensing for viewers. Traditionally, everyone who wants access is a user. For teams that want to invite clients, certifiers, subbies and consultants on light-touch bases, that model gets expensive fast.

Implementation and admin overhead. Rolling Procore out across an organisation is a project in itself. Many smaller teams don't have an operations person whose job is to configure and maintain the platform.

AI is early. Procore has announced AI initiatives (Procore Copilot, etc.) but at the time of writing, AI features in Procore are more limited. For teams that want AI-first workflows today, the gap is noticeable.

How Doclio is positioned differently

Doclio isn't trying to be Procore. It deliberately focuses on a narrower set of jobs:

• Managing drawings and their revisions with proper supersession and approval trails
• A rich annotation system with typed pins — Note, Query, Issue, Alert and Approval — configurable per project
• External approvals via token-based email links (no login needed for approvers)
• Reports for punch lists, RFIs and inspections that can be shared live or as static snapshots
• AI for project based infomation, available to everyone (based on their permissions) and drawing revision comparison and drawing-aware Q&A
• Unlimited free viewer seats on every plan

What it deliberately doesn't try to do:

• Financial cost management / invoicing / commitments
• Scheduling / Gantt charts
• Labour productivity tracking
• Bid management
• Full ERP integration
• Detailed takeoffs and estimating (yet). Doclio has basic measurement like distance and area, and export

If your needs span financial management and scheduling inside the same platform, Procore (or a combination of Procore + specialist tools) is probably still the right answer. If your needs are centred on drawings, annotations, collaboration and reporting, Doclio is designed for that job specifically and prices accordingly.

Feature-by-feature comparison

The honest way to read this: Procore is a broader, deeper, more expensive tool; Doclio is a narrower, simpler, substantially cheaper tool. Neither description is a complaint. They're aimed at different teams.

When to stay on Procore

• You need integrated cost management alongside drawings. Doclio doesn't do this.
• You're running large enterprise projects with regulated reporting and multi-module workflows spanning finance, safety, quality and schedule.
• You have a mature Procore implementation that your team is already trained on. The switching cost is real.

When Doclio is the better fit

• You're a small to mid-sized builder, consultant, or specialist subcontractor where Procore's price feels disproportionate.
• You want to share project information to anyone, witout having to pay more for each user
• Your core pain is drawing management — revisions, annotations, approvals, reports — rather than financial management.
• You want AI features working today, not on a roadmap.
• You want clients, certifiers and external reviewers on every project without paying per seat.
• You want to get a project running today, not in three months' time after implementation.

Pricing comparison (rough guide)

Procore doesn't publish pricing; it's negotiated per customer. Public references suggest entry-level Procore contracts generally start in the tens of thousands per year and scale with construction volume.

Doclio publishes pricing on the pricing page. The common tiers:

• Starter — free forever. 1 active project, 20 drawings, 200 MB storage, unlimited users.
• Growth — $29/month billed annually. 5 active projects, 200 drawings, 1 GB storage, 300 AI credits/month, unlimited users.
• Business — $69/month billed annually. 15 active projects, 750 drawings, 10 GB storage, 1,200 AI credits/month.
• Professional — $199/month billed annually. 50 active projects, 3,000 drawings, 100 GB storage, 4,000 AI credits/month.
• Enterprise — $2,499/month billed annually, unlimited everything.

For most small and mid-sized teams, the monthly Doclio bill is less than Procore's per-user licence for a single seat.

Try it parallel

The low-risk way to decide is to keep Procore (or whatever you're on now) and run a single live project in Doclio in parallel for a project or two. Drawings, RFIs, defects, approvals — all on one job. Compare how your team actually uses both. If Procore is doing things Doclio can't and you need those things, that's your answer. If the opposite is true, that's your answer too.

---

Start a free Doclio project — no credit card, no implementation, no trial. Bring your drawings, invite your team, and see where we fit.

Document control is the least glamorous discipline in construction management and one of the most financially significant. This article walks through what document control actually means, the five principles that matter in practice, and how to build it into a real workflow without adding so much friction that people just go around it.

What document control is (and isn't)

Document control is the set of processes that make sure the right version of the right document reaches the right person at the right time, with a clear trail of who approved it, when, and against what.

It is not filing. Filing is where documents go to die. Good document control is actively pushing current documents to the people who need them, suppressing the ones that have been superseded, and keeping a clean approval and audit trail.

It applies to:

• Design documents (drawings, specifications, schedules, BIM exports)
• Contract documents (contracts, variations, schedules of rates)
• Quality documents (ITPs, checklists, test results, sign-offs)
• Submittal documents (shop drawings, product data sheets, samples)
• Construction records (daily diaries, toolbox talks, incident reports)

The rest of this article focuses on drawings and design documents, because that's where most of the pain is. The principles generalise.

The five rules of good document control

1. There is only ever one "current" version

On any project, on any given date, there is exactly one version of each document that is the live authoritative version. Everybody — the owner, the builder, the consultants, the subcontractors, the certifier — must be able to see which version that is without asking anyone.

The two-second test: can a subcontractor on site, on a phone, identify the current revision of a given sheet without calling someone? If yes, you have document control. If no, you don't.

2. Superseded versions are marked, not deleted

You don't throw old revisions away. You keep them, but you mark them clearly as superseded, and you make the current one the default view. That way, if a dispute comes up ("we priced Rev A, not Rev B"), you can still produce Rev A — but nobody's accidentally building to it.

The common failure mode: people email PDFs around, and the "current" version exists only in the latest email. Six months later, nobody can find the definitive file.

3. Every change has a trail

Who issued it, when, what changed, who approved it. For a drawing revision, that means a revision number, a date, a description of changes, and an approver. For a contract variation, it's a variation number, a price impact, an approval, and a date.

This isn't bureaucracy — it's the difference between winning and losing a progress claim dispute, an insurance claim, or a defect liability argument. Without the trail, every change becomes a he-said-she-said.

4. Access is explicit, not assumed

Not everyone should see every document. Commercial terms between the head contractor and the client aren't the subcontractor's business. Draft designs that haven't been issued aren't the certifier's business. Access should be granted explicitly to documents or groups of documents, and it should be easy to audit who can see what.

The accidental-access failure (giving the whole project team access to a contract negotiation folder) is one of the most expensive mistakes you can make. It's also one of the easiest.

5. The current version is pushed, not pulled

If your document control process depends on everyone checking a folder regularly to see what's new, your document control process will fail. People are busy. They will miss updates. They will use yesterday's drawing because they didn't check the folder.

Good document control pushes — notifies users by email (or app notification) when a relevant document changes, and ideally with a summary of what changed, not just a "Revision C issued" link.

Where most teams break document control

Three places, consistently.

Email as the document repository. PDFs attached to threads. "Latest version" meaning "the file in the most recent email I remember". This works fine with 10 documents. It breaks catastrophically at 100.

Cloud drives with no versioning discipline. SharePoint, Google Drive, Dropbox — fine as a file store, but they don't enforce revision discipline. Anyone can upload anything. "Which of these three files is the current one?" becomes a regular question.

PM tools that treat drawings as generic files. Plenty of project management platforms let you upload PDFs, but treat them like any other document — no revision chain, no supersession, no approval trail, no discipline-level grouping. That's not document control; it's cloud storage with UI.

What good document control tooling looks like

A tool that actually helps with document control — rather than just making you feel organised — should do six things.

Revisions as first-class objects. When you upload a new version, the old one should be automatically superseded, the new one marked current, and the full history visible. You should never have to rename files to keep track.

Automatic comparison between revisions. Knowing a new revision has been issued is step one. Knowing what changed is what prevents people building to the wrong version. AI-powered comparison (vision models that diff old vs new pages) is now a viable default for this, and it's far less noisy than pixel-diff tools.

Approval workflows built in. Every document that needs to be signed off should have a visible approval chain — who approved it, when, and any comments. This should be queryable later.

Granular sharing. Share an individual drawing, a discipline (e.g. all hydraulic sheets), a project, or your whole workspace. Different stakeholders should see different slices without you having to build custom folders for each one.

Notifications that summarise, not just alert. "A revision was uploaded" is weak. "Rev C supersedes Rev B on S-100: slab thickness changed from 200 to 250 mm" is strong.

An audit trail you can actually use. Every upload, download, approval and view should be logged, and you should be able to answer "who last saw this document?" in a few clicks.

How Doclio handles document control

Document control is a significant part of what Doclio was built to do.

Revisions. Every drawing has its own revision history. Upload a new revision and the previous one is automatically superseded but retained. You can view the revision chain, see who uploaded each version, and open any historical version if needed.

AI revision comparison. When a new revision lands, Doclio runs a Claude Sonnet vision model over the old and new sheets in the background and pre-computes a categorised summary of what changed — "design changes" separated from "title block only" edits. By the time you open the drawing, a structured summary is cached and ready. No manual pixel-diff review.

Approvals. The Approval annotation type has a full workflow: add approvers, they get tokenised email links, they approve or reject on a public page without needing a Doclio account, and the approval trail is kept on the annotation itself. Reporting on outstanding approvals is built in.

Granular sharing. Share at the project level, discipline level (all architecturals, all hydraulics), individual drawing level, or via a tag. Different external users can have different access — viewers, commenters, editors.

Notifications with context. When a drawing is added, updated or deleted, notifications include the drawing number and title. Revisions trigger a summary. Digest emails batch these for users who prefer once-a-day rather than per-event alerts.

Audit trail. Every report, drawing, approval and annotation keeps a log of who did what and when. The external report viewer also logs who opened a report and when — useful for demonstrating that the client genuinely received the issued version.

Starting small

You don't have to boil the ocean to get document control right. Start with three changes:

1. Move drawings off email into a tool with revision versioning. Anything is better than attachments.
2. Define who approves what. Even a simple "I approve all structural revisions before they're issued" discipline is better than nothing.
3. Make sure the team knows where the current version lives. One URL, one rule: "always check Doclio (or your tool of choice) before you cut anything".

Those three alone will prevent most of the expensive mistakes.

---

Run your next project in Doclio — proper revision control, approval workflows and AI-powered drawing comparison, starting from a free Starter plan.

None of that is fraud — it's just marketing. But it wastes the time of builders, project managers and estimators who have a genuine need: a way to try a PM tool on a live small project, without pulling out a credit card, without committing to an annual plan, and without being locked out the moment the project gets real.

This article is a practical guide. We'll cover what to look for in a truly free plan, what the common traps are, and how Doclio's free Starter tier works (including what it doesn't include — because transparency is the point).

What "free" usually means, and what it usually doesn't

When you read "free project management", it almost always falls into one of four categories.

Free trial. You get full access for 7, 14, or 30 days. Then you pay or lose access. This is still useful, but it isn't what most people mean by "free".

Freemium with hard caps. Real free tier, but capped so tightly (e.g. 1 user, 5 documents) that it can't handle even a small real project. Fine for kicking the tyres, not fine for actual work.

Free for viewers only. The tool is paid for the people who create drawings and tasks, but viewers/clients are free. This is a common (and fair) pricing model in construction — but it's not the same as "free PM software" in the dictionary sense.

Free forever, usable for a real small project. This is the rarest tier and the one most teams want. One or two projects, reasonable drawing limits, full feature access, unlimited users. Limits you'll grow out of if the project grows — but you can finish a small job without ever paying.

The fine print to check before you start

Before you commit your project data to any "free" tool, check six things. You'll find the answer buried somewhere in the pricing page or FAQ — if you can't find it, assume the worst.

1. How many users are included? "Free" for 1 user is effectively a demo. Free with unlimited viewers, paid for creators, is a real free plan.
2. How many projects? One live project is enough for a real trial. Zero projects (or "projects expire after 14 days") isn't.
3. How much storage? Construction drawings are big. 100 MB is lean, 200–500 MB is reasonable for a small job, 1 GB+ is comfortable.
4. What happens when you hit a limit? Some tools go read-only gracefully. Others lock you out, or start billing the card you didn't realise you'd entered.
5. Can you export your data? Any tool worth using lets you export drawings, annotations and reports as PDFs (at minimum) so you're not held hostage.
6. Are core features gated behind paid tiers? Some "free" plans lack things that are essential — like PDF export, sharing, or revision history. Check the feature comparison table, not just the price.

How to tell a genuine free tier from a marketing free tier

Three tests.

Test 1: Can you close a real (small) project on it? If the answer is "not without upgrading", it's not actually free for anything useful.

Test 2: Are viewers and clients charged? If yes, every new stakeholder you invite is a line item. That model can work for large jobs, but it makes "free" mostly theoretical for small builders.

Test 3: Can you invite your client and consultant without a credit card? If so, you have a workable collaborative tool. If not, you have a private workspace that's hard to use in real construction.

What you should expect a free PM tool to do

At a minimum, a construction PM tool worth its free tier should handle:

• PDF drawing upload and viewing on desktop and mobile.
• Markups and annotations with types that reflect construction work — RFIs, defects, notes, safety items.
• Revisions — when you upload a new version of a drawing, the old one should be properly superseded, not overwritten.
• Reports — being able to generate a punch list or an RFI summary as a PDF.
• Sharing — invite clients and consultants by email without forcing them into a paid account.
• Basic data export — PDF export of reports and drawings, at least.

Anything less and you're using a tool that will cost you more in workarounds than a paid subscription would.

Doclio's Starter plan: what you get, what you don't

We built Doclio's free Starter plan because the free tiers we used on other tools kept getting in the way of actually finishing a project. Here's what it includes (and what it doesn't, because we'd rather you know upfront):

Included on Starter:

• 1 active project, plus 1 archived project slot
• 20 drawings per project
• 200 MB of file storage
• Unlimited users — owners, editors, viewers, clients, subbies, consultants, certifiers. No seat caps on any plan, including free.
• All annotation types — Note, Query, Issue, Alert, Approval, plus custom types you configure
• Full approval workflow, including tokenised external approvals by email
• Reports (live or static), both web and PDF
• AI assistant (with a monthly credit allowance; see below)
• Drawing revision comparison with AI
• Mobile-friendly PWA (works offline with service worker support)
• REST API? No — API access is on Business plans and above
• Light and dark themes, plus a custom accent colour and font
• 7 supported languages

Not included on Starter:

• More than one active project at a time (archive the old one to start a new one, or upgrade)
• Large file sets (200 MB is genuinely small by construction standards)
• Unlimited AI credits — Starter includes 20 AI credits a month (60 in your first month), plus a one-time 500-credit bonus for the first 14 days. Enough for normal use; heavy users may want Growth.
• Commercial API access

The short version: the Starter plan is built for one small project. A house renovation, a small commercial fitout, a specialist trade's portion of a larger job. For a single project with a small drawing set and a team of any size, it's genuinely free, genuinely useful, and genuinely unlimited on users.

If you outgrow it, Growth is $29/month (annual), which adds 3 active projects, 25 archived, 200 drawings and 1 GB — still with unlimited users.

When free is the wrong answer

To be blunt: free doesn't work for every team.

• If you run more than one project at a time routinely, you'll outgrow Starter in week one.
• If you have large drawing sets (hundreds of sheets per job, typical for commercial or industrial work), 200 MB won't last.
• If you need API access or SSO/enterprise controls, you're going to pay for them somewhere.
• If you need SLA-backed support, a free plan isn't usually the right tier.

For everyone else — owner-builders, small residential builders, specialist subcontractors, consultants running light-touch projects — a properly-built free plan is a genuine work tool, not a marketing gimmick.

How to get started for free

Three steps:

1. Sign up for Doclio with an email or Google account. No credit card.
2. Create your first project, configure your annotation types, and upload your drawings.
3. Invite your team and your external stakeholders — viewers are free and unlimited on every plan.

If it clicks, upgrade. If it doesn't, stop using it — no trial to cancel, no card to charge, no data hostage situation. That's what "free" should mean.

---

Start on Doclio's free Starter plan — 1 project, unlimited users, AI assistant included. No credit card, ever.

But "Fieldwire or nothing" isn't the actual choice. A growing number of builders are looking for a Fieldwire alternative — usually because they want better drawing management, a more flexible annotation system, AI features Fieldwire doesn't yet offer, or a genuinely free tier that doesn't cap viewers or cripple the product. This article walks through where Fieldwire shines, where it doesn't, and how Doclio compares.

Doclio is construction project management built around PDF drawings, annotations, approvals and AI. It's used by builders, project managers and consultants who need to run drawings and site issues across a whole organisation — not just one trade's task list.

What Fieldwire does well

Before we get into alternatives, let's be fair about Fieldwire's strengths:

• Mobile-first task management. The app is well-tuned for punch-listing and site walks.
• Plan viewing. Fast PDF rendering, responsive on tablets, decent offline mode.
• Trade-focused task flow. Assign a task to a sub, set a due date, mark complete. Clean and simple.
• Scales with small crews. Small teams can be running within an hour.

If your entire workflow is "guy on site needs to punch-list against a plan and assign follow-ups", Fieldwire is hard to beat.

Where teams start looking for an alternative

Three recurring frustrations push teams to look elsewhere.

Pricing gets expensive fast

Fieldwire's free tier is limited — 5 users and 3 projects — and the paid tiers step up quickly. Once you're on a project with a head contractor, subcontractors, a consultant or two and a client rep, you're often into the paid plans just to get everyone on. The per-user model starts to sting for teams that want to invite external reviewers, clients, or infrequent consultants.

It's task-centric, not drawing-centric

Fieldwire is built around tasks. That's great when the job is punch-listing. It's less great when what you actually need to manage is the drawing set itself — revisions, supersession, approvals, shared markups across disciplines, RFIs against specific details. The drawing layer in Fieldwire is more of a backdrop for tasks than a first-class object with its own lifecycle.

No AI layer yet

Drawing AI and AI assistants are now real workflows — automatic revision comparison, drawing-aware Q&A, auto-classification on import. Fieldwire doesn't offer these today. For teams dealing with large sets or frequent revisions, that's a significant gap.

How Doclio compares

Doclio takes a different approach. Rather than start from "mobile task list on a plan", it starts from "the drawing set is the project", and layers annotations, approvals, reports, and AI on top.

Drawings as first-class objects. Every PDF has a discipline, drawing number, title, revision history, approval trail, and share settings of its own. Upload a new revision, Doclio supersedes the old one automatically and runs an AI comparison in the background so you know what changed before you open it.

Annotations that actually model construction work. Doclio annotations aren't just "tasks" — they're typed: Note, Query, Issue, Alert, Approval. Each type has its own colour, icon, workflow and, where relevant, a proper approval flow. Types are per-project configurable, so your naming (and your client's naming) is preserved.

Approvals built in. Doclio has a first-class approval workflow: add an approver to an annotation, the approver gets a tokenised email link, they approve or reject on a public page without needing a login. No more emailing PDFs back and forth.

AI features out of the box. The AI assistant answers questions about your project in plain English, grounded in your actual drawings and annotations. Revision comparison is automatic. Web search is built in for anything not in your project.

Unlimited users on every plan. This is the big one. Every Doclio plan — including the free Starter plan — has no seat caps at all. Owners, editors, viewers, clients, subbies and consultants are all unlimited. You pay for project/drawing/storage capacity, never per user.

A genuinely free forever tier. Doclio's Starter plan is free indefinitely: 1 active project, 1 archived project, 20 drawings, 200 MB storage, and unlimited users. You can run a small job end-to-end on it without ever paying.

Feature-by-feature comparison

The honest summary: if you only want mobile punch-listing, Fieldwire is more polished at that specific job. If you want a single tool that handles drawings, revisions, markups, RFIs, defects, approvals, reports and AI for a whole project, Doclio covers a wider surface area.

When Fieldwire is still the right call

To be fair:

• If your workflow is primarily native mobile punch-lists and you won't compromise on that feel, Fieldwire's app is more specialised.
• If you're a subcontractor whose entire job is trades tasks against a plan you don't own, Fieldwire's task-first model fits neatly.
• If you're already deeply integrated with Fieldwire's task API, switching has real cost.

When Doclio is the better fit

• You're managing drawings and the set is changing frequently — Doclio's revision workflow and AI comparison pay back fast.
• You need external approvals from a client, certifier or consultant — Doclio's token-based approval page works without logins.
• You want viewers and client reps on every project without hitting seat limits.
• You want AI baked in — revision comparison, project Q&A, drawing context search — not as a roadmap promise.
• You want a free tier that stays free on small jobs.

Migrating from Fieldwire to Doclio

Migration is usually straightforward. Drawings come across as PDFs, and tasks map to Doclio annotations (you can map Fieldwire tasks to Doclio's Action, Defect or RFI types depending on how you used them). Doclio supports drag-and-drop bulk PDF import, auto-extracts drawing numbers and titles from title blocks, and lets you configure your annotation types and statuses to match what your team is used to.

If you're curious, start with a single live project — free Starter plan, unlimited users, no credit card — and run it parallel to Fieldwire for a week. Most teams make the call quickly once both tools are in their hands.

---

Start a free Doclio project — 1 active project, unlimited users, AI assistant included. No credit card, no time limit.

It's also a pitch that deserves a close read. AI takeoffs are real, they work well for certain scopes, and they're genuinely changing estimating workflows — but they're not a magic button. This article walks through what the technology actually does today, where the honest limitations are, and how teams are folding it into their estimating stack.

It also addresses a question we get asked directly: does Doclio do AI takeoffs? Yes, as of mid-2026 — Doclio's AI Assistant can measure quantities directly from a drawing's own geometry, not just estimate them, alongside a manual takeoff tool and a click-to-match tool for repeated symbols. We'll walk through what that covers, what it doesn't, and when a dedicated estimating tool still earns its place in your stack.

What an AI takeoff actually is

A traditional takeoff is an estimator going through a drawing set sheet by sheet, counting fixtures, measuring linear metres of pipe, totalling areas of finish, and transcribing those numbers into a spreadsheet or estimating package. It's meticulous, repetitive, and expensive.

An AI takeoff uses a machine learning model — usually a vision model trained on construction drawings — to do the counting and measuring pass automatically. You upload your drawing set, tell the tool what to look for ("count every single-leaf door", "measure all 100mm stormwater pipe"), and get back a set of detected objects with counts, locations, and often a visual overlay on the drawing showing what was found.

The better tools now handle:

• Symbol counting — doors, windows, fixtures, fire services, electrical outlets. Generally the most reliable category.
• Linear measurement — pipe runs, walls, kerbing, cable trays. Reliable on well-drafted sheets; less so when symbols overlap.
• Area measurement — flooring, roofing, wall finishes. Decent for clean polygons, weaker for irregular boundaries.
• Classification — distinguishing between symbol variants (single vs double door, 100mm vs 150mm pipe). This is where most errors show up.

Where AI takeoffs are already good

Three scopes are where the current generation of tools earns its keep.

Fixture and door/window counts. These are high-volume, highly repetitive tasks that are miserable for humans and well-suited to a trained model. Most AI takeoff tools are now accurate enough on these to produce a first-pass schedule in minutes, which an estimator spot-checks rather than rebuilds.

Repeat-project estimating. Teams that bid a lot of similar projects — retail fitouts, residential builders with standard product, commercial interiors — can train or tune the model on their own symbol library and get extremely good results fast. This is where you see the genuinely dramatic time savings.

Preliminary estimates and bid/no-bid decisions. Even a 70%-accurate takeoff, delivered in an hour, is enough to decide whether a project is worth pricing in earnest. That's a real change in how early-stage estimating works.

Where the limits are

It's worth being blunt about this because a lot of marketing material glosses over it.

Accuracy on non-standard symbols. Every consultant draws slightly differently. If the model was trained on a library that doesn't match your consultant's symbology, the first few jobs will miss things. Tuning helps — but tuning takes time.

Multi-sheet deduplication. A door on Floor Plan L2 shouldn't also be counted on the Door Schedule or the RCP. Most AI takeoff tools handle this imperfectly, and double-counting is a painful error to catch after the fact.

Complex services drawings. Dense hydraulic, mechanical and electrical services with overlapping linework and heavy notation are where current models struggle most. A human estimator who knows services still wins here.

Specifications and spec-dependent quantities. Counts are one thing; the right product at the right spec is another. The AI tells you there are 43 doors; it can't tell you that 12 of them need to be FD60/FD30 fire-rated per the NCC schedule without someone also reading the spec.

Verifying the AI. You still need an estimator to review the output, and reviewing someone else's takeoff is harder than redoing it yourself. The time savings are real but they're smaller than the marketing suggests unless your team builds a strong review process.

What this means for how you use AI takeoffs

The teams getting the best results tend to share a few habits.

• Treat the AI pass as a first draft. Always review, always expect edits.
• Start with the scopes AI does best — architectural counts, straightforward quantities — and keep complex services in the hands of specialists.
• Keep a library of known-good results. Past AI takeoffs against verified as-builts are how you build confidence and improve tuning.
• Keep your pricing conservative. Until you've run enough jobs through the tool to know its error profile, price risk in.

Does Doclio do AI takeoffs?

Yes, with an important nuance worth being precise about — Doclio's AI takeoffs are measured, not estimated. Ask the AI Assistant an area question ("what's the cladding area on the elevations?") and it finds the regions, then traces each one against the drawing's actual vector linework and measures it at the drawing's scale. The number you get back is geometry, not a language model's guess — though like any takeoff, it's only as good as the drawing and its scale, so spot-checking a known dimension and verifying against spec before ordering materials is still the right habit.

Doclio now covers a genuine range of takeoff workflows:

• AI-measured takeoffs. Ask the AI Assistant (Estimator mode) a counting or area question about an open drawing and it returns a draft takeoff — one row per region, each editable in a FLOOD editor (drag nodes, add cutouts, smooth edges) before you accept it. Needs a vector PDF and a set scale; scanned drawings can still be estimated but not traced.
• Click-to-match for repeated symbols. The MATCH tool finds every other instance of a symbol you click, straight from the PDF's vector data — zero AI credit cost, exact placement, best for counting doors, fixtures, and fittings on a clean vector sheet.
• A manual takeoff tool. COUNT, LINE, and AREA modes for click-through counting, run-length measurement, and polygon areas, filed under colour-coded categories you define — full manual control when you'd rather do it yourself.
• A drawing-aware AI assistant for everything else — "how many RFIs mention the slab?", "what changed in the last revision?" — with grounded answers linked back to the actual drawings and annotations.

Where Doclio fits vs. a dedicated estimating tool

Doclio isn't trying to be a full bill-of-quantities estimating package, and for some workloads a dedicated tool still has a real edge:

• Repeat-project estimating at scale. If you bid a high volume of similar projects and want to train or tune a model on your own symbol library, a specialist tool built around that workflow will get you there faster.
• Formal BOQ output. Doclio's takeoffs feed running totals and draft panels inside the project, not a full estimating package with cost-linked line items.

Where Doclio does the job on its own: fixture and door/window counts (MATCH, zero credit cost), area and length queries on a clean vector drawing (AI-measured takeoffs), and anything that benefits from staying inside the same tool you're already using for drawings, RFIs, approvals and reports — no export/import round-trip, no re-uploading revisions to a second system. Many teams now run pricing-stage takeoffs and construction-stage measurement checks in Doclio directly, and reach for a dedicated estimating tool only for large, repeat-project BOQ work.

What to look for in any AI takeoff tool

If you're evaluating, the questions worth asking vendors:

• What does accuracy look like on my consultant's drawings? (Run a pilot; don't accept a demo on their sample set.)
• How does the tool handle multi-sheet deduplication?
• Can I train or tune the model on my own symbol library?
• Where are my drawings stored and processed, and what's the data retention policy?
• What's the review workflow — can an estimator easily correct and re-run without losing manual overrides?

Any vendor who can't answer those cleanly isn't ready.

---

Doclio now measures takeoffs from your actual drawings, not just guesses — on top of the RFIs, drawing revisions, and approvals you already run through it. Start a free project and see where we fit.

That's what "drawing AI" is starting to change. The term gets used loosely, but it really covers three jobs: reading drawings (pulling information out of a PDF), comparing drawings (spotting what changed between revisions), and reasoning about drawings (answering natural-language questions against a drawing set). Each of these has moved from research-lab territory to real software in the last eighteen months, driven almost entirely by multimodal large language models that can look at a rasterised page the way a human does.

This guide walks through what drawing AI can genuinely do today, where the limits are, and how to bring it into a construction workflow without creating new problems.

What people mean by "drawing AI"

There's no single product category. Most of what gets marketed as drawing AI falls into one of four buckets:

Automatic revision comparison. Given an old revision and a new revision of the same sheet, the model highlights what's changed. Older tools did this geometrically (pixel diffs, raster overlays), which produced a lot of noise — every title-block update looked like a design change. Modern vision models can actually read the drawing and tell you that the slab thickness went from 200 mm to 250 mm, or that three columns moved, while ignoring a date stamp.

AI takeoffs and quantity extraction. Tools that scan a drawing and return counts or lengths — doors, fixtures, linear metres of pipe. This is a specialised area dominated by dedicated tools (Togal.AI, Kreo, Stack, Buildots). Accuracy is still mixed, and most teams use these as a first pass to be reviewed by an estimator rather than a final answer.

Drawing-aware chat assistants. Ask a question in plain English, get an answer grounded in your project's drawings and metadata. "What was the door schedule on Level 2?" "Show me the revision history for the hydraulic sheets." "What's the specified finish for the lobby walls?" These sit on top of your existing drawing set and use the model to search and summarise.

Drawing classification and tagging. Automatically recognising discipline, sheet type, drawing number and title from a raw PDF so you don't have to key it in. Surprisingly useful, because most teams still do this manually whenever a consultant sends a new bundle.

Each of these uses a different AI capability. A single model can technically do all four, but the products shipping today tend to specialise in one or two.

Why drawings are hard for AI (and why that's finally changing)

Construction drawings aren't like other documents. They're dense, visually structured, and meaning lives in relationships — a line connecting two symbols, a dimension next to an edge, a revision cloud around a modified region. A general-purpose language model that reads the raw PDF text misses almost all of this, because most of the information isn't in the text layer at all.

The breakthrough has been vision-language models that ingest the rasterised page image and reason over it the way a human draftsperson does. Claude Sonnet, GPT-4 Vision and Gemini can all now look at a scanned sheet and answer questions about what they see, with accuracy that's good enough to be useful on many jobs — especially when paired with OCR and retrieval over a structured project database.

That said, there are still sharp limits. Models struggle with very high-resolution or multi-page schedules, hand-markups, heavily overlapping linework, and non-standard symbol sets. Anything safety-critical (structural calcs, egress compliance, fire sizing) still belongs in the hands of a qualified person with the model as an accelerator rather than a decision-maker.

Where drawing AI earns its keep in practice

Three workflows are where teams are getting measurable value today.

Revision comparison

This is the single most time-consuming manual job on most projects. When a consultant issues a new revision of an architectural pack, someone has to go through every sheet, figure out what actually changed, and update the team. Vision-based comparison tools automate that first pass. A good tool will categorise its findings — "design changes" that affect construction versus "title block only" updates — so the team can triage quickly.

The trust-building move here is transparency: the AI should show you where on the drawing it saw each change, not just tell you there was one. When that's available, most teams shift from "have someone compare this overnight" to "get the AI summary in the morning and spot-check the design-change sheets." That's often a 10x cycle-time improvement on revision reviews.

Drawing-aware question answering

Project teams spend a surprising amount of time answering the same questions over and over: what's the door schedule, where are the fire hydrants, which drawings have been superseded, what's outstanding for approval. A drawing-aware chat assistant grounded in your project data can answer most of these instantly, and cite back to the drawing or annotation it drew from.

The key word is "grounded". An assistant that has been given actual access to your drawings, annotations, and metadata will produce sourced answers. One that's just working from a general-purpose model will hallucinate. If you're evaluating a tool, ask whether the assistant can point you to the exact sheet and pin its answer came from — if not, it's probably guessing.

Auto-extraction during drawing import

The fiddliest part of uploading a new PDF set is entering drawing numbers, titles and disciplines for each sheet. Vision models can read the title block directly and pre-fill these fields. Even imperfect extraction (say 80% correct) removes most of the typing and leaves you reviewing rather than keying.

What drawing AI is not good at yet

Honest answer: it isn't a replacement for a drafter, an estimator or a reviewer. It's a massively accelerated first pass.

Anything that depends on engineering judgement — deciding whether a detail is buildable, whether a clash is significant, whether a spec change affects cost — still belongs with the humans. AI takeoffs can be wrong in ways that are hard to catch (missing an entire fixture type, double-counting across sheets) and need a line-by-line review before they're used for pricing.

There's also a data-governance question. Vision models are usually cloud-hosted, which means your drawings leave your network to be processed. For most commercial work this is fine, but for government, defence or secure projects you need to check where the model runs and what its retention policy is. Any vendor that can't give you a straight answer on that isn't ready for enterprise use.

How to introduce drawing AI without disrupting your team

Three principles from teams that have done this well.

Start with one workflow. Pick the single highest-pain task — usually revision comparison on a large consultant-heavy project — and pilot there. Don't try to roll out AI across takeoffs, QA/QC and submittals all at once.

Keep a human approver on every AI output. Especially for anything that affects cost or compliance. The AI's job is to narrow the field; a person's job is to sign off.

Measure cycle time, not "accuracy". Accuracy debates are rabbit holes, because most tools will get better with more use. The honest metric is how much faster your team closes a revision review or answers a drawing query. That's what you're actually paying for.

How Doclio approaches drawing AI

Doclio is a construction project management app built around PDF drawings and annotations, and we use AI for two jobs specifically.

The first is automatic revision comparison: when you upload a new revision, Doclio runs a vision model (Claude Sonnet) over the old and new sheets in the background and pre-computes a structured summary of what changed — categorised as design changes versus title-block-only edits. By the time you open the drawing, the comparison is cached and ready.

The second is a drawing-aware AI assistant inside the app. Ask it "what changed in the last revision?", "what are my overdue RFIs?", or "find the annotation about the slab reinforcement" and it answers using your real project data, with links back to the specific drawing or annotation it referenced. When it can't find the answer internally, it can optionally search the web and cite sources.

We're opinionated about what AI should and shouldn't do in construction. It shouldn't replace your estimator or your site manager. It should take the five-hour drawing review down to fifteen minutes, and the "where did we file that RFI?" question down to three seconds. That's where drawing AI pays back.

---

Want to try drawing AI on your own plans? Start a free Doclio project — the Starter plan is free forever and includes the AI assistant with monthly credits.