# ============================================================================= # Published - Capex and Opex for Engineering (verbatim) # ============================================================================= # An article authored by Cedric Ancellin, first published on this site. # Text is preserved as written (including original wording and any typos). # Governed by ../LAWS. Verbatim files are exempt from the em-dash rule. # # Added on 2026-11-05. # ============================================================================= title: "Capex and Opex for Engineering" author: "Cedric Ancellin" published: "2026-11-08" platform: "zc8.com" linkedin_url: "https://www.linkedin.com/pulse/capex-opex-engineering-cedric-ancellin-6ysye/" cover_image: "/assets/articles/capex_and_opex_for_engineering.jpg" topics: ["capex", "opex", "software capitalization", "time tracking", "ASC 350-40", "ASU 2025-06", "IAS 38", "Section 174A", "CTO", "CFO", "EBITDA", "engineering management", "AI coding agents"] summary: > How to tag engineering work so finance derives capex and opex from the tickets instead of asking engineers for a percentage at quarter end, what changes under ASU 2025-06, IAS 38 and the 2025 tax law, and what the same data tells engineering. body: | In [Growing Engineering from Startup to Series B](https://zc8.com/published/growing_engineering_from_startup_to_series_b), I wrote that you should tag your development work so finance can derive opex and capex from the tickets. That was one paragraph. This article is about how to actually do it, because it is the part of the job most CTOs learn late, usually the week the auditors arrive. It is written for the CTO and the CFO together, because the CTO owns the inputs, the CFO owns the mapping, and neither can build this alone. Capex and opex are two ways a company records the same dollar. Capital expenditure is money spent building something that lasts. It goes on the balance sheet as an asset and is spread over its useful life, typically three to five years for software. Operating expenditure is money spent keeping the lights on. It hits the income statement in full, in the period it was spent. In this article, opex means anything expensed, including what lands in cost of revenue. In technology, the question used to be mostly about hardware. You bought servers, they were capex, and you depreciated them. The cloud moved most of that to opex, and today the biggest capex decision in a software company is the payroll of its engineering team. When your engineers build a new product, part of their salary can become an asset instead of an expense. The cost does not disappear. It comes back as amortization over the following years, but amortization sits below EBITDA, so capitalizing raises EBITDA today. No cash is saved. The capitalized part of the salary moves from operating to investing cash flow, so experienced investors look at free cash flow after capitalized software, and at how well you can prove what you capitalized. It is why your CFO cares about your tickets. Before anything else, understand that capitalization is a judgment applied under rules, not a target. On the books it follows the standard. Once the criteria are met, you capitalize, and when they are not, you expense. The real choices are in tax, where a company can deduct domestic research now or elect to spread it over five years or more, and a company losing money today may prefer the deduction later, when it is worth more. Those are decisions for finance and tax counsel. Your job is to record reality, accurately enough that every one of those decisions can be made from the same data. That is also what protects you from the rule changes, and the rules on this subject change often. When the standard moves, the facts about what was built, by whom, when and for what do not move with it. Finance changes how it maps those facts, and nobody asks your engineers to relive last year. When a classification is genuinely uncertain, default to opex. It is the conservative position, and it does not mean opex is the better outcome. Many companies still do it by estimate. At the end of the quarter, someone asks each engineer what percentage of their time went to new development. The engineer guesses, the guess goes into a spreadsheet, and the spreadsheet goes to the auditors. It is not evidence, and a good auditor will treat it accordingly. The only design that lasts is hours logged against a correctly tagged ticket, because the ticket is a contemporaneous record of what the work was, and the hours are a contemporaneous record of how long it took. The principle I use is to keep inputs and classifications strictly separate. The people doing the work only record facts. The capex or opex flag is never a field anyone sets. It is derived downstream, in your reporting layer, from those facts. If engineers could set the flag directly, they would be grading their own work, and the flag would be worth nothing as evidence. Whether an hour is capex or opex comes down to two boundaries. The first is whether the build decision has been made and completion is probable. Research, feasibility spikes and deciding what to build are expensed. Once the company has committed the resources, the hard technical questions are answered and the major requirements have stopped changing, qualifying work can be capitalized. The second is whether the asset is ready for its intended use. Until then, the work is building the asset. Once it is ready, the work preserves its value, and that is expensed. Those two boundaries resolve most of the arguments. A bug fixed before the software is ready is part of building the asset and can be capitalized. The same bug fixed after the software is ready is maintenance, and that is expensed. An enhancement that adds a capability the product did not have is new build, even on a feature that has been live for years, so it is tracked as an asset of its own. A refactor with no change in behavior adds no capability and is always expensed. Infrastructure follows the same logic only when it is part of building the software. Build-out specific to one asset belongs to that asset. Shared pipelines and tooling are overhead or an asset of their own, running any of it is maintenance, and hardware is equipment, capitalized under its own rules. I simplified all of this in the Series B article, where I wrote that bug fixes are expensed and tied capitalization to the design stage. I tag in four layers. The first three inherit from each other, so nobody enters the same fact twice, and the fourth is the person, joined to every hour they log. - The asset is the roadmap item the work builds. Every product ticket links to one, and every capitalized hour rolls up to it, because that is what becomes a line on the software asset register. The asset carries its budget, the hours and cost you estimated when you decided to build it, so you can measure what it actually took. It also carries three dates, which are the two boundaries in practice: the day the build was approved and funded, the day the remaining technical uncertainty was resolved and the requirements settled, and the day the software was ready for its intended use. Each date links to its evidence, such as the approved brief, the proof of concept and the settled spec, or the release. - The ticket says why the work exists. Once, during triage, the product manager or team lead sets its work category and, when relevant, the client or prospect. It takes about thirty seconds. The work category is a locked vocabulary: new feature, enhancement, bug fix, refactor, infrastructure, client implementation, support, sales work, admin, and a few others. - The worklog says how the time was spent. Each person logs hours, a date and an activity, such as development, architecture, code review, testing, training or travel, and the worklog inherits everything else from its ticket. The date decides which accounting period the cost lands in, and the period is locked once it closes. - The person says what the hour costs and where it lands. Their department, role, rates, location and employing entity sit in tables owned by finance and HR, never in the ticketing tool. Nobody sets a phase on a ticket. In my experience, a phase field on every ticket is the tag most often wrong, because nobody remembers to update fifty tickets on launch day. The phase of each hour is derived from the worklog date and the asset's dates. Hours logged before the build was approved and the uncertainty resolved are discovery. Hours from the later of those two dates until the software is ready for use are build. Hours after that are maintenance. Ready for its intended use is the test, not launched. A feature that is built and tested and waiting behind a flag is ready, and its amortization starts, even if marketing has not announced it. A feature still in beta testing is not. A ticket that spans one of those dates simply has hours in both phases. Because the flag is computed for each worklog, from its work category and its derived phase, and not for each ticket, one ticket can produce hours that are treated differently. On a capitalizable feature, the hours spent designing, writing and testing the code are capex, and the hours spent training the support team on it are opex. A developer abroad is treated differently for tax than one at home. You can drill from an asset down to a ticket, to a person, to a single hour, and that is exactly the path an auditor walks. I keep two rates for each person. The loaded rate is salary, benefits, payroll taxes and stock compensation, with no overhead, and it is the rate the books use. Tax counts overhead and the research credit counts a narrower set, mostly wages, so finance adds those adjustments in its own layer rather than in the rate. The standard rate is a normalized cost per role, used for management reporting, so a project does not look more expensive because a senior engineer got a raise. People are no longer the only cost of building software. Your agents and AI tools consume tokens and subscriptions, and your cloud bill grows with every environment you create. Tag that spend to the asset as well, with separate API keys or projects per asset and resource tags in your cloud account. Under US GAAP, outside services consumed directly in developing software can be capitalized. A general-purpose AI subscription is typically expensed, and usage-based agent charges can be capitalized only when usage logs tie the consumption to a qualifying project, which is most of the evidence a key per asset gives you, with the rest coming from what the agent was used for. This is new ground, and your auditors will draw the line. Even where it is expensed, it belongs in the cost of the asset, or your cost to market will flatter every feature your agents built. Production hosting is expensed, and tagged by customer it feeds your cost to serve. Two overrides protect you. The first is activity. Training people, converting data and general overhead are expensed even when they are logged on a capitalizable ticket, though building the tool that converts the data is part of the build. The override only ever moves hours from capex to opex. If you believe hours belong in capex, you recategorize the ticket, you do not let the worklog upgrade itself. Where the line sits for the sprint planning and design reviews of the team building the feature is a judgment call, usually treated as build, and one to confirm with your auditors. The second is the client. Work done for a paying client under contract is cost of service, matched against that client's revenue, and it is never capitalized as part of your software asset, whatever its category. That includes code. A developer writing a custom integration for one client is doing client delivery. It only becomes a new feature if the result is a capability any client could use. Whether finance defers some of that client work as a cost of fulfilling the contract is a separate question, with its own rules. Put the controls in the tools, not in a review at quarter end. The tracker should refuse tickets that cannot be classified, such as client work with no client, or product work with no asset. Then let an agent check the tags. It reads each ticket against its description and its asset and flags what does not fit, such as a new feature whose description reads like a fix. A human decides, and the agent never changes a tag itself. When a tag changes after hours were logged in a closed period, treat it as an event to review, never as a silent restatement of last quarter. The rules underneath all this are moving, and you should know where. In US GAAP, software you sell as a service is usually internal-use software under ASC 350-40, because your customers never take possession of it. That standard was built on project stages that agile teams never fit well. FASB's ASU 2025-06 removes the stages. Capitalization starts when management has authorized and funded the project and it is probable it will be completed and used as intended, meaning the novel parts have been proven through coding and testing and the major requirements have stopped changing. FASB expects little change for most software but a possible decrease for software delivered as a cloud service. Practitioners warn that for such software, that point can come late in the project. It is effective for annual periods beginning after December 15, 2027, early adoption is allowed, and the stages apply until you adopt it. The two boundaries survive the change. The evidence shifts to the three dates on the asset, which is one more reason to record them as they happen. If you report under IFRS, as listed European groups must in their consolidated accounts, IAS 38 splits a project into a research phase, always expensed, and a development phase, capitalized once six criteria are met, from technical feasibility to probable future economic benefit. Once all six are met, capitalizing is required. A US company with a subsidiary in Europe can face both. The subsidiary files its local accounts under its country's rules, the group consolidates under US GAAP, and the same engineer's hour can be treated differently in each. Tax is a separate layer again. In the US, the 2025 tax law restored immediate expensing of domestic research, software development included, after three years in which it had to be amortized, and a company can still elect to spread it over five years or more. Foreign research is still amortized over fifteen years, so where your engineers sit changes your tax bill, and the research tax credit has its own eligibility rules on top. Keep book and tax as separate derived columns and let accounting reconcile them. The CTO does not need to master any of this. The CFO does, and that is the point of the split. Your auditors and tax counsel will draw the exact lines, and they will redraw them as the rules change. With clean inputs, redrawing a line is a change to a rule in finance's reporting layer, not a request to your engineers to re-tag a year of work. Once the data is in place, it answers far more than the capex question, and this is where engineering earns its seat at the table. Every measure below comes from the same data, with no extra tagging. - Cost to market. Add up every hour and every dollar of tooling on an asset from its first discovery ticket to the day it is ready, and you know what the feature cost to bring to market and how long it took. Compare it with the budget on the asset, and your next estimate gets better. - Return on investment. Put the cost of each asset next to the revenue it produced, in new contracts or growth in recurring revenue, and you can show the board which investments paid off and which did not. - Maintenance ratio. This is the share of engineering hours that goes to maintenance instead of new build, overall and for each asset. A rising ratio is the clearest early signal of technical debt you will ever put in front of a board, and an asset still pulling heavy maintenance a year after launch costs more than its amortization says. It is the Ugly Duckling from the Series B article, showing up in the numbers before it shows up in the roadmap. - Cost to serve. Joined to your CRM, the worklogs tell you what each customer costs against the revenue it brings. They also show which customers pull on engineering when support or implementation should be serving them. That feeds renewal pricing and churn risk. - Cost of acquisition. Hours spent on demos, pilots and RFPs are tagged to the prospect, so you know what each deal cost to win or to lose, and whether the customer's lifetime value covers it. - Staffing mix. The gap between loaded and standard cost shows where people more senior, and more expensive, than the work requires are doing it. - Key-person dependency. When one person holds most of the hours on an asset, you have found the risk a Series B investor will find in diligence. Productivity is the one to handle with care. Hours measure effort, not output, and a team that logs more hours is not a more productive team. What the data measures well is the cost of delivering a capability, and how that cost moves over time. It also gives an honest answer to the question every board is asking right now, which is what AI is actually doing for your engineering. If your agents are working, the cost and the time to bring a comparable feature to market should fall, and you can show it. The same data that lets an auditor drill down to a single person's hour should not become a surveillance tool. Keep person-level detail and loaded rates restricted to accounting, and give management rollups by asset, team and customer. Engineers log honestly when they know the hours are used to price the work, not to rank them. Roll it out in a way that commits only to what you can deliver. The first commitment is the inputs. Every engineering ticket carries the agreed fields, and you run one full month of clean, auditable data before deciding which reports to build first. Close each period, and have accounting trace a sample of twenty random tickets end to end every quarter. Start with engineering, then add the other departments one at a time, because product, implementation, support and sales are spending the company's money too. Tag what is true, not the accounting outcome you want. Capitalization is derived from honest inputs, and when the numbers look wrong, you fix the input that was wrong, never the output. transcription: "As written by Cedric Ancellin, first published here 2026-11-08."