Every heavy-civil precon team runs the same pipeline, whether or not anyone has ever drawn it on a whiteboard: you take off the quantities, you build your own estimate for the work you self-perform, you solicit bids from subs for the rest, you level and score the bids that come back, and you award. Four of those five steps are well-served by the tools you already own. The fourth — making sense of the 5 to 15 sub bids you receive per package — is the one that still happens in a spreadsheet at 9 p.m. before bid day. A purpose-built heavy-civil estimating software stack handles the first three steps beautifully and then hands you a pile of incomparable PDFs. This article maps the pipeline so you can see exactly where the handoff is, and why sub-bid evaluation is a distinct job rather than a feature your estimating system forgot to ship.

The precon pipeline, step by step

Here is the sequence, in order. The first three steps are about building your number. The last two are about judging their numbers. That distinction is the whole point of this piece.

1. Takeoff

You measure the work off the plans — cubic yards of excavation, linear feet of pipe, tons of asphalt, square yards of pavement. Takeoff produces the quantities that everything downstream depends on. This is a measurement task, not a judgment task, and it is its own category of tooling.

2. Self-perform estimate

For the scope your own crews will run, you price the work: labor, equipment, crews, production rates, indirects, markup. This is the core of what HeavyBid and B2W do, and they do it well. The output is a defensible bottom-line number for the portions of the job you control directly, built from your historical cost data and your own production assumptions.

3. Solicit sub bids

For everything you don't self-perform — and on a heavy-civil job that can be a large share of the value — you send the scope packages out and ask subs to price them. Electrical, structural concrete, drilled shafts, signals, landscaping, MSE wall, striping: each package goes to a handful of subs, and you wait for bid day.

4. Level and score the bids you receive

This is where the day gets long. Five to fifteen bids come back per package, no two formatted alike. One sub itemizes 40 lines; another sends a one-page lump sum. Before you can say which is genuinely the lowest responsible bid, you have to normalize every line to your scope, reconcile what each bidder covered against what they skipped, compare unit prices across the field, and flag the numbers that won't hold. This is bid leveling, and it is the step nobody's estimating system was built to run.

5. Award

You weigh price against scope coverage, schedule, compliance, the sub's track record, and the structural risk in the pricing itself — then you pick, and you write down why. On a $40M job the "why" matters as much as the pick, because six months later someone will ask why you passed on the apparent low bidder.

Where HeavyBid and B2W stop

HCSS HeavyBid and B2W are estimating systems, and the word estimating is exact. They exist to help you build your own bid to the owner: assemble crews, apply production rates, roll up cost codes, and produce a competitive number for the work you self-perform. That is steps 1 through 3 of the pipeline above, and it is a hard, valuable job that these tools have spent decades getting right.

But notice what that job is about. It is about your costs, your crews, your assumptions, your number. The estimating system models the work as if you were going to do all of it yourself. When a sub bid lands in your inbox, it is not built from your cost data and it does not arrive in your format. It is a third party's representation of a scope, written however that sub chooses to write it, with whatever they decided to include or exclude. An estimating engine has nothing to say about it, because evaluating someone else's bid is not estimating. It is a comparison and judgment task that starts the moment the bids you receive hit the table.

Where sub-bid evaluation begins

Sub-bid evaluation is step 4, and it is a genuinely different kind of work. You are not building a number; you are reconciling several numbers that were all built by other people to describe the same scope, and deciding which one to trust. The core tasks have no overlap with estimating:

  • Normalize to your scope. Map each sub's line items onto your scope of work, so a per-cubic-yard price and a lump sum for the same work can sit in the same row. This is bid leveling, and it is the spine of everything that follows.
  • Reconcile scope coverage both ways. Find what each bidder priced that you asked for, and — more importantly — what they quietly left out. A missing item is a future change order with that sub's name on it. Two-way scope coverage analysis is exactly the gap that turns an apparent low bid into the expensive one.
  • Compare on a peer baseline. Line up the unit prices across the field and compute a peer-median per scope item, so one wild number can't drag the benchmark. The median, not the average.
  • Flag the structural risks. Penny-priced unit items, unbalanced bids, front-loaded mobilization, and totals that sit far off the field are all warning signs in the pricing itself, independent of any cost model.

None of that is a knob inside an estimating system. It is a separate discipline that picks up precisely where estimating sets the work down.

Estimate what a faster, defensible award process is worth on your packages with the ROI calculator →

The handoff, and why it's where time leaks

The seam between step 3 and step 4 is the handoff. Your estimating system finishes its job — your self-perform number is locked, your bid to the owner is ready except for the sub-supplied scopes — and then the sub bids arrive and the tooling goes quiet. From here the work moves to a spreadsheet: an analyst pulls 8 to 12 PDFs into one folder, builds columns by hand, retypes line items, eyeballs which sub left out traffic control, and tries to keep the thread across a dozen differently-organized bids near a deadline. That is the most error-prone hour of bid day, and it is happening in the gap between two tools that were each built for a different step.

The cost of the handoff is not just hours. It is the missed exclusion you didn't catch at 6 p.m., the award you can't fully defend later because the reasoning lived in your head and a few cell comments, and the schedule pressure that pushes the decision to the last possible minute. The pipeline is sound; the gap in the middle is where it leaks.

Complement, not replace

Here is the part that matters most, and it is easy to get wrong. Sub-bid evaluation does not compete with your estimating system. Bid Reasoner does not do takeoff. It does not build your self-perform estimate. It does not quantity-estimate or replace the production-rate modeling that HeavyBid and B2W exist to do. Keep all of that exactly where it is.

What sub-bid evaluation does is own step 4 — the bids you receive — which your estimating stack was never designed to touch. Bid Reasoner reads each sub bid PDF, normalizes the line items to your scope, runs four deterministic risk rules across the field (unbalanced unit price at or below $1.00; a peer outlier above 2× or below 0.5× the peer median; a total-bid outlier more than 20% off the field; front-loaded mobilization above 10% of total), and scores all six dimensions — price, scope, schedule, compliance, performance, and risk. You pick a decision mode — Lowest Responsible Bid, Best Value, Lowest Risk, Schedule Priority, Scope Completeness, Budget-Constrained, or a custom weighting — and it returns a ranked recommendation with page-cited evidence behind every flag, plus a forced-override audit trail if your judgment overrules the math. It works in any US state through peer-median normalization, with no government data required; built-in state-DOT pay-item baselines exist for a couple of states as a head start, never a requirement.

In other words: your estimating system builds your number, and sub-bid evaluation judges theirs. They sit on opposite sides of the handoff, and they make each other stronger. If you want the full picture of how the estimating side and the evaluation side fit together on a heavy-civil job, our heavy-civil estimating software page lays out where each one starts and stops.