# Construction Financial Reports — Complete Reference, Organized by Category > Assembled verbatim from the English source files in this repo (`plan.en.md` and `stage1`–`stage6`/README.en.md). Every report's original detail — formulas, worked numeric examples, field tables, first-principles notes, exercise scripts, and checklists — is reproduced in full. Only navigation scaffolding (Chinese-version links, in-page anchor tags, and the per-stage Navigation menus) was removed so the pieces read as one continuous document. > > Plan sections 1–6 (which are short summaries of the full stages) are intentionally omitted to avoid duplicating the complete stage text that appears below; the plan's unique framing material (big picture, data model, learning path, minimal system) is kept in Part 0. ## Contents - **Part 0 — Foundations & Overview** - **Category 1 — Company-Level Past Reports** — Income Statement, Balance Sheet, Cash Flow Statement, Summary WIP, AR Aging, AP Aging, Retention, Change Order Report - **Category 2 — Company-Level Future Reports** — WIP Backlog, Forecasted Income Statement, Forecasted 13-Week Cash Flow, Forecasted Balance Sheet - **Category 3 — Job-Level Reports** — Project Economics, Job Cost Detail, Job Budget Variance, Job Labor Report, Job Cost-to-Complete - **Category 4 — Service Reports** — work orders, planned maintenance agreements *(not present in the source)* --- ## Part 0 — Foundations & Overview The framing material from `plan.en.md` that ties every report together. ### 0. Big Picture Construction financial statements answer four questions: 1. What does the company own, what does it owe, and what is its net worth? - Report: Balance Sheet 2. Did the company make or lose money over a period? - Report: Income Statement 3. Where did cash come from, and where did it go? - Report: Cash Flow Statement 4. Is each project profitable, and how much risk remains? - Reports: WIP, Job Cost, Forecast The construction-specific difficulty is that revenue and cost are not recognized simply based on invoices. They depend on projects, contracts, budgets, percent complete, change orders, retention, receivables, payables, and collections. Core conclusion: > General accounting looks at the company. Construction accounting must look at both the company and each project. WIP is the bridge between project operating reality and the financial statements. ### 9. Engineer's Data Model View Do not start by memorizing report layouts. Start with a data model: ```text jobs contracts change_orders budgets cost_codes cost_transactions commitments billings collections vendor_bills vendor_payments payroll gl_entries ``` Then treat reports as queries or views: ```text Balance Sheet = GL balances as of date Income Statement = GL activity over date range Cash Flow = cash movement + working capital changes WIP = job-level earned revenue and cost forecast Job Cost Detail = cost transaction drilldown AR Aging = unpaid customer invoices by age AP Aging = unpaid vendor bills by age Forecast = scheduled future revenue / cost / cash assumptions ``` ### 8. Ten-Week Learning Path #### Weeks 1-2: Basic Financial Statements Learn: - Balance Sheet - Income Statement - Cash Flow Statement - MTD / YTD / Multi-period - Actual vs Budget Output: - Generate the three statements from mock transactions. #### Weeks 3-4: Project Cost Model Learn: - Job - Contract - Budget - Cost Code - Cost Type - Actual Cost - Committed Cost - Change Orders Output: - Design a simple construction accounting schema. #### Weeks 5-6: WIP Learn: - Percent complete - Earned revenue - Overbilling / underbilling - Backlog - Gross profit forecast Output: - Generate Summary WIP and explain every column. #### Week 7: Job Drilldowns Learn: - Job Cost Detail - Job Budget Variance - Job Cost-to-Complete - Job Labor Report Output: - Drill from WIP into job-level details. #### Week 8: AR/AP Aging and Cash Learn: - AR Aging - AP Aging - Retention - Collection timing - Payment timing Output: - Explain why a profitable company can still run short of cash. #### Weeks 9-10: Future Reports Learn: - WIP Backlog - Forecasted Income Statement - Forecasted 13-week Cash Flow - Forecasted Balance Sheet Output: - Generate forecast reports from backlog and AR/AP schedules. ### 10. Minimal Implementable System If you want to learn with code, start with the smallest useful system: 1. Create transaction-level mock data. 2. Write GL posting logic. 3. Generate a Balance Sheet. 4. Generate an Income Statement. 5. Generate a Cash Flow Statement. 6. Add Job, Contract, Budget, and Cost Transaction. 7. Generate Summary WIP. 8. Drill from WIP into Job Cost Detail. 9. Add AR/AP Aging. 10. Add WIP Backlog and 13-week Cash Flow. --- ## Category 1 — Company-Level Past Reports Actual, historical, whole-company reporting — what the company owns and owes, whether it made money, and the company-wide working-capital/WIP position. Reproduced in full from Stages 1, 3, 5, and 6. ### Stage 1: The Three Core Financial Statements Goal: connect the three basic financial statements before going into full WIP detail. #### 1. Three Things to Remember First 1. The Balance Sheet shows a point-in-time state: what the company owns, what it owes, and its net worth. 2. The Income Statement shows operating results over a period: whether the company made or lost money. 3. The Cash Flow Statement shows cash movement over a period: where cash came from and where it went. Core relationships: ```text Assets = Liabilities + Equity Ending Cash = Beginning Cash + Cash In - Cash Out Net Income != Ending Cash - Beginning Cash ``` In construction, keep these three concepts separate: ```text Revenue = income recognized under accounting rules Billings = amounts invoiced to the customer Collections = cash actually received from the customer ``` They are often different numbers. #### 2. Finance Glossary | English | Meaning | | --- | --- | | Balance Sheet | What the company owns, owes, and is worth on a specific date | | Income Statement | Whether the company made or lost money over a period | | Cash Flow Statement | How cash moved in and out over a period | | Assets | Resources the company owns or controls | | Liabilities | Obligations the company owes or must perform | | Equity | Owner value after liabilities are subtracted from assets | | Cash | Bank and cash balances | | Beginning Cash | Cash at the start of a period | | Ending Cash | Cash at the end of a period | | Revenue | Amount earned under accounting rules | | Earned Revenue | Revenue that should be recognized based on progress | | Billings | Amount invoiced to customers | | Collections | Cash actually received from customers | | Direct Cost | Cost directly attributable to a project | | Gross Profit | Revenue minus direct cost | | Overhead / G&A | Company operating expenses not tied to one job | | Net Income | Profit after all costs and expenses | | Accounts Receivable / AR | Invoiced amounts not yet collected | | Accounts Payable / AP | Vendor bills not yet paid | | Billings in Excess of Earned Revenue | Overbilling; a liability-like balance | | Costs and Earnings in Excess of Billings | Underbilling; an asset-like balance | | Percent Complete | Current project completion percentage | | Cost to Date | Cumulative cost incurred so far | | Estimated Total Cost | Expected final project cost | #### 3. Revenue, Billings, and Collections These are the easiest concepts to mix up in construction finance. Think of them as three different timelines: ```text Revenue = how much work has been earned for accounting purposes Billings = how much the customer has been asked to pay Collections = how much cash has arrived ``` They answer different questions: ```text Revenue -> How much work has been completed? Billings -> How much has been invoiced? Collections -> How much cash has been received? ``` ##### 3.1 Revenue: Earned, Not Invoiced Construction projects often take months or years, so revenue usually cannot be treated as equal to invoice amount. Example: ```text Contract amount: 200,000 Estimated total cost: 150,000 Cost to date: 60,000 ``` Using cost-based percent complete: ```text Percent Complete = 60,000 / 150,000 = 40% Revenue = 200,000 * 40% = 80,000 ``` The full contract is 200,000, but only 40% is complete, so accounting revenue is 80,000. Revenue cares about: ```text Project progress Cost incurred Estimated total cost Contract amount ``` It does not directly care whether the customer has paid. ##### 3.2 Billings: Invoiced, Not Earned Billings are formal payment requests to the customer. In construction: ```text The company has submitted an invoice or progress billing to ask the customer for payment. ``` Common terms: ```text Billing Invoice Progress Billing ``` Example: ```text Contract amount: 200,000 Current progress billing: 100,000 Billings = 100,000 ``` After billing, the customer may not pay immediately: ```text Billings: 100,000 Collections: 80,000 Accounts Receivable: 20,000 ``` ```text Accounts Receivable = Billings - Collections Accounts Receivable = 100,000 - 80,000 = 20,000 ``` If: ```text Billings = 100,000 Revenue = 80,000 ``` Then billings exceed earned revenue: ```text Overbilling = 100,000 - 80,000 = 20,000 ``` This 20,000 is not revenue. It is Billings in Excess of Earned Revenue, which is closer to a liability because the company still needs to perform the related work. If: ```text Revenue = 80,000 Billings = 60,000 ``` Then: ```text Underbilling = 80,000 - 60,000 = 20,000 ``` The company has earned revenue but has not invoiced enough yet. This is usually asset-like. ##### 3.3 Collections: Cash, Not Profit Collections are cash received. Example: ```text Billings = 100,000 Collections = 80,000 Accounts Receivable = 20,000 ``` Collections affect cash. They do not directly determine profit. If: ```text Revenue = 80,000 Cost = 60,000 Collections = 80,000 ``` Then: ```text Net Income = 80,000 - 60,000 = 20,000 ``` The customer paid 80,000, but the company also incurred 60,000 of cost. Collections are not profit. ##### 3.4 One Example ```text Contract amount: 200,000 Estimated total cost: 150,000 Cost to date: 60,000 Billings to date: 100,000 Collections to date: 80,000 ``` Revenue: ```text Percent Complete = 60,000 / 150,000 = 40% Revenue = 200,000 * 40% = 80,000 ``` Billings: ```text Billings = 100,000 Revenue = 80,000 Overbilling = 20,000 ``` Collections: ```text Collections = 80,000 Billings = 100,000 Accounts Receivable = 20,000 ``` Current state: ```text Revenue: 80,000 Billings: 100,000 Collections: 80,000 ``` All three numbers are valid, but they mean different things. ##### 3.5 How to Read Them ```text Revenue vs Billings ``` Shows whether the project is overbilled or underbilled. ```text Billings vs Collections ``` Shows how much the customer still owes. ```text Revenue vs Cost ``` Shows whether the project is profitable so far. One-line memory aid: ```text Revenue is earned. Billings are requested. Collections are received. ``` #### 4. Exercise Data ```text Beginning cash: 100,000 Project contract: 200,000 Estimated total project cost: 150,000 Billings to date: 100,000 Collections to date: 80,000 Vendor bills: 60,000 Vendor payments: 40,000 ``` To avoid full WIP complexity for now, use this minimal revenue recognition assumption: ```text Cost to Date = 60,000 Estimated Total Cost = 150,000 Percent Complete = 60,000 / 150,000 = 40% Earned Revenue = 200,000 * 40% = 80,000 ``` So: ```text Billings = 100,000 Revenue = 80,000 Collections = 80,000 Cost = 60,000 Profit = 20,000 ``` #### 5. Income Statement The Income Statement reports operating results over a period. It asks: ```text During this period, did the company make or lose money from operations? ``` Core idea: ```text Revenue - Cost - Expense = Profit ``` It is not asking: ```text How much did the customer pay? How much did the bank account increase? How much was invoiced? ``` It asks whether the economic value earned during the period exceeded the resources consumed to earn it. ##### 5.1 Revenue Revenue is the amount accounting says the company has earned. In construction, revenue usually does not equal collections or billings. Example: ```text Project contract: 200,000 Estimated total cost: 150,000 Cost to date: 60,000 Percent Complete = 60,000 / 150,000 = 40% Earned Revenue = 200,000 * 40% = 80,000 ``` So Income Statement revenue is: ```text Revenue = 80,000 ``` ##### 5.2 Direct Cost Direct Cost is cost directly attributable to the project: ```text Labor Materials Subcontractors Equipment Site-related project cost ``` In this example: ```text Vendor bills: 60,000 Vendor payments: 40,000 Direct Cost = 60,000 Cash Paid to Vendors = 40,000 ``` The Income Statement recognizes cost when resources are consumed, not when cash is paid. ##### 5.3 Gross Profit ```text Gross Profit = Revenue - Direct Cost Gross Profit = 80,000 - 60,000 = 20,000 ``` Gross Profit asks whether project delivery itself is profitable before company overhead. ##### 5.4 Overhead / G&A Overhead / G&A are company operating expenses not directly tied to one job: ```text Office rent Headquarters payroll Finance, HR, legal Software Insurance Administrative costs Sales and management expenses ``` For this simplified example: ```text Overhead / G&A = 0 Net Income = Gross Profit ``` In a real company: ```text Gross Profit = 20,000 Overhead / G&A = 8,000 Net Income = 12,000 ``` ##### 5.5 Net Income ```text Net Income = Revenue - Direct Cost - Overhead / G&A Net Income = 80,000 - 60,000 - 0 = 20,000 ``` Net Income increases Equity, assuming no distributions: ```text Equity = Opening Equity + Current Net Income Equity = 100,000 + 20,000 = 120,000 ``` Profit increases owner value, but it does not necessarily become cash immediately. ##### 5.6 Example Income Statement | Line Item | Amount | | --- | ---: | | Revenue | 80,000 | | Direct Cost | 60,000 | | Gross Profit | 20,000 | | Overhead / G&A | 0 | | Net Income | 20,000 | Observations: - Profit comes from revenue minus cost, not from collections. - Billings are 100,000, but revenue is only 80,000. - Collections are 80,000 in this example, but that is not profit. #### 6. Balance Sheet The Balance Sheet is a point-in-time financial snapshot. It asks: ```text On a specific date, what does the company own, what does it owe, and what belongs to the owner/shareholders? ``` Core formula: ```text Assets = Liabilities + Equity ``` A first-principles interpretation: ```text Assets show where resources are. Liabilities + Equity show who provided those resources. ``` ##### 6.1 Assets Assets are resources the company owns or controls. Common construction assets: ```text Cash Accounts Receivable / AR Retention Receivable Inventory Costs and Earnings in Excess of Billings Equipment Prepaid Expenses ``` In this example: ```text Cash = 140,000 Accounts Receivable = 20,000 Total Assets = 160,000 ``` Accounts Receivable is an asset, but it is not cash. Retention receivable and underbilling are also asset-like, but their quality depends on whether they can be invoiced and collected. ##### 6.2 Liabilities Liabilities are amounts the company owes or obligations it must perform. Common construction liabilities: ```text Accounts Payable / AP Debt Accrued Expenses Payroll Payable Taxes Payable Billings in Excess Deferred Revenue ``` In this example: ```text Accounts Payable = 20,000 Billings in Excess = 20,000 Total Liabilities = 40,000 ``` Billings in Excess is liability-like because the customer has been billed more than the revenue earned by progress. The company still must perform the work behind that extra billing. ##### 6.3 Equity Equity is the owner/shareholder value after liabilities are deducted from assets: ```text Equity = Assets - Liabilities ``` Common components: ```text Opening Equity Owner Contributions Retained Earnings Current Net Income ``` In this example: ```text Opening Equity = 100,000 Current Net Income = 20,000 Total Equity = 120,000 ``` ##### 6.4 Example Balance Sheet | Assets | Amount | | --- | ---: | | Cash | 140,000 | | Accounts Receivable | 20,000 | | Total Assets | 160,000 | | Liabilities + Equity | Amount | | --- | ---: | | Accounts Payable | 20,000 | | Billings in Excess of Earned Revenue | 20,000 | | Opening Equity | 100,000 | | Current Net Income | 20,000 | | Total Liabilities + Equity | 160,000 | Calculations: ```text Cash = 100,000 + 80,000 - 40,000 = 140,000 Accounts Receivable = 100,000 - 80,000 = 20,000 Accounts Payable = 60,000 - 40,000 = 20,000 Billings in Excess = 100,000 - 80,000 = 20,000 Equity = Opening Equity + Net Income = 100,000 + 20,000 = 120,000 ``` Validation: ```text Assets 160,000 = Liabilities 40,000 + Equity 120,000 ``` ##### 6.5 Why the Balance Sheet Must Balance Every asset has a source. If the company has 160,000 of assets, those assets must come from: ```text Liabilities: resources provided by others Equity: resources owned by the company/owners ``` If the Balance Sheet does not balance, at least one asset, liability, equity movement, revenue, cost, cash inflow, or cash outflow is missing or wrong. The Balance Sheet is therefore a basic data integrity check. ##### 6.6 Construction Balance Sheet Focus Construction companies pay special attention to: ```text Accounts Receivable Retention Receivable Accounts Payable Overbilling Underbilling Cash Debt ``` Key questions: ```text How much do customers owe us? How much do we owe vendors? Are we overbilled? Have we done work that has not been billed? Is there enough cash to support projects? Has profit turned into cash? ``` #### 7. Cash Flow Statement Direct method: | Cash Flow | Amount | | --- | ---: | | Beginning Cash | 100,000 | | Cash Collected from Customer | 80,000 | | Cash Paid to Vendors | -40,000 | | Ending Cash | 140,000 | Indirect method: | Operating Cash Flow | Amount | | --- | ---: | | Net Income | 20,000 | | Increase in Accounts Receivable | -20,000 | | Increase in Accounts Payable | 20,000 | | Increase in Billings in Excess | 20,000 | | Operating Cash Flow | 40,000 | Observation: ```text Net Income = 20,000 Operating Cash Flow = 40,000 Cash increased by 40,000 ``` Profit and cash differ because: - 20,000 of billings have not been collected, so AR increased and consumed cash. - 20,000 of vendor bills have not been paid, so AP increased and temporarily provided cash. - 20,000 of billings have not yet been earned, so Billings in Excess increased and temporarily provided cash. #### 8. Three Key Questions ##### Why Are Profit and Cash Different? Profit follows accrual accounting. Cash follows actual receipts and payments. In this example, the company earned 20,000 of profit but cash increased by 40,000 because it still owes vendors 20,000 and has 20,000 of overbilling liability. ##### Why Are Billings Different from Revenue? Billings are payment requests to the customer. Revenue is the amount accounting says has been earned. In this example, billings are 100,000 but earned revenue is only 80,000. The extra 20,000 is not revenue; it is a liability-like overbilling balance. ##### Why Are Collections Different from Profit? Collections are cash receipts. They do not mean all the money has been earned, and they do not ignore cost. In this example, the company collected 80,000, incurred 60,000 of cost, and earned 20,000 of profit. #### 9. Checklist - Explain `Assets = Liabilities + Equity`. - Distinguish `Revenue`, `Billings`, and `Collections`. - Explain why an increase in AR reduces operating cash flow. - Explain why an increase in AP increases operating cash flow. - Use one set of numbers to generate a Balance Sheet, Income Statement, and Cash Flow Statement. ### Stage 3: WIP (Work in Progress) #### 1. Stage Goal Stage 3 moves into Summary WIP — putting multiple projects into one WIP schedule: ```text How far along is each project? How much profit is each project expected to make? How much revenue should be recognized now? Are billings ahead of or behind revenue? What risks exist across the project portfolio? ``` #### 2. First Principles: What WIP Really Is WIP is not just a project list. First principles: ```text Construction projects span multiple accounting periods. Revenue, cost, billings, and collections do not naturally move together. WIP translates real project progress into the revenue, assets, and liabilities that should appear in the financial statements. ``` WIP is a bridge: ```text Project operating reality -> Accounting revenue recognition -> Financial statements ``` The core WIP question is not: ```text How much has this project billed? How much cash has this project collected? ``` The real question is: ```text Based on current completion, how much revenue should this project have earned? How does that amount compare with billings to date? ``` The key point: ```text WIP is centered on the gap between Earned Revenue and Billings. ``` ##### 2.1 What happens without WIP? Assume a project: ```text Contract amount: 1,000,000 Estimated total cost: 800,000 Cost incurred this period: 400,000 Billings this period: 700,000 Collections this period: 600,000 ``` If you look only at billings, you may think: ```text Revenue = 700,000 ``` If you look only at collections, you may think: ```text Revenue = 600,000 ``` But from project progress: ```text Percent Complete = 400,000 / 800,000 = 50% Earned Revenue = 1,000,000 * 50% = 500,000 ``` So: ```text Revenue earned by progress is 500,000 Of the 700,000 billed, 200,000 is ahead of earned revenue Some of the cash collected also relates to work not yet earned ``` Without WIP, the company may confuse the billing schedule with actual operating performance. First principles: ```text Billing is a commercial action. Collection is a cash action. Revenue recognition is the accounting expression of performance progress. WIP keeps these three things separate. ``` ##### 2.2 Why use cost-to-cost percent complete? In many construction projects, the most observable progress signal is not elapsed time. It is how much cost has been consumed to complete the work. That is why WIP often uses: ```text Percent Complete = Cost to Date / Estimated Cost at Completion ``` The logic: ```text If the project is expected to cost 800,000 in total, and 400,000 has already been incurred, then the project is roughly 50% complete. ``` This is not a perfect truth. It is an accounting estimate model. It depends on: ```text Reliable cost estimates Accurate cost-to-date records Timely updates to estimated cost to complete A reasonable relationship between cost incurred and work performed ``` So WIP quality depends heavily on Estimated Cost to Complete. If estimated remaining cost is understated: ```text Estimated Cost at Completion is too low Percent Complete is too high Earned Revenue is too high Profit is recognized too early ``` This is why WIP is not just a report. It is a management judgment system. ##### 2.3 Why is overbilling a liability? Overbilling means: ```text Billings > Earned Revenue ``` First principles: ```text The customer has been billed for more than the company has earned through performance. ``` The excess is not profit and not earned revenue. It is an obligation to perform future work. Example: ```text Billings = 700,000 Earned Revenue = 500,000 Overbilling = 200,000 ``` The economic meaning of the 200,000 is: ```text The customer is ahead of the project progress under the billing schedule. The company still has to perform work before it truly earns that amount. ``` That is why overbilling usually appears on the liability side of the Balance Sheet. ##### 2.4 Why is underbilling an asset? Underbilling means: ```text Earned Revenue > Billings ``` First principles: ```text The company has performed and earned value, but has not billed the customer enough yet. ``` Example: ```text Earned Revenue = 500,000 Billings = 420,000 Underbilling = 80,000 ``` The economic meaning of the 80,000 is: ```text The company has created economic value that should be collectible, but it has not yet turned that value into formal billings. ``` So it usually appears on the asset side of the Balance Sheet, often as: ```text Costs and Earnings in Excess of Billings ``` But be careful: ```text Underbilling is an asset, but it is not guaranteed cash. ``` If it comes from unapproved change orders, customer disputes, or bad estimates, the asset quality may be weak. ##### 2.5 WIP's core risk: estimation errors compound WIP is not pure fact recording. It contains many estimates: ```text Estimated Cost to Complete Estimated Cost at Completion Percent Complete Earned Revenue Estimated Gross Profit ``` These estimates are chained together. One bad estimate can compound through the formulas: ```text Estimated remaining cost is understated -> Estimated cost at completion is understated -> Percent complete is overstated -> Earned revenue is overstated -> Gross profit is overstated -> Underbilling may be overstated -> The financial statements look better than reality ``` So when reading WIP, do not only read the final numbers. Ask: ```text Who updated estimated cost to complete? How often is it updated? Are there unapproved change orders? Have all costs been posted? Is the project manager underestimating cost to finish? ``` First-principles summary: ```text The value of WIP is not the table itself. The value of WIP is that it exposes timing mismatches, estimate changes, and revenue recognition risk in long-duration projects. ``` #### 3. The 10 Questions WIP Answers A Summary WIP schedule usually answers: ```text 1. What is the project contract amount? 2. What is the budgeted cost? 3. How much cost has been incurred? 4. How much cost remains? 5. What is the estimated final cost? 6. What is the estimated project profit? 7. What is the percent complete? 8. How much revenue should be recognized? 9. How much has been billed? 10. Is the project overbilled or underbilled, and how much backlog remains? ``` These questions fall into three groups: ```text Contract side: Contract, Change Orders, Revised Contract Cost side: Budget, Cost to Date, Estimated Cost to Complete, Estimated Cost at Completion Revenue / billing side: Percent Complete, Earned Revenue, Billings, Overbilling / Underbilling, Backlog ``` #### 4. Minimum WIP Fields A minimum WIP schedule keeps only the fields needed to run the core logic: | Field | Meaning | Purpose | | --- | --- | --- | | Job | Project number | Identifies the project | | Contract | Contract amount | Basis for revenue recognition | | Budget Cost | Budgeted cost | Original cost plan, compared with final cost estimate | | Cost to Date | Cost incurred to date | Resources already consumed | | Est. Cost to Complete | Estimated cost to complete | Remaining cost required to finish | | Est. Cost at Completion | Estimated cost at completion | Current estimate of final total cost | | % Complete | Percent complete | Current completion level | | Earned Revenue | Revenue earned / recognized | Revenue that should be recognized based on progress | | Billings | Billings to date | Amount requested from the customer | | Over/Under Billing | Billing gap | Difference between billings and earned revenue | | Gross Profit | Gross profit | Current or estimated project profit | | Backlog | Remaining contract value | Contract value not yet earned | Important: ```text A minimum WIP is not trying to include every possible field. It is trying to make revenue recognition, billing differences, and project profit clear. ``` #### 5. Core Formulas ```text Estimated Cost at Completion = Cost to Date + Estimated Cost to Complete Percent Complete = Cost to Date / Estimated Cost at Completion Earned Revenue = Contract * Percent Complete Estimated Gross Profit = Contract - Estimated Cost at Completion Gross Margin = Estimated Gross Profit / Contract Overbilling = Billings - Earned Revenue Underbilling = Earned Revenue - Billings Backlog = Contract - Earned Revenue ``` Decision rules: ```text Billings > Earned Revenue => Overbilling, usually a liability Earned Revenue > Billings => Underbilling, usually an asset Billings = Earned Revenue => Billings and revenue recognition are aligned ``` The formulas are not parallel. They form a dependency chain: ```text Contract -> Estimated Cost at Completion -> Percent Complete -> Earned Revenue -> Overbilling / Underbilling -> Balance Sheet classification ``` When reading WIP, follow that chain: ```text Is the contract amount correct? Is the final cost estimate reliable? Is percent complete credible? Is earned revenue overstated? Is the billing difference normal timing or a risk signal? ``` #### 6. Reading One WIP Row from First Principles One WIP row is not a set of independent fields. It is a chain from contract value to financial statement impact. Read it in six steps. ##### 6.1 Step 1: Start with Contract, the revenue ceiling ```text Contract = the price the customer has committed to pay for the current scope ``` First principles: ```text Without contract value, there is no economic basis for revenue recognition. ``` Ask: ```text Does the contract include approved change orders? Have unapproved change orders been included too early? Are there contract reductions, disputes, or scope changes? ``` If Contract is overstated, Earned Revenue, Gross Profit, and Backlog will also be overstated. ##### 6.2 Step 2: Read Estimated Cost at Completion as cost reality ```text Estimated Cost at Completion = Cost to Date + Estimated Cost to Complete ``` First principles: ```text Project profitability is not determined by how much has been spent so far. It is determined by how much the whole project will cost when finished. ``` The most important and most easily over-optimistic field is: ```text Estimated Cost to Complete ``` Ask: ```text Are all remaining subcontract commitments included? Are material price increases reflected? Are rework, acceleration, and claim costs included? Has the project manager updated the estimate based on current site reality? ``` ##### 6.3 Step 3: Derive Percent Complete from cost ```text Percent Complete = Cost to Date / Estimated Cost at Completion ``` First principles: ```text Percent complete should not be a feeling. It estimates performance progress from consumed resources as a share of total expected resources. ``` But it is not mechanical truth. If large materials were purchased but not installed: ```text Cost to Date may be high Actual field progress may be lower ``` If costs have not yet been posted: ```text Cost to Date may be understated Actual field progress may be understated ``` So Percent Complete must be checked against field reality. ##### 6.4 Step 4: Derive Earned Revenue from progress ```text Earned Revenue = Contract * Percent Complete ``` First principles: ```text Revenue should follow performance progress, not billings or cash collections. ``` This step translates project reality into income statement revenue. If Percent Complete is too high: ```text Earned Revenue is too high Gross Profit is too high Underbilling may be too high The financial statements improve too early ``` Earned Revenue is one of the core outputs of WIP. ##### 6.5 Step 5: Compare Earned Revenue with Billings ```text Billings > Earned Revenue => Overbilling Earned Revenue > Billings => Underbilling ``` First principles: ```text Earned Revenue is how much revenue should be recognized. Billings is how much has been requested from the customer. The difference shows the timing mismatch between operating progress and commercial billing. ``` This difference determines the balance sheet classification: ```text Overbilling -> liability Underbilling -> asset ``` ##### 6.6 Step 6: Read Backlog as remaining risk ```text Backlog = Contract - Earned Revenue ``` First principles: ```text Backlog is contract value that has not yet been performed and may become future revenue. ``` More backlog means more remaining work, but it is not automatically good. Ask: ```text What is the margin on the remaining backlog? How much cost is required to complete it? Are there unapproved changes, schedule pressure, or claim risks? ``` The goal of reading a WIP row is not just to calculate a number. The goal is to judge: ```text Is revenue recognition reasonable? Is estimated profit reliable? Is the billing gap healthy? Does the remaining work carry risk? ``` #### 7. Five Mock Projects The exercise script uses five mock projects: ```text J-300: Healthy project, good margin, slight overbilling. J-301: Underbilled project, revenue recognition is ahead of billings, cash flow needs attention. J-302: Nearly complete project, small backlog, billings slightly ahead. J-303: Early-stage project, low cost to date, large backlog, high estimate risk. J-304: Low-margin risk project; billings are close to revenue, but final profit is thin. ``` Each project defines: ```text Contract amount Budget cost Cost to date Estimated cost to complete Billings to date ``` Then the script calculates: ```text Estimated Cost at Completion Percent Complete Earned Revenue Estimated Gross Profit Gross Margin Overbilling / Underbilling Backlog ``` #### 8. How to Read WIP Risk ##### 8.1 Watch for margin fade If: ```text Contract = 1,000,000 Budget Cost = 800,000 Estimated Cost at Completion = 950,000 ``` The original expected profit was: ```text Original Expected Profit = 1,000,000 - 800,000 = 200,000 ``` The current estimated gross profit is: ```text Estimated Gross Profit = 1,000,000 - 950,000 = 50,000 ``` The project has lost 150,000 of expected margin. This is usually more important than simply asking how much cost has been incurred so far. ##### 8.2 Watch for large underbilling Underbilling means: ```text Revenue has been recognized based on progress, but the project has not billed the customer enough yet. ``` It may be a normal timing difference, or it may signal risk: ```text Progress billing has not been submitted on time Change orders are not approved yet Cost or progress estimates are too optimistic Revenue recognition is ahead of customer approval ``` Underbilling can make the income statement show profit before cash comes back. ##### 8.3 Do not treat overbilling as automatically good Overbilling means: ```text Billings exceed earned revenue. ``` It may improve cash flow, but it also means: ```text The company still has to perform the remaining work. ``` So overbilling is not purely good or bad. Read it together with: ```text Is the remaining cost estimate reasonable? Is the project at risk of losing money? Has the customer actually paid? Is future execution under control? ``` ##### 8.4 Check backlog quality Backlog is remaining contract value that has not yet been earned. But backlog is not cash, and it is not profit. Ask: ```text Is the backlog high-margin or low-margin? Are remaining cost estimates reliable? Are there change order disputes? Can the project be delivered as planned? ``` #### 9. How WIP Connects to the Three Financial Statements WIP flows into the company financial statements. ```text Earned Revenue ``` flows into Revenue on the Income Statement. ```text Cost to Date ``` flows into Direct Cost on the Income Statement. ```text Underbilling ``` flows into an asset on the Balance Sheet: ```text Costs and Earnings in Excess of Billings ``` ```text Overbilling ``` flows into a liability on the Balance Sheet: ```text Billings in Excess of Costs and Earnings ``` ```text Billings - Collections ``` flows into Accounts Receivable on the Balance Sheet. ```text Collections ``` flows into operating cash flow on the Cash Flow Statement. Therefore: ```text WIP is not an isolated project report. WIP is the core basis for revenue recognition and balance sheet classification in construction accounting. ``` #### 10. Run the Exercise Script Run: ```bash node stage3/summary_wip.js ``` The script outputs: ```text One Summary WIP row per project Portfolio totals Risk flags ``` #### 11. Checklist - Explain why WIP is the bridge between project reality and financial statements. - Calculate `% Complete` using the cost-to-cost method. - Calculate `Earned Revenue` from `% Complete`. - Identify `Overbilling` and `Underbilling`. - Explain why `Overbilling` is usually a liability. - Explain why `Underbilling` is usually an asset. - Explain why `Backlog` is not cash and not accounts receivable. - Identify WIP risks such as margin fade, high underbilling, and low-margin projects. ### Stage 5: AR Aging, AP Aging, and Retention #### 1. Stage Goal Stage 5 is about cash pressure. Even when the Income Statement shows profit, WIP shows project margin, and the job reports explain cost and budget risk, a construction company can still run short of cash. Why: ```text Revenue recognized does not mean the customer has paid. Profit does not mean cash has arrived. Vendor bills may be due before customer cash comes in. Retention is receivable, but may not be collectible soon. ``` This stage focuses on: ```text AR Aging AP Aging Retention ``` #### 2. First Principles: Why Profit Does Not Mean Cash Safety First principles: ```text Profit measures whether value was created. Cash measures whether the company can survive. ``` A construction company can have: ```text profit on the income statement project margin on WIP customer receivables getting older vendor bills coming due cash getting tighter ``` Stage 5 shifts from profitability to cash conversion. Core questions: ```text How much do customers owe us? How long have they owed it? How much is retention and not collectible yet? How much do we owe vendors? When are vendor bills due? Can customer collections cover vendor payments? ``` Key point: ```text Aging reports are not profit reports. Aging reports are cash pressure maps. ``` ##### 2.1 The chain from profit to cash From first principles, the construction cash conversion chain is: ```text Perform work -> recognize revenue -> bill the customer -> customer approval -> customer payment -> cash in bank ``` If any step slows down, cash pressure appears. Examples: ```text Work is performed, but not billed yet => WIP may show underbilling Invoice is issued, but customer has not paid => AR increases Customer approved the work, but withheld retention => Retention Receivable increases Customer has not paid, but vendor bills are due => cash gap appears ``` So Stage 5 is not asking only whether profit exists. It asks: ```text How long does profit take to become usable cash, and how much friction is in the way? ``` ##### 2.2 Three sources of cash pressure Cash pressure usually comes from three timing mismatches: ```text 1. Revenue and billing mismatch Revenue has been earned, but not billed. 2. Billing and collection mismatch Invoice has been issued, but the customer has not paid. 3. Collection and payment mismatch Customer has not paid, but vendors, payroll, and taxes are due. ``` WIP mainly explains the first mismatch. AR Aging mainly explains the second mismatch. AP Aging mainly explains the third mismatch. Retention can amplify both the second and third mismatches. #### 3. Minimum Data Model for Aging AR Aging and AP Aging start at the invoice / bill level. Minimum AR invoice fields: | Field | Meaning | Purpose | | --- | --- | --- | | Customer | Customer | Who owes us money | | Job | Project | Which project the receivable belongs to | | Invoice Date | Invoice date | When the invoice was issued | | Due Date | Due date | When payment is due | | Invoice Amount | Invoice amount | Amount billed to the customer | | Collections | Collections | Amount already paid | | Retention Receivable | Retention receivable | Amount withheld by the customer | | Open AR | Open ordinary AR | Uncollected amount excluding retention | Minimum AP vendor bill fields: | Field | Meaning | Purpose | | --- | --- | --- | | Vendor | Vendor | Who we owe | | Job | Project | Which project the bill belongs to | | Bill Date | Bill date | When the vendor billed us | | Due Date | Due date | When payment is due | | Bill Amount | Bill amount | Amount billed by the vendor | | Payments | Payments | Amount already paid | | Retention Payable | Retention payable | Amount we withhold from vendor payment | | Open AP | Open ordinary AP | Unpaid amount excluding retention | First principles: ```text Aging is not based on revenue recognition date. Aging is based on the distance between due date and the current as-of date. ``` ##### 3.1 Days Past Due Core formula: ```text Days Past Due = As Of Date - Due Date ``` It answers: ```text As of the report date, how many days late is this receivable or payable relative to the agreed payment due date? ``` Concepts: ```text As Of Date The report cutoff date. It is the date from which you evaluate all receivables and payables. Due Date The payment due date. It is the date when the invoice or bill should be paid under the contract or payment terms. ``` Example: ```text As Of Date = 2026-06-14 Due Date = 2026-05-20 Days Past Due = 25 ``` This item is 25 days past due. Bucket rules: ```text Days Past Due <= 0 => Current 1 to 30 days => 1-30 31 to 60 days => 31-60 61 to 90 days => 61-90 More than 90 days => 90+ ``` Examples: ```text As Of Date = 2026-06-14 Due Date = 2026-06-24 Days Past Due = -10 Bucket = Current ``` It is not due yet, so it is Current. ```text As Of Date = 2026-06-14 Due Date = 2026-05-20 Days Past Due = 25 Bucket = 1-30 ``` It is 25 days past due, so it belongs in 1-30. ```text As Of Date = 2026-06-14 Due Date = 2026-03-31 Days Past Due = 75 Bucket = 61-90 ``` It is 75 days past due, so it belongs in 61-90. First principles: ```text Aging is not based on how long ago the invoice was issued. Aging is based on how long the item is past its due date. ``` The same invoice date can produce different aging results if payment terms differ: ```text Invoice Date = 2026-05-01 Terms = Net 30 Due Date = 2026-05-31 As Of Date = 2026-06-14 Days Past Due = 14 Bucket = 1-30 ``` But with Net 60 terms: ```text Invoice Date = 2026-05-01 Terms = Net 60 Due Date = 2026-06-30 As Of Date = 2026-06-14 Days Past Due = -16 Bucket = Current ``` The key date is not Invoice Date. The key date is Due Date. One-line memory: ```text Days Past Due measures how late a receivable or payable is relative to its agreed payment date. ``` ##### 3.2 Split open amount into ordinary AR/AP and retention Do not only calculate: ```text Open Amount = Invoice Amount - Collections ``` It is more useful to split: ```text Open Ordinary AR = Invoice Amount - Collections - Retention Receivable Retention Receivable = receivable withheld by contract and released later ``` AP is similar: ```text Open Ordinary AP = Bill Amount - Payments - Retention Payable Retention Payable = vendor amount withheld by the company and paid later ``` First principles: ```text Ordinary AR/AP is a short-term payment timing issue. Retention is a contractual release-condition issue. They have different cash behavior and should not be blended into one open amount. ``` #### 4. AR Aging AR Aging answers: ```text How much do customers owe us, and how old is it? ``` Common buckets: ```text Current 1-30 31-60 61-90 90+ Retention Receivable ``` Calculation: ```text Days Past Due = As Of Date - Due Date ``` Classification: ```text Days Past Due <= 0 => Current 1 to 30 days => 1-30 31 to 60 days => 31-60 61 to 90 days => 61-90 More than 90 days => 90+ ``` First principles: ```text AR is an asset, but older AR is lower-quality asset. ``` Why: ```text Older receivables are more likely to be disputed. Older receivables are harder to collect. Older receivables cannot pay payroll, subcontractors, or material bills on time. ``` When reading AR Aging, do not only read the total. Ask: ```text How much is current? How much is over 60 days? How much is over 90 days? Is old AR concentrated in one customer? Does old AR come from pending change orders? Is old AR actually retention? ``` ##### 4.1 AR quality tiers AR Aging is not just sorting money by age. It evaluates asset quality. A rough quality view: ```text Current Inside normal credit terms, highest quality. 1-30 Slightly late; needs follow-up, but usually not dangerous yet. 31-60 Needs management attention; may indicate approval, documentation, or customer cash issues. 61-90 Clear risk zone; requires an owner, collection plan, and dispute reason. 90+ High-risk asset; may require allowance, legal follow-up, or project-level review. Retention Not ordinary past due; release conditions have not been met. ``` First principles: ```text The AR balance tells you how much the customer owes. AR aging tells you how hard it may be to turn that amount into cash. ``` ##### 4.2 Common root causes of old AR Old AR is usually not just "the customer is slow." Common causes: ```text incomplete invoice documentation long customer approval workflow disputed work progress unapproved change order unfinished punch list pay application does not match contract requirements customer cash constraints project manager did not follow up ``` When you see 90+ AR, ask: ```text Is this a collection issue, contract issue, delivery issue, or accounting classification issue? ``` #### 5. AP Aging AP Aging answers: ```text How much do we owe vendors, and when must we pay? ``` Common buckets: ```text Current 1-30 31-60 61-90 90+ Retention Payable ``` First principles: ```text AP is short-term financing from other parties. But it is not free, unlimited financing. ``` If AP Aging is old, it may mean: ```text cash is tight vendor relationships are deteriorating subcontractors may stop work credit terms may tighten execution risk is increasing ``` When reading AP Aging, ask: ```text Which vendors are coming due soon? Which AP is over 60 days? Are critical subcontractors past due? Does AP timing match AR collection timing? Is the company hiding cash pressure by delaying vendor payments? ``` ##### 5.1 AP payment priority AP Aging is not simply "pay the oldest bill first." Payment priority also depends on: ```text whether the vendor is critical whether nonpayment affects field execution whether it can trigger work stoppage or lien rights whether discounts or penalties apply whether payment is tied to customer collection whether quality or contract disputes exist ``` First principles: ```text AP payment is not just an accounting action. It is cash allocation and project execution risk management. ``` ##### 5.2 AP Aging can also be misread High AP is not always bad. If: ```text most AP is current vendor terms are normal customer collections can cover payments ``` the company may be using vendor credit appropriately. But if: ```text large AP has moved into 61-90 or 90+ critical vendors are past due the company is preserving cash by delaying payments ``` that is a cash pressure signal. The key is not total AP. The key is: ```text due-date structure vendor criticality match with AR collection timing ``` #### 6. Retention Retention is a special source of cash pressure in construction. It can appear on both sides: ```text Retention Receivable Money the customer withholds from us and will pay later. Retention Payable Money we withhold from vendors or subcontractors and will pay later. ``` First principles: ```text Retention is a contract-driven cash delay. It does not mean the project failed to earn value; it means earned cash is temporarily restricted. ``` Example: ```text Approved work value this period: 100,000 Retention Rate: 10% Current payment or ordinary AR: 90,000 Retention Receivable: 10,000 ``` Retention Receivable is an asset, but its cash quality is lower than ordinary current AR. Why: ```text It may require project completion. It may require owner acceptance. It may require punch list completion. It may require warranty period expiration. ``` Retention often does not need a separate report because it usually appears as: ```text a special AR Aging column a special AP Aging column or a subcategory of AR/AP ``` ##### 6.1 Meaning of net retention Read both: ```text Retention Receivable Retention Payable ``` Net impact: ```text Net Retention Cash Delay = Retention Receivable - Retention Payable ``` If: ```text Retention Receivable > Retention Payable ``` customers are withholding more from the company than the company is withholding from vendors. This ties up net cash. If: ```text Retention Payable > Retention Receivable ``` the company is temporarily withholding more from vendors than customers are withholding from the company. This can ease cash pressure in the short term, but it still must be paid later. First principles: ```text Retention is not a profit issue. Retention is a delay in cash control. ``` ##### 6.2 Release conditions matter more than the balance When you see retention, ask: ```text When will it be released? What condition must be satisfied? Does it require final acceptance? Is there a punch list? Is there a warranty period? Does subcontractor retention release at the same time? ``` Retention released in 30 days and retention released in 12 months have very different cash quality. #### 7. Reading AR, AP, and Retention Together Do not read AR alone. Do not read AP alone. Read them together: ```text When will customers pay us? When do we have to pay vendors? How much retention are customers withholding from us? How much retention are we withholding from vendors? Where does the cash gap appear? ``` First principles: ```text Cash pressure comes from timing mismatch. ``` Dangerous combination: ```text AR is old AP is coming due Retention Receivable is high Retention Payable is low ``` Meaning: ```text Customer cash is not coming in. Vendor cash must go out soon. The company cannot offset much by withholding vendor retention. Cash pressure may hit suddenly. ``` Key observations: ```text A profitable company can still be cash-poor when AR aging is old. A company with backlog can still be cash-poor when collections are slow. Retention receivable cannot pay payroll or vendors in the short term. ``` ##### 7.1 Simple cash pressure framework Use four steps: ```text 1. Check near-term collections How much Current AR + 1-30 AR is reliable? 2. Check near-term payments How much Current AP + past due AP must be paid? 3. Check locked cash How much Retention Receivable cannot be released soon? 4. Check mismatch Is old AR larger than deferrable AP? ``` A simplified view: ```text Short-term Cash Gap = Current / near-term AP - reliable near-term AR collections + payroll / tax / overhead cash needs ``` This is not meant to be exact. It reminds you: ```text Total AR cannot directly pay AP. Only AR that can be collected on time can cover AP coming due. ``` ##### 7.2 How to read this stage's script output After running the script, you see: ```text Total Open AR: 680,000 Total Open AP: 370,000 Net AR minus AP: 310,000 ``` At first glance, AR is larger than AP. But continue reading: ```text AR over 60 days: 244,500 AP currently due / past due: 197,600 Net Retention Cash Delay: 53,600 ``` This means: ```text The company has a lot of receivables on paper, but a meaningful portion is old or locked in retention; meanwhile, a meaningful amount of AP is current or already past due. ``` So the conclusion is not "AR is greater than AP, therefore safe." The real question is: ```text Can AR become cash in time, and must AP be paid now? ``` #### 8. Run the Exercise Script Run: ```bash node stage5/ar_ap_aging.js ``` The script outputs: ```text AR Aging by customer AP Aging by vendor Retention summary Cash pressure summary ``` The script uses: ```text As Of Date = 2026-06-14 ``` This keeps aging bucket results reproducible. #### 9. Checklist - Explain why profit does not mean cash safety. - Calculate AR aging buckets from invoice due dates. - Calculate AP aging buckets from vendor bill due dates. - Explain why AR is an asset but old AR is lower quality. - Explain why AP is short-term financing but cannot be delayed forever. - Explain Retention Receivable and Retention Payable. - Explain why retention delays cash recovery. - Read AR, AP, and Retention together to judge cash pressure. - Explain the full chain from profit to cash. - Distinguish the cash quality of total AR, old AR, and retention receivable. - Use near-term AR and due AP to reason about short-term cash gaps. ### Stage 6: Change Order Report #### 1. Stage Goal Stage 6 goal: ```text Understand why change orders are dangerous for both profit and cash. ``` Change Orders connect the contract, cost, WIP, and cash views of a project: ```text They may change contract value. They may change project cost. They may change WIP margin. They may delay billings and collections. ``` #### 2. First Principles: Why Change Orders Are Dangerous A Change Order is: ```text A confirmation of changed price, cost, schedule, or responsibility boundary after the original contract scope changes. ``` First principles: ```text A construction contract is not static. Field conditions, owner requests, design changes, omissions, and rework can all change project economics. ``` Change Orders are dangerous because they often create three mismatches: ```text 1. Work has been performed, but the customer has not approved it. 2. Cost has been incurred, but contract value has not increased. 3. The project manager expects recovery, but accounting cannot recognize it yet. ``` So a Change Order is not a note field. It affects: ```text Contract Budget Estimated Cost at Completion Earned Revenue Gross Profit Backlog AR Cash Flow ``` One-line memory: ```text Change Order is the entry point where scope change enters the financial model. ``` ##### 2.1 Why pending change orders cannot be treated as revenue automatically If work has changed but the customer has not approved it: ```text Cost may already be in Cost to Date. Contract value may not be allowed to increase yet. ``` If a pending change order is added to Contract too early: ```text Contract is overstated Earned Revenue is overstated Gross Profit is overstated Underbilling may be overstated Financial statements look better than reality ``` First principles: ```text Revenue recognition requires an enforceable right. Without customer approval or strong contractual basis, expected recovery should not be treated as certain revenue. ``` ##### 2.2 Core change order risk chain Typical risk chain: ```text Extra field work occurs -> cost happens first -> change order is submitted -> customer approval is delayed -> billing cannot happen on time -> AR / underbilling rises -> cash pressure rises -> if rejected, profit is reversed ``` This is why change orders affect both profit and cash. #### 3. Minimum Data Model for Change Orders Minimum fields: | Field | Meaning | Purpose | | --- | --- | --- | | Job | Project | Which project owns the change | | Change Order # | Change order number | Identifies the change | | Status | Status | Approved, Pending, Rejected | | Description | Description | Scope change | | Amount | Amount | Contract increase / decrease requested or approved | | Cost Impact | Cost impact | Cost increase / decrease required to perform the change | | Margin Impact | Margin impact | Amount - Cost Impact | | Submitted Date | Submitted date | When it was submitted to the customer | | Approved Date | Approved date | When it was approved | | Billing Status | Billing status | Whether it has been billed | | Collection Status | Collection status | Whether it has been collected | First principles: ```text Every change order has at least two sides: How much more will the customer pay? How much more will the company spend? ``` So Amount alone is not enough. Cost Impact must also be tracked. #### 4. Status: Approved, Pending, Rejected ##### 4.1 Approved Approved means the customer has approved the change. Usually it can: ```text be added to Revised Contract be included in WIP contract value be used for revenue recognition be billed under the contract process ``` Still confirm: ```text Has it been billed? Has it been collected? Is there retention? ``` ##### 4.2 Pending Pending means the change has been submitted or is under negotiation, but the customer has not approved it. This is the most dangerous status. Why: ```text Cost may already be incurred. Revenue may not be recognizable yet. Cash may not be collectible yet. The final amount may be reduced. It may be rejected entirely. ``` When reading pending change orders, ask: ```text Is there written direction? Does the contract support the claim? Does the customer acknowledge the scope? Is the amount disputed? Has cost already been incurred? Does the project rely on this CO to preserve margin? ``` ##### 4.3 Rejected Rejected means the customer rejected the change. Impact: ```text It cannot increase contract value. If cost has already been incurred, project margin falls. If forecast assumed approval, the forecast must be reversed. ``` First principles: ```text A rejected CO usually means the cost stays in the project, but the revenue is not recovered. ``` #### 5. Amount, Cost Impact, Margin Impact Core formula: ```text Margin Impact = Amount - Cost Impact ``` Example: ```text Amount = 100,000 Cost Impact = 70,000 Margin Impact = 30,000 ``` If approved, this change adds 30,000 of gross profit. But if: ```text Amount = 100,000 Cost Impact = 115,000 Margin Impact = -15,000 ``` The change increases contract value but lowers project profit. First principles: ```text Change Orders may increase revenue without increasing profit. Always compare incremental revenue with incremental cost. ``` #### 6. How Change Orders Affect WIP One of the key WIP fields is: ```text Revised Contract = Original Contract + Approved Change Orders ``` Approved COs affect: ```text Contract Backlog Earned Revenue Estimated Gross Profit Gross Margin ``` Pending COs usually should not be added directly to approved contract value unless company policy and accounting rules allow inclusion under specific conditions. If a pending CO is incorrectly included in contract value: ```text Percent Complete is unchanged Contract increases Earned Revenue increases Gross Profit increases Underbilling increases ``` This makes the project look better too early. First principles: ```text WIP revenue recognition depends on contractual rights. Change Order approval status determines whether that right is clear enough. ``` #### 7. How Change Orders Affect Cash Flow Cash risk often appears before profit risk. Why: ```text Extra labor, material, or subcontract cost may happen immediately. Customer approval may take time. Billing may need to wait for approval. Collection waits for another payment cycle. ``` Cash timeline: ```text Cost incurred -> CO submitted -> CO approved -> Invoice issued -> Customer payment -> Cash received ``` If cost comes first and approval / collection comes later: ```text The project may ultimately be profitable, but cash can be tight in the middle. ``` This is why Stage 6 should be read together with Stage 5 AR Aging. #### 8. Report Reading Framework Read a Change Order Report in six steps: ```text 1. Group by status How much is Approved, Pending, and Rejected? 2. Check pending age How long has it been pending? Is it beyond the customer's normal approval cycle? 3. Check whether cost has already been incurred Cost incurred before approval is high risk. 4. Check margin impact Does the CO add profit, or does it add revenue while lowering margin? 5. Check WIP impact Has it been included in revised contract, EAC, backlog, or revenue recognition? 6. Check cash impact Has it been billed, collected, or aged into old AR? ``` Warning signs: ```text Large pending CO amount Old pending COs Cost impact already incurred Negative-margin COs Rejected COs still included in forecast Approved COs completed but not billed Billed COs sitting in old AR ``` #### 9. Run the Exercise Script Run: ```bash node stage6/change_orders.js ``` The script outputs: ```text Change Order Detail Summary by Status Margin Impact Summary WIP Impact Cash Risk Flags ``` #### 10. Checklist - Explain why Change Order is not just a note field. - Distinguish Approved, Pending, and Rejected. - Explain why pending COs cannot be automatically treated as revenue. - Calculate `Margin Impact = Amount - Cost Impact`. - Explain how COs affect Revised Contract, Backlog, Earned Revenue, and Gross Profit. - Explain how COs create cash pressure. - Identify risks such as old pending COs, cost incurred before approval, and negative-margin COs. --- ## Category 2 — Company-Level Future Reports Forward-looking, whole-company forecasts. Reproduced in full from `plan.en.md` §7 — the only place the source material covers forecasting. ### 7. Stage 7: Future Reports Goal: after historical reports and WIP are stable, move into forecasting. Recommended order: 1. WIP Backlog 2. Forecasted Income Statement 3. Forecasted 13-week Cash Flow 4. Forecasted Balance Sheet #### 7.1 WIP Backlog Question: when will the remaining work be completed? Common fields: ```text Job Remaining Backlog Expected Completion Schedule Revenue Recognition by Month Cost Recognition by Month Gross Profit by Month ``` #### 7.2 Forecasted Income Statement Inputs: - Current backlog - Expected project completion timing - Gross margin - Overhead budget - New work assumptions Outputs: ```text Forecasted Revenue Forecasted Cost Forecasted Gross Profit Forecasted Overhead Forecasted Net Income ``` #### 7.3 Forecasted 13-week Cash Flow Inputs: - AR collection schedule - AP payment schedule - Payroll - Tax - Debt service - Manual adjustments Outputs: ```text Beginning Cash Cash In Cash Out Net Cash Flow Ending Cash Minimum Cash Week ``` #### 7.4 Forecasted Balance Sheet A forecasted Balance Sheet is a derived report and should not be the first forecasting report you learn. It comes from: ```text Forecasted Income Statement + Forecasted Cash Flow + AR / AP / Retention assumptions + Debt / Capex assumptions ``` --- ## Category 3 — Job-Level Reports Single-project economics and the drilldowns behind every WIP number. Reproduced in full from Stages 2 and 4. ### Stage 2: Construction Project Economics #### 1. Stage Goal Stage 2 moves into the real core of construction finance: ```text Is the project itself profitable? How far along is the project? How much revenue should be recognized? How much has been billed? How much remaining work and risk is still in the project? ``` This stage still does not build a full WIP report. It focuses on the project economics model behind WIP. #### 2. First Principles: What the Project Economics Model Answers A construction project is not a one-time sale. It is a continuing performance obligation. For software engineers, a useful analogy is: ```text Contract = total scope and price Budget = cost estimate for that scope Actual Cost = resources already consumed Estimate to Complete = resources still needed to deliver Billings = amount requested from the customer Collections = amount actually paid by the customer ``` The project economics model answers four questions: ```text 1. What is the contract currently worth? 2. What will it cost to finish the project? 3. Based on current progress, how much revenue should be recognized? 4. Are billings, collections, revenue, and cost misaligned? ``` Most important point: ```text Do not judge a construction project only by billings or collections. You must look at contract, budget, actual cost, estimated final cost, revenue recognition, billings, and collections together. ``` #### 3. Core Objects ##### 3.1 Customer The customer is the party paying for the contract. It answers: ```text Who bought the construction service? Who is ultimately responsible for payment? ``` It affects: ```text Accounts Receivable Collections Retention Receivable Customer concentration risk ``` ##### 3.2 Job / Project Job / Project is the smallest operating unit in construction finance. General accounting often looks only at the whole company: ```text Total company revenue Total company cost Total company profit ``` Construction accounting must ask: ```text How much revenue does each project have? How much cost does each project have? What is each project's estimated final profit? Which project is hurting cash flow? Which project is losing money before the loss is obvious? ``` From this stage onward, key numbers should be traceable to a Job / Project. ##### 3.3 Contract The contract defines how much the customer is willing to pay for the project. Core fields: ```text Original Contract Amount Approved Change Orders Revised Contract Amount ``` Formula: ```text Revised Contract = Original Contract + Approved Change Orders ``` Example: ```text Original Contract Amount = 1,000,000 Approved Change Orders = 120,000 Revised Contract Amount = 1,120,000 ``` First-principles view: ```text Original Contract is the initial committed price. Change Orders adjust the price when scope changes and the customer approves. Revised Contract is the current amount used for revenue and backlog. ``` ##### 3.4 Budget Budget is the company's cost plan for the project. Core fields: ```text Original Budget Budget Revisions Current Budget ``` Budget answers: ```text Based on the original or current plan, how much should this project cost? ``` Budget is not reality. After execution begins, Actual Cost and Estimated Cost at Completion become critical. ##### 3.5 Cost Cost fields are the core of project economics: ```text Committed Cost Actual Cost Cost to Date Estimated Cost to Complete Estimated Cost at Completion ``` Relationship: ```text Estimated Cost at Completion = Cost to Date + Estimated Cost to Complete ``` First-principles view: ```text Project profit is not determined by cost incurred so far. It is determined by the final cost expected when the whole project is complete. ``` A project with low current cost may still be risky if most of the cost is still ahead. ##### 3.6 Billings, Collections, and Retention These fields connect project operations to cash flow. ```text Billings = amount invoiced to the customer Collections = cash collected from the customer Retention = amount temporarily withheld by the customer under the contract ``` Typical retention scenario: ```text Current earned or approved work value: 100,000 Retention rate: 10% Current customer payment: 90,000 Retention Receivable: 10,000 ``` Retention Receivable is an asset, but it is not immediately usable cash. ##### 3.7 Backlog Backlog is remaining uncompleted contract value. Formula: ```text Backlog = Revised Contract - Earned Revenue ``` It answers: ```text How much contract value is still waiting to become future revenue? ``` Backlog is not accounts receivable and not cash. It is work still left under the contract. #### 4. Core Formulas ```text Revised Contract = Original Contract + Approved Change Orders Estimated Cost at Completion = Cost to Date + Estimated Cost to Complete Estimated Gross Profit = Revised Contract - Estimated Cost at Completion Percent Complete = Cost to Date / Estimated Cost at Completion Earned Revenue = Revised Contract * Percent Complete Overbilling = Billings to Date - Earned Revenue Underbilling = Earned Revenue - Billings to Date Backlog = Revised Contract - Earned Revenue ``` Note: ```text Overbilling and underbilling cannot both be positive. ``` Decision rule: ```text Billings > Earned Revenue => Overbilling Earned Revenue > Billings => Underbilling Billings = Earned Revenue => Billing and revenue recognition match ``` #### 5. Walk Through One Project Assume: ```text Original Contract Amount = 1,000,000 Approved Change Orders = 120,000 Cost to Date = 420,000 Estimated Cost to Complete = 380,000 Billings to Date = 620,000 Collections to Date = 540,000 Retention Receivable = 50,000 ``` Contract: ```text Revised Contract = 1,000,000 + 120,000 = 1,120,000 ``` Estimated total cost: ```text Estimated Cost at Completion = 420,000 + 380,000 = 800,000 ``` Estimated gross profit: ```text Estimated Gross Profit = 1,120,000 - 800,000 = 320,000 ``` Percent complete: ```text Percent Complete = 420,000 / 800,000 = 52.5% ``` Earned revenue: ```text Earned Revenue = 1,120,000 * 52.5% = 588,000 ``` Billing position: ```text Billings to Date = 620,000 Earned Revenue = 588,000 Overbilling = 620,000 - 588,000 = 32,000 ``` Backlog: ```text Backlog = 1,120,000 - 588,000 = 532,000 ``` Collection position: ```text Accounts Receivable = Billings - Collections - Retention Accounts Receivable = 620,000 - 540,000 - 50,000 = 30,000 ``` Current project reading: ```text Current contract value: 1,120,000 Estimated final cost: 800,000 Estimated gross profit: 320,000 Current percent complete: 52.5% Earned revenue: 588,000 Billings to date: 620,000 Overbilling: 32,000 Regular accounts receivable: 30,000 Retention receivable: 50,000 Remaining backlog: 532,000 ``` #### 6. Key Judgments ##### 6.1 Do Not Use Billings to Judge Project Revenue Billings are payment requests. Revenue should be recognized based on project progress. ```text High billings do not mean the project has earned that much revenue. ``` ##### 6.2 Do Not Use Cost to Date to Judge Final Profit Cost to Date only shows how much has been spent so far. The real profit driver is: ```text Estimated Cost at Completion ``` If estimated remaining cost increases, project gross profit decreases. ##### 6.3 Overbilling Is Not Always Bad Overbilling means billings exceed earned revenue. It may indicate: ```text Good cash flow Customer payment timing ahead of project progress ``` It may also indicate: ```text Future work still must be performed Current liability increased Risk will appear later if project cost overruns ``` ##### 6.4 Underbilling Needs Attention Underbilling means earned revenue exceeds billings. It may indicate: ```text The company has done work but has not billed promptly Profit appears before cash arrives ``` If underbilling persists, ask: ```text Why has it not been billed? Does the customer accept this work? Are there unapproved change orders? Are cost or progress estimates wrong? ``` #### 7. Relationship to the Three Financial Statements The project economics model flows into the company statements the same way WIP does: Earned Revenue becomes Income Statement revenue, Actual Cost / Cost to Date becomes Direct Cost, Billings less Collections becomes Accounts Receivable, overbilling becomes a Balance Sheet liability and underbilling a Balance Sheet asset, and Collections drive operating cash flow. The full field-by-field mapping is given once under Category 1 — Stage 3, "How WIP Connects to the Three Financial Statements." Summary: ```text The project model explains operating reality. The three financial statements summarize operating results. WIP is the bridge between project economics and financial statements. ``` #### 8. Run the Exercise Script This stage includes a project economics script: ```bash node stage2/project_economics.js ``` The script uses 5 mock projects to calculate: ```text Revised Contract Estimated Cost at Completion Estimated Gross Profit Percent Complete Earned Revenue Overbilling / Underbilling Backlog Accounts Receivable Retention Receivable ``` #### 9. Checklist - Explain the difference between `Original Contract Amount` and `Revised Contract Amount`. - Explain why project profit depends on `Estimated Cost at Completion`. - Calculate percent complete using `Cost to Date / Estimated Cost at Completion`. - Distinguish `Earned Revenue`, `Billings`, and `Collections`. - Determine whether a project is `Overbilling` or `Underbilling`. - Explain why `Backlog` is not cash and not accounts receivable. - Explain how the project model flows into the three basic financial statements. ### Stage 4: Job Cost Detail and Job Reports #### 1. Stage Goal Stage 3 Summary WIP tells us: ```text How much profit is the project expected to make? What is the percent complete? How much revenue should be recognized? Is the project overbilled or underbilled? ``` Stage 4 drills down from WIP to job-level detail. The core question becomes: ```text Where do the cost, profit, and risk shown on WIP actually come from? ``` This stage covers four report types: ```text Job Cost Detail Job Budget Variance Job Labor Report Job Cost-to-Complete ``` #### 2. First Principles: Why Drill Down from WIP WIP is a project-level summary. It can tell you: ```text This project margin is fading. This project has high underbilling. This project estimated final cost has increased. ``` But WIP cannot directly tell you: ```text Which cost code caused the overrun? Which vendor bill drove the cost increase? Are labor hours off budget? Which committed costs have not yet become actual costs? Is the project manager's cost-to-complete estimate reliable? ``` First principles: ```text WIP tells you where something looks wrong. Job reports explain why it is wrong. ``` Software engineering analogy: ```text WIP = dashboard / aggregate metrics Job Cost Detail = logs / traces Budget Variance = expected vs actual diff Labor Report = resource productivity metrics Cost-to-Complete = forecast model ``` Reading WIP without job detail is like reading a production dashboard without logs, traces, and root cause data. #### 3. Minimum Data Model for Cost Detail Job reports usually start from transaction-level detail. Minimum fields: | Field | Meaning | Purpose | | --- | --- | --- | | Job | Project | Which project owns the cost | | Cost Code | Cost code | Work package / budget bucket | | Cost Type | Cost type | Labor, Material, Subcontract, Equipment, etc. | | Vendor / Employee | Vendor or employee | Who generated the cost | | Transaction Date | Transaction date | When the cost occurred | | Description | Description | What the cost was for | | Actual Cost | Actual cost | Cost already incurred and posted | | Hours | Hours | Labor or equipment hours | | Invoice / Payroll Reference | Invoice or payroll reference | Source document | First principles: ```text Every Cost to Date number on WIP should trace back to job cost transactions. ``` If it cannot be traced, two problems appear: ```text The WIP number cannot be explained. The project risk cannot be located. ``` #### 4. Job Cost Detail Job Cost Detail answers: ```text Where exactly did this job spend money? ``` It is the lowest-level cost evidence. Typical fields: ```text Job Cost Code Cost Type Vendor / Employee Transaction Date Description Actual Cost Hours Invoice / Payroll Reference ``` First principles: ```text Project cost is not one number. Project cost is a collection of specific resource consumptions. ``` When reading Job Cost Detail, ask: ```text Is the job assignment correct? Is the cost code correct? Is the cost type correct? Is this cost duplicated? Should this cost be project cost but was posted to overhead? Was a cost from another project incorrectly posted here? ``` Job Cost Detail is the factual base for the other job reports. #### 5. Job Budget Variance Job Budget Variance answers: ```text Are budget, actual cost, and committed cost overrun? ``` More precisely, it answers: ```text Based on actual cost, committed cost, and estimated remaining cost, will this cost code finish above or below budget? ``` Common fields: ```text Budget Actual Cost Committed Cost Projected Cost Variance ``` ##### 5.1 Field first principles ```text Budget How much this cost code was allowed to spend. Actual Cost Cost already incurred and posted. Committed Cost Cost already locked through purchase orders, subcontracts, or other commitments, but not necessarily posted yet. Remaining Committed Cost The part of committed cost that has not yet become actual cost. Estimated Uncommitted Cost Cost that has not been bought or contracted yet, but is still expected to occur. Projected Cost Current estimate of what this cost code will ultimately cost. Variance The gap between budget and projected final cost. ``` First principles: ```text Budget is the plan. Actual is the reality already incurred. Committed is future reality already promised. Estimated uncommitted is future reality not yet committed but still expected. Variance is the gap between plan and reality. ``` ##### 5.2 Core formulas ```text Remaining Committed Cost = max(Committed Cost - Actual Cost, 0) Projected Cost = Actual Cost + Remaining Committed Cost + Estimated Uncommitted Cost Projected Variance = Budget - Projected Cost ``` Interpretation: ```text Projected Variance > 0 => projected under budget Projected Variance = 0 => projected exactly on budget Projected Variance < 0 => projected over budget ``` ##### 5.3 Why Actual Cost alone is not enough Looking only at Actual Cost can understate risk. Example: ```text Budget = 100,000 Actual Cost = 60,000 Committed Cost = 50,000 ``` If you look only at actual cost, it seems like 40,000 of budget remains. But if committed cost will fully occur: ```text Projected Cost = 110,000 Projected Variance = -10,000 ``` The project is already projected to overrun. First principles: ```text Actual Cost only represents the past. Committed Cost represents part of the future that is already locked. Estimated Uncommitted Cost represents future cost that is not locked yet but is still likely to happen. Budget Variance must look at both past and future. ``` ##### 5.4 Separate three kinds of variance Job Budget Variance has at least three useful variance views: ```text Actual Variance = Budget - Actual Cost Committed Variance = Budget - Actual Cost - Remaining Committed Cost Projected Variance = Budget - Projected Cost ``` They answer different questions: ```text Actual Variance How much budget remains if we only look at posted cost? Committed Variance How much budget remains if we also include committed but unposted cost? Projected Variance Will this cost code be over or under budget after all expected future cost? ``` Example: ```text Budget = 100,000 Actual Cost = 50,000 Remaining Committed Cost = 35,000 Estimated Uncommitted Cost = 25,000 ``` Then: ```text Actual Variance = 100,000 - 50,000 = 50,000 Committed Variance = 100,000 - 50,000 - 35,000 = 15,000 Projected Variance = 100,000 - 50,000 - 35,000 - 25,000 = -10,000 ``` For the same cost code: ```text Actual-only view: appears to have 50,000 left. Committed view: only 15,000 remains. Projected view: already forecast to overrun by 10,000. ``` ##### 5.5 Why read variance by Cost Code? Total project variance can hide local problems. Example: ```text Concrete is under budget by 30,000 Electrical is over budget by 27,000 Total project variance may look almost flat ``` But the management questions are different: ```text Why is Concrete under budget? Why is Electrical over budget? Can the savings really offset the overrun? Will the overrun continue to grow? ``` First principles: ```text Total variance is the result. Cost code variance locates the cause. ``` So Job Budget Variance is usually sliced by: ```text Cost Code Cost Type Vendor / Subcontractor Project phase ``` ##### 5.6 Common misreadings ###### Misreading 1: Actual is below Budget, so everything is fine Not necessarily. If the project is not complete, Actual below Budget only means: ```text Posted cost has not exceeded budget yet. ``` It does not mean: ```text Final cost will not exceed budget. ``` ###### Misreading 2: Committed cost covers the future, so risk is low Not necessarily. Committed only covers the work already purchased or contracted. There may still be: ```text unbought scope rework cost acceleration cost material price increases claims and disputes missing vendor bills ``` ###### Misreading 3: Total variance is fine, so the project is fine Not necessarily. A project may have: ```text large savings in some cost codes large overruns in other cost codes ``` The total may net out, while local risks still need management. ##### 5.7 Example in this stage's script Run: ```bash node stage4/job_reports.js ``` In `Job Budget Variance by Cost Code`, you can see: ```text 0300 Concrete Budget = 210,000 Projected = 180,000 Variance = 30,000 ``` Concrete is currently projected under budget. You can also see: ```text 1600 Electrical Budget = 220,000 Projected = 247,000 Variance = -27,000 ``` Electrical is currently projected over budget. That is the value of Job Budget Variance: ```text It does not just tell you total project cost. It tells you which cost code is drifting away from plan. ``` #### 6. Job Labor Report Job Labor Report answers: ```text Are labor hours and labor cost off budget? ``` Common fields: ```text Budget Hours Actual Hours Budget Labor Cost Actual Labor Cost Cost per Hour Productivity Variance ``` Core formulas: ```text Cost per Hour = Actual Labor Cost / Actual Hours Hour Variance = Budget Hours - Actual Hours Labor Cost Variance = Budget Labor Cost - Actual Labor Cost ``` First principles: ```text Labor risk has two sources: 1. Too many hours. 2. Too much cost per hour. ``` So a labor report should not only show total labor cost. It should separate: ```text hours variance rate variance productivity variance ``` If: ```text Budget Hours = 1,000 Actual Hours = 1,200 ``` Productivity may be worse than expected. If: ```text Budget Cost per Hour = 50 Actual Cost per Hour = 65 ``` Labor rate, overtime, or labor mix may be the issue. #### 7. Job Cost-to-Complete Job Cost-to-Complete answers: ```text Will this project blow up by the time it finishes? ``` Common fields: ```text Budget Cost to Date Committed Cost Estimated Cost to Complete Estimated Cost at Completion Projected Variance ``` Core formulas: ```text Estimated Cost at Completion = Cost to Date + Estimated Cost to Complete Projected Variance = Budget - Estimated Cost at Completion ``` First principles: ```text Historical cost explains what already happened. Cost-to-complete judges what will still happen. ``` This is the hardest job report because it is not pure fact recording. It is a forecast. It requires project manager judgment about: ```text remaining scope remaining subcontract cost unposted vendor bills rework risk acceleration cost unapproved change orders claims and disputes ``` Cost-to-Complete is the core input to WIP quality. If Estimated Cost to Complete is understated: ```text Estimated Cost at Completion is understated Percent Complete is overstated Earned Revenue is overstated Gross Profit is overstated WIP looks too optimistic ``` #### 8. How Job Reports Connect Back to WIP The four job reports are not isolated. They explain different parts of WIP: ```text Job Cost Detail -> explains where Cost to Date came from. Job Budget Variance -> explains whether budget and projected cost are drifting. Job Labor Report -> explains whether labor productivity and labor cost are hurting the project. Job Cost-to-Complete -> updates Estimated Cost at Completion, directly affecting WIP revenue and profit. ``` Dependency chain: ```text Job Cost Detail -> Cost to Date -> Cost-to-Complete forecast -> Estimated Cost at Completion -> Percent Complete -> Earned Revenue -> WIP over/under billing -> Financial statements ``` First-principles summary: ```text WIP is the project-level financial result. Job reports are the evidence, explanation, and forecast behind that result. ``` #### 9. Recommended Learning Order Recommended order: ```text 1. Job Cost Detail 2. Job Budget Variance 3. Job Labor Report 4. Job Cost-to-Complete ``` Reason: ```text Start with factual detail. Then read budget variance. Then inspect labor productivity. Finally judge the future forecast. ``` Do not start directly with Cost-to-Complete. If you do not understand actual cost, budget, and labor productivity, it is hard to judge whether the project manager's forecast is reliable. #### 10. Run the Exercise Script Run: ```bash node stage4/job_reports.js ``` The script outputs: ```text Job Cost Detail Job Budget Variance by cost code Job Labor Report Job Cost-to-Complete Summary ``` #### 11. Checklist - Explain the difference between WIP and job reports. - Explain why Job Cost Detail is the factual base for cost. - Summarize actual cost by cost code and cost type. - Distinguish Actual Cost from Committed Cost. - Explain why looking only at Actual Cost can understate overrun risk. - Separate labor risk into hours variance and rate variance. - Explain why Cost-to-Complete is a forecast, not pure fact. - Explain how job reports update Cost to Date, EAC, Percent Complete, and Earned Revenue in WIP. --- ## Category 4 — Service Reports > **Not present in the source material.** None of `plan.en.md` or `stage1`–`stage6` covers service or maintenance work — the entire corpus is construction contract/project accounting. There is **no original detail to preserve** for this category, so nothing is reproduced here. Work Orders and Planned Maintenance Agreements would need to be authored from scratch. This heading is retained only so the four-category structure is complete.