Electrical takeoff
in PlanSwift.

Before you click anything

PlanSwift is a good tool. It's been the workhorse on a lot of electrical estimating desks for years, and if you know its quirks you can move fast in it. But it's a manual tool — it gives you a sharper pencil, it doesn't do the takeoff for you. Everything below is the order I actually work a set in, the stuff that bites you if you skip it, and where you'll feel the ceiling on a big job. If you've taken off electrical before, none of this is mysterious; the value is in the sequence and the gotchas.

1. Set up the job & import the plans

Start a new job and pull in the PDF set. Most architects ship one giant combined PDF, so the first thing I do is split it in my head into two buckets: the architectural backgrounds (floor plans, RCPs) and the electrical sheets — E0.x for general notes and schedules, E1.x for power, E2.x for lighting, E3.x onward for one-lines, panel schedules and details. Import the whole thing, then rename every page so it reads E2.1 — Level 1 Lighting instead of "Page 14." It sounds fussy. It saves you an hour of scrolling on day two when you're hunting for the sheet that has the panel that feeds the receptacles you're on.

Group the electrical pages together in the page list. PlanSwift will happily let you take off on the architectural floor plan, which is sometimes what you want for a background, but your counted symbols live on the E-sheets. Keep them adjacent so you're not jumping the length of the set every time.

2. Set the scale — correctly, on every sheet

This is the single most common way an electrical takeoff goes wrong, and it's worth being slow about. Do not trust the scale printed in the title block, and do not use the little graphic scale bar as gospel. PDFs get printed-to-fit, re-saved, and re-issued, and the plotted scale drifts. Calibrate against a known dimension instead — a column grid you can read a real number off, a door that's dimensioned, a corridor with a callout. Set your scale tool on that, type in the true distance, and let PlanSwift compute the rest.

Then check it again on the next sheet. The trap with E-sheets specifically is that lighting and power are often plotted at a different scale than the architectural backgrounds — the EE enlarged a congested area, or fit a big floor onto a smaller sheet — and they don't always match each other either. I've seen E2.1 at 1/8" and E2.2 at 3/32" in the same set because one floor was bigger. If you calibrate once and assume the whole set holds, every linear run you measure after that is quietly wrong. The other gotcha is viewports: an enlarged plan detail dropped into the corner of a sheet has its own scale, so don't measure conduit across it at the sheet scale. Calibrate per sheet, and per viewport when there's a blow-up.

3. Build your takeoff structure first

Before you place a single count, lay out your folders. I mirror the way the estimate is going to be priced, because that's the document this all feeds: Lighting (fixtures by type, then their controls), Receptacles & devices (standard, GFI, dedicated, floor boxes), Switchgear & distribution (panels, transformers, disconnects, gear), Branch wiring & conduit, and Low voltage / systems (data, fire alarm, security — whatever's in your scope). Some of you will want it broken by floor or by area on top of that; PlanSwift's nested folders handle it.

The reason this matters: when you export, the structure is the export. If your takeoff is a flat pile of 40 count items, your spreadsheet is a flat pile of 40 rows you then have to re-sort by hand. If it mirrors your estimate, the numbers drop straight into your worksheet in the right buckets. Build the skeleton once, reuse it on every job — a template here is the difference between starting clean and starting from scratch.

4. Count devices with the Count tool

Now the bulk of the work. Open the lighting fixture schedule first and create a count item for each fixture type — Type A 2x4 troffer, Type B downcan, Type F1 exit sign, and so on — not one generic "fixture" bucket. The schedule is your source of truth for what each tag means; the plan only tells you where they are. Same discipline on devices: a standard duplex, a GFI, a dedicated 20A, and a floor box are four different count items because they're four different prices and four different rough-in details.

Color-code as you go. I assign a color per circuit type or per system so that when the sheet is covered in markup I can still read it — receptacles one color, switches another, lighting a third, emergency/egress something loud like red. Then it's single-click counting: pick the count item, click each symbol, symbol by symbol, across the sheet. Turn on PlanSwift's auto-count search if the symbols are clean and you trust it, but verify the total against the panel schedule — auto-count loves to grab a symbol in the legend or miss one that's rotated. Honestly, on most messy real-world sets I end up clicking by hand anyway, because the time spent cleaning up a bad auto-count exceeds the time to just count it.

5. Measure the linear runs

Switch to the Linear tool for conduit and feeder runs. Trace the homeruns and feeders you can actually see, and for branch wiring use a sane rule-of-thumb run per device rather than tracing every concealed pull — nobody traces every #12 to every receptacle, you allowance it. Where PlanSwift's plan length under-reads reality is verticals: the plan is flat, so a drop from the ceiling to a wall device, or a riser up to the deck, isn't in your traced length. Add a height/drop adder per device — a fixed footage per receptacle, per fixture whip, per switch leg — so the wire quantity reflects the third dimension the drawing doesn't show.

Then put waste on it. Wire and conduit don't install at exactly the measured length; you pull extra, you make up at boxes, you scrap ends. A waste factor on the linear quantities (and a little on devices for breakage) keeps you from buying short. Set these adders and factors in the item properties so they apply automatically — don't do the math in your head every run.

6. Use Assemblies — this is where PlanSwift earns its keep

If you take only one thing from this page, take this. A bare count of "47 receptacles" is almost useless to an estimate, because a receptacle isn't one line item — it's a device, a box, a mud ring, a plate, a length of wire, and the labor to install all of it. PlanSwift's Parts & Assemblies is built exactly for this. Set up your parts once with real costs, then build a receptacle assembly that bundles: the duplex device + the box + the ring + the cover plate + a set footage of wire per drop, with labor units on each. Now every single click of that count item doesn't just add one to a tally — it explodes into a full bill of material.

Do the same for each fixture type (fixture + whip + connector + lamps if applicable), for switch drops, for homeruns (conduit + wire + fittings per foot). It's an afternoon of setup the first time. After that, your takeoff is your material list and your labor hours, and the counting work you did in steps 4 and 5 turns directly into a priced bid. This is the real reason estimators put up with PlanSwift's clicking — the assembly engine is genuinely good, and it's the feature that separates it from a plain markup tool.

7. Handle the revisions without redoing everything

Addenda will land mid-bid. The wrong move is to re-count the whole sheet. PlanSwift can overlay the revised sheet on top of the prior version and highlight the differences, or you compare the two side by side and hunt the revision clouds. Find what actually changed — three fixtures added in the new conference room, the panel bumped from 42 to 84 circuit — and re-count only that. Adjust the affected count items, leave the rest alone, and note the addendum number against the change so you can defend the number later. The discipline is surgical edits, not a redo.

8. Export to Excel

When the takeoff's done, export the summary to Excel. Because you structured the takeoff to mirror your estimate (step 3) and built assemblies (step 6), what lands in the worksheet is organized quantities with material and labor already attached — not a raw dump you have to re-key. From there it flows into your pricing template, you layer on your markups and conditions, and you've got a bid. Keep the PlanSwift file with the job; when the GC asks how you got a number, the marked-up sheet is your audit trail.

Where PlanSwift slows you down

Here's the honest part. Everything above works — but notice how much of it is you, clicking. Every symbol on every sheet is placed by your hand. Reading the legend and the fixture schedule, deciding which symbol is a GFI versus a standard duplex, matching tags to types — all of that judgment is on you, every single job, even when it's the hundredth time you've seen that architect's symbol set. The panel schedules and one-lines sit right there in the set and don't connect to your counts; nothing tells you your 47 receptacles don't reconcile with the circuits on the panel. You catch that by hand, or you don't catch it.

And it doesn't scale. A small fit-out is a pleasant afternoon. A 40-sheet commercial job — multiple floors, a deep fixture schedule, low-voltage systems layered in — is one to three days of clicking before you've priced a thing. Miss the bid date or thin out the takeoff to make the date, and either way you lose. The tool isn't the bottleneck; the manual click is.

That's the gap we built Pilars to close. You upload the full PDF set and the AI reads it — every sheet, the symbols, the lighting fixture schedule, the panel schedules — and returns the counts and measured runs automatically, so the 40-sheet job is back in hours, not days. You still review and adjust; you just don't start from an empty sheet and click 2,000 symbols. It's $100 per trade, no per-seat fees. If PlanSwift's clicking is your bottleneck, that's the thing to fix — see how it stacks up as a PlanSwift alternative.

Questions estimators actually ask