What a G702 checker cannot check
The short answer: a G702 checker recomputes the figures the two forms state about each other, so a difference between them has to surface somewhere. The printed column totals against the rows above them, the sum of Column C against Line 3, the sum of Column G against Line 4, the certificate chain from Line 3 down to Line 9, and Lines 5a and 5b against the rate and the two bases they are drawn from. What no checker can reach from one document and figures you type is four whole classes of error: last month’s schedule item by item, your own contract records, the rest of the packet, and the difference between a document error and a keying error. This page covers both halves, and which checks have to see the document rather than figures you type.
Type the G703 rows and the G702 lines exactly as the document prints them, or paste the schedule out of Excel. The printed column totals, both cross-form ties and the certificate chain are recomputed on every keystroke, and where one figure explains the difference the page names the cell, the figure it has to hold, and the dollar gap.
Open the free G702/G703 calculatorNo account. Nothing is uploaded.Search results for “free G702” are almost entirely blank forms. A template is the right answer when you are the subcontractor writing the application. It is the wrong answer when you are the general contractor, owner, lender, or bookkeeper receiving one, because your problem is not producing the document. Your problem is proving that a document somebody else produced is arithmetically correct before you certify it and money moves. What follows is the split between the checks that run on figures you type and the ones that need the document read, the four blind spots behind both, and what else in this space is free.
What a checker recomputes, and where each check runs
The G702 and its G703 continuation sheet restate the same money in more than one place, which is what makes the pair checkable. Which of those identities a checker can actually run depends on what it is allowed to see. Figures you type give it the totals and the certificate. The figures printed down each row need the document itself read, and that is the line between the free browser calculator and the upload route.
From figures you type, in the browser, with no account:
- Column totals. Each printed grand total against the sum of the rows above it, for C, D, E, F and G.
- The cross-form ties. The sum of Column C equals Line 3; the sum of Column G equals Line 4. This second one is the handshake between the detail and the certificate, and every figure after Line 4 is computed from it.
- The certificate chain. Line 3 = Line 1 + Line 2, Line 5 = 5a + 5b, Line 6 = Line 4 - Line 5, Line 8 = Line 6 - Line 7, Line 9 = Line 3 - Line 6.
- Retainage against its bases. When the form prints a rate, 5a is that rate applied to completed work, the Column D plus Column E base, and 5b is the rate applied to stored material, the Column F base. Not Line 4, and not the sum of Column G, both of which include stored material.
- Two figures off last month. Line 7 against the Line 6 the previous certificate printed, and this application’s Column D total against the Column G total it printed. Both are single figures on a certificate already in the folder, so neither needs the prior schedule matched item by item.
- Readings that are not arithmetic. A line billed past its scheduled value, a gap in the item numbering, a credit in Column E measured against the Line 2 deduct, retainage still held once Line 4 has reached Line 3, and rows that fall short of the schedule total the document states. Each of those can be correct on a correct document, so they come back amber to confirm rather than red.
Row math is the part a typed-in checker computes for you instead of checking. Give it C, D, E and F and it fills in G = D + E + F, H = G / C and I = C - G down every line, which is the addition a reviewer would otherwise do by hand, and those three then agree with the figures they were built from by construction. What the document prints in Column G is never typed, so a printed G that disagrees with D + E + F is invisible from the browser. That is not a shortcut, it is what typing costs: a check needs the stated figure and the computed figure to arrive separately.
On the upload route, because the printed figures are read off the page:
- Row math as a real check. The stated G against D + E + F, the stated H against G / C, and the stated I against C - G, on every line. I is compared against the stated G rather than a recomputed one, so a wrong G copied into both places breaks the row total and stays visible.
- Two more column totals. The printed Column I total against the rows, and the per-line retainage column when the form carries one: its own printed total, and its sum against Line 5.
- The carry-forward item by item. Each line’s Column D against the prior application’s cumulative figure for that item, once both applications are in the account.
- The change order summary. The additions and deductions block on the certificate netting to Line 2.
Two details separate a checker you keep using from one you abandon in a week. The first is tolerance: AIA figures are stated to the nearest dollar, so a dollar of drift per cell is rounding, not an error, and on a total added down a long schedule the honest allowance grows with the row count rather than staying at a dollar. A checker that flags fifty cents on a 90-line sheet is noise. The second is knowing what was not printed. Plenty of continuation sheets arrive without their certificate, and a blank Line 4 means the form did not state it, not that it stated zero. The right output there is “not checked”, not “expected $265,000, found $0.00”.
Type what the document prints, not what it should say
This is the part that makes or breaks a checker, and it is easy to get backwards. If a tool computes Column G for you from D + E + F, then G = D + E + F can never fail. If it computes the totals row, the column totals always tie. If it derives Line 6 from Line 4 and Line 5, the certificate chain is green on every input. A tool built that way shows a reassuring row of ticks while checking nothing at all.
A real check needs two independent numbers: what the document states, and what the arithmetic says it has to be. So the printed totals row is its own field, and Lines 3, 4, 5, 6, 8 and 9 are typed as printed rather than derived from one another. Leave one blank and the honest output is that the check did not run, not a green tick nothing earned. That is more typing, and it is the entire point. It is also why a formula-linked template, useful as it is for building an application, cannot check one: its formulas verify the numbers you typed into your copy, which is the tool computing its own answer and then agreeing with itself.
A pay application that ties everywhere except one place
A three-line schedule of values on a $450,000 contract, 10% retainage, at the second application. Every row satisfies G = D + E + F and I = C - G, and every printed column total equals the sum of its own rows:
| A · Description | C · Sched. | D · Prev. | E · This | F · Stored | G · To date | H · % | I · Balance |
|---|---|---|---|---|---|---|---|
| 1 · Sitework | 120,000 | 90,000 | 20,000 | 0 | 110,000 | 92% | 10,000 |
| 2 · Concrete | 240,000 | 100,000 | 40,000 | 15,000 | 155,000 | 65% | 85,000 |
| 3 · Structural steel | 90,000 | 0 | 0 | 0 | 0 | 0% | 90,000 |
| Printed totals | 450,000 | 190,000 | 60,000 | 15,000 | 265,000 | 59% | 185,000 |
The certificate in front of it reads: Line 1 $450,000, Line 2 zero, Line 3 $450,000, Line 4 $256,000, Line 5a $25,000, Line 5b $1,500, Line 5 $26,500, Line 6 $229,500, Line 7 $175,500, Line 8 $54,000, Line 9 $220,500. Nothing about it looks wrong. Here is what a checker reports:
| Check | Expected | As printed | Result |
|---|---|---|---|
| Column G total = sum of rows | 265,000 | 265,000 | Ties |
| Sum of Column C = Line 3 | 450,000 | 450,000 | Ties |
| Sum of Column G = Line 4 | 265,000 | 256,000 | Off by 9,000 |
| Line 3 = Line 1 + Line 2 | 450,000 | 450,000 | Ties |
| 5a = 10% x (Column D + Column E) | 25,000 | 25,000 | Ties |
| 5b = 10% x Column F | 1,500 | 1,500 | Ties |
| Line 5 = 5a + 5b | 26,500 | 26,500 | Ties |
| Line 6 = Line 4 - Line 5 | 229,500 | 229,500 | Ties |
| Line 8 = Line 6 - Line 7 | 54,000 | 54,000 | Ties |
| Line 9 = Line 3 - Line 6 | 220,500 | 220,500 | Ties |
One failure out of ten, and it is a transposition: 265 typed as 256 in Line 4. Every line below it was then computed from the wrong figure, which is why they all agree with each other and why reading the certificate on its own catches nothing. Correct Line 4 to $265,000 and Line 6 becomes $238,500 and Line 8 becomes $63,000, so the check as written is $9,000 short. The subcontractor loses that money, you certify a figure that does not match the work, and next month’s Line 7 inherits the error. Typed into the free calculator, these figures come back with one red row: Column G ties to Line 4, expected $265,000.00, stated $256,000.00, off by -$9,000.00. Everything else on the page comes out even, the whole certificate chain included.
The panel above the checks reads No single figure explains this, and that is the correct answer rather than a shrug. Setting Line 4 to $265,000 ties Column G and immediately breaks Line 6 = Line 4 - Line 5, and the printed column totals already agree with the rows, so the schedule is not the loose end either. Lines 4, 6, 8 and 9 move together, which is what a certificate written down from a wrong Line 4 looks like: no one figure repairs it, so the page names the broken tie and the $9,000 and leaves the correction to the person holding the document. The seven other shapes the gap takes are in how to find the error when the G703 does not match the G702.
The four blind spots
Worth being blunt about, because the limits are structural rather than a matter of effort. A tool that sees one document, from figures you supply, cannot reach four whole classes of error:
- Last month, item by item. Two summary ties do reach back on one figure each, and the browser calculator runs both: Line 7 against the prior Line 6, and the Column D total against the prior Column G total. Neither sees front-loading spread across twenty line items, or scope quietly moved from one item to another, because both of those leave the two totals agreeing. That needs the prior application’s entire schedule, matched item by item.
- Anything involving your records. The executed contract sum, the approved change-order log, the contract retainage rate. A sub who inflates Line 2 with change orders you never approved produces a document whose internal arithmetic is flawless. Only your own file contradicts it.
- The rest of the packet. The lien waiver’s amount, through date, type, and signature; the certificate of insurance; certified payroll. See lien waiver vs pay application for the three waiver checks.
- Whether the number on the page is the number you entered. Figures you key in carry no confidence signal, so every mismatch reads as a document error when sometimes it is a keying error. Pasting the block straight out of Excel removes most of that when the schedule arrived as a workbook, and a 120-line PDF still has to be entered by hand, which is the slowest part of the job by an order of magnitude.
Three of the four move when the document is read instead of retyped. The uploaded file brings its own printed figures, so the carry-forward runs item by item against last month’s application once both are in the account, a lien waiver in the same packet is checked against Line 8, and nothing is retyped, so a difference belongs to the document rather than to you. The fourth stays yours until you hand it over: the contract sum, the approved change orders and the retainage rate are checked against your records only once you pin them to the project. The full pre-certification sequence, tool or no tool, is in the review checklist.
A template is not a checker
The pages ranking for this query are downloads. Enerpize publishes a free AIA-style G702/G703 payment application template in Word, Excel and PDF, no signup, and states that it automates the calculation of contract sum to date, total earned less retainage, and current payment due from your schedule of values. That is a fair description of a good template, and it is also the limitation: the automation applies to figures you enter into your copy.
The free browser tools in this space have the same shape. They build a schedule of values or a pay application for the party doing the billing, total it, and export it, which is competent work on the sender’s side of the transaction. A document that arrived from somebody else needs the opposite move: compare what it prints against what its own arithmetic requires. A builder has nothing to compare against, because it produced both halves.
The other free option: an AI pay app review
One competitor does aim at the receiving side. Kolena publishes a free pay app review page that asks you to upload your pay application and returns a pay app review checklist, and a companion page describing an AI agent that parses submitted AIA G703 forms in PDF or Excel, cross-verifies scheduled values, previous payments and retainage, validates calculations across columns, flags anomalies or missing data, and generates structured output. Kolena publishes a customer-reported figure of pay app review time falling from three hours to under ten minutes; that is their claim about their customers, not a measurement of ours. Access runs through a free-trial signup, and the page does not name which G702 or G703 line items the agent verifies.
The structural difference is where the verdict comes from. An AI reviewer produces a judgment about a document. A reconciliation engine produces a recomputed identity: expected $265,000, stated $256,000, off by $9,000, at Line 4. The second kind of statement is checkable by hand, which matters when a subcontractor disputes the finding. It is also why the extraction step being AI is safe here: every number a model reads passes through the arithmetic before anyone sees it, so a misread digit breaks an identity and surfaces as a flag rather than as a wrong answer.
When one document becomes a stack of twenty
The free calculator handles the document in front of you. A month-end stack does not work that way: twenty applications from twenty subs, native PDFs out of billing software, Excel exports, and scans of printed forms with handwritten corrections in the margin. Retyping all of it is not a plan.
That is the product. Upload the file you were sent, every G702 line and G703 row is extracted into a grid, the same identities run against the extracted figures plus the ones a single document cannot reach, and each flag anchors to the exact cell with the expected figure, the stated figure, and the delta. Nothing is auto-corrected without a human confirming it, and clean results export to Excel, CSV or JSON. Subcontractors change nothing about how they bill. During Early Access the whole product is free, with no card and no trial clock, and pricing is decided afterwards with notice before anything changes. If you are weighing categories rather than tools, extract-and-verify versus create-and-submit lays out the three of them.
Questions people ask
Four classes of error, and they are the same four for any checker reading one document. It cannot match this application to last month item by item, so front-loading spread across many lines stays invisible even while Line 7 and the Column D total agree with the prior certificate. It cannot compare the document to your own records, so an inflated Line 2 with no approved change order behind it stays internally consistent. It cannot read the lien waiver, the insurance certificate, or the rest of the packet. And where the figures were entered by hand it cannot tell a document error from a keying error, because a figure you typed carries no signal about how it was read.
The browser calculator runs the checks that only need figures you can type: the printed column totals for C, D, E, F and G against the rows above them, the sum of Column C against Line 3, the sum of Column G against Line 4, the certificate chain from Line 3 down to Line 9, Lines 5a and 5b against the retainage rate and their two bases, and two ties to last month, Line 7 against the prior Line 6 and the Column D total against the prior Column G total. The per-row identities are the ones typing cannot reach: G = D + E + F, H = G / C and I = C - G are computed for you from the four columns you type, so they cannot disagree with them. Checking a printed G, H or I, the Column I total, or a per-line retainage column means the document itself has to be read, which is the upload route.
Because its formulas only ever see the figures you retyped into your own copy. A template computes Column G from D, E and F, so G = D + E + F holds on every input it will ever accept, and the same goes for the totals row and the certificate chain. A check needs the two numbers to arrive separately: the figure the document prints, and the figure the arithmetic requires. A template is the right tool when you are the one filling the application in, and it proves nothing about one somebody else sent you.
Not for the browser calculator. You type the figures the document prints, or paste the schedule straight out of Excel, the arithmetic runs on your own machine, and nothing leaves the page. Upload is the other route, and it exists so the figures are read for you instead of retyped, which is the part that stops being practical somewhere around the fortieth line item.
Typed figures check the same whether the page came from billing software, a spreadsheet, or a scan, because the arithmetic does not care where a number came from. On the upload route a scan is read by a vision model and every extracted number then goes through the same identities, so a misread digit breaks an identity and is flagged rather than passing through silently.
No. Billing networks such as GCPay, Textura, Siteline and Procore Pay are create-and-submit systems: they control the document at the source, which means both parties have to be on the platform before anything is verified. A checker verifies whatever arrives, from whoever sends it, in whatever format, and only the receiver has to use it.
The free calculator takes figures you type. Upload the document instead and the figures are read for you, checked against last month's application once both are in the account as well as against their own arithmetic, and exported clean.
Try PayAppCheck freeNo card required. Sign up with an email.PayAppCheck is software, not a law or accounting firm. Not legal, accounting or tax advice. Verify lien, notarization, and retainage requirements against your contract, your state statute, and your accountant.