An ESG director we spoke with recently described her company’s carbon procurement stack in one sentence: “We have a spreadsheet that tells us what we bought, and a prayer that it holds up in an audit.” That sentence is about to become a liability. With the Science Based Targets initiative’s Corporate Net-Zero Standard V2.0 now formally recognizing commodity certificates, book-and-claim chains of custody, and a new category called Ongoing Emissions Responsibility, the flat, undifferentiated ledger most corporate carbon teams rely on is structurally unequipped for what auditors are about to ask. This post is about why a purpose-built book-and-claim carbon credit platform is no longer a nice-to-have for enterprises navigating V2.0, and what it actually takes to engineer one at the data layer, not just the reporting layer. Why SBTi V2.0 Broke the Old Carbon Ledger Model For most of the last decade, corporate carbon procurement tools have treated every credit the same way: an ID, a quantity, a vintage, a status of “retired” or “available.” That model was tolerable when the primary use case was voluntary offsetting against a single, simple claim. It is not tolerable anymore. SBTi’s Corporate Net-Zero Standard V2.0 introduces an implementation hierarchy that requires companies to distinguish between multiple, legally distinct instrument categories operating under different rules simultaneously. Commodity certificates and energy attribute certificates using mass balance or book-and-claim chains of custody are now formally recognized as legitimate implementation tools for certain scope 3 categories, but they are reported separately from the physical emissions inventory and must meet specific integrity criteria around activity matching and double-counting prevention. Separately, the standard introduces Ongoing Emissions Responsibility, a mechanism addressing the years a company continues emitting while working toward its target, which large companies must engage with formally from 2035 or disclose why they haven’t. A book-and-claim carbon credit platform has to hold all of this simultaneously: physical inventory data, decoupled environmental attribute certificates, neutralization-grade removal credits, and OER-eligible instruments, each governed by different eligibility rules, each needing to be queried, filtered, and reported on independently without contaminating the others. Treat these as one undifferentiated pile of “carbon credits,” and a compliance audit will find the gap immediately. The Architecture Problem: Why Linear Ledgers Can’t Model Book-and-Claim Most transaction ledgers, whether in a traditional database or a basic blockchain implementation, are built around a linear delivery model: an asset exists, it moves from party A to party B, and its state changes from “held” to “transferred.” That model works fine for a physical bar of gold or a single share of stock. It breaks down the moment you introduce book-and-claim. Book-and-claim, by definition, separates the environmental attribute of a low-carbon commodity from the physical product it describes. A sustainable aviation fuel certificate, for instance, can be sold, tracked, and retired entirely independently of the physical fuel itself, which may be consumed thousands of miles away by a party with no contractual relationship to the certificate buyer. A linear ledger has nowhere to put that split. It wants one asset, one owner, one location. Book-and-claim wants two parallel records — a physical delivery record and an attribute record that are related but never merged, and that can be independently audited, retired, and reported without either one silently inheriting the other’s status. This is the architecture problem a book-and-claim carbon credit platform actually has to solve: not “how do we record a transfer,” but “how do we record two distinct, cryptographically traceable claims against a single originating event, without ever letting them be double-counted against the same target.” The Software Solution: A Multi-Layered Attribute Schema The fix is not a bigger spreadsheet or a more detailed status field bolted onto an existing table. It’s a fundamentally different data model one where every credit or certificate is described not by a single status flag, but by a structured set of attributes that a query engine can filter against instantly. In practice, this means moving to a schema built around highly structured attribute storage, using an approach like JSON-B fields layered on top of relational tables with dedicated micro-indexes on the fields that compliance teams and auditors will query most often. Rather than a single “credit_status” column, each unit in a book-and-claim carbon credit platform carries a structured attribute object that can include: The engineering value of this approach is that these attributes live at the data layer, indexed and queryable, not buried in a PDF certificate or a manually maintained tag in a spreadsheet. When a compliance officer needs to pull every OER-eligible, Advanced-tier, book-and-claim certificate purchased in a given reporting year, that should be a sub-second, indexed database query, not a week of manual document review before an audit deadline. Read: Why Your Carbon Exchange Needs a Carbon Smart Order Router (Before Your Best Clients Route Around You) Dynamic Tagging: Isolating Permanent Removals From Temporary Reductions One of the more quietly dangerous failure points in legacy carbon ledgers is treating permanence as an afterthought, something noted in a project description rather than something the platform actively enforces. Under V2.0’s durability requirements, this distinction is not cosmetic. A company matching residual emissions against removals needs those removals to carry a storage duration genuinely comparable to the atmospheric lifetime of the emissions being addressed, and the standard proposes either a like-for-like matching approach or a phased transition toward more durable removals through 2050. A book-and-claim carbon credit platform designed for this reality doesn’t just store a “credit type” label. It structurally isolates permanent removal inventory from temporary reduction inventory at the query layer, so that a reporting dashboard, an API call, or an internal override cannot accidentally pull a temporary nature-based credit into a bucket that a company’s climate transition plan has designated for permanent removal matching. This is the same design principle that governs how we’ve approached credit-state architecture on Carbon Plant, our FSA-registered environmental impact exchange: state and category distinctions have to be enforced at the data and settlement layer, not left to a front-end filter that a direct
Between July 3 and July 10, 2026, three things happened that had nothing to do with each other on the surface and everything to do with each other underneath. EEX reported an 11% jump in H1 2026 secondary trading volume, driven largely by financial players rotating into environmental commodities as a hedge against broader market volatility. ICE’s CORSIA futures bounced back toward $10/tonne after a volatile spring, as airlines resumed covering compliance obligations ahead of Phase I deadlines. And Macao’s new International Carbon Exchange launched standardized spot contracts for CCP-labeled technology and nature-based credit pools, signaling that even newer regional exchanges are moving straight to standardized, liquid instruments rather than one-off project listings. Read individually, these are three market news items. Read together, they say something much more specific to anyone who builds trading infrastructure: the carbon exchange matching engine sitting under most platforms today was never designed for this. This is not a market commentary post. It’s an engineering one about the carbon exchange matching engine that has to sit underneath all three of these developments at once. If you’re a CTO, an exchange founder, or a compliance officer evaluating whether your platform’s plumbing can survive the next eighteen months of regulatory and volume shocks, the question worth asking isn’t “is the market growing.” It’s “does our carbon exchange matching engine actually behave like exchange-grade infrastructure, or does it just look like it on a demo call?” Why a Carbon Exchange Matching Engine Can No Longer Be an Afterthought For years, most environmental marketplaces got away with a basic database-backed order list dressed up as a carbon exchange matching engine. A seller posts a lot, a buyer submits an offer, a human or a simple script matches them, and a row gets updated. That approach was tolerable when volumes were modest, and price action was slow. It is not tolerable anymore. The EEX volume surge is a symptom, not the disease. When secondary trading accelerates the way it did in H1 2026, order flow stops looking like occasional manual listings and starts looking like algorithmic, API-driven activity: participants hitting your endpoints repeatedly, testing spreads, and reacting to price moves in near real time. A carbon exchange matching engine built on slow, polling-based database queries simply cannot keep up. Worse, it creates exactly the kind of latency gap where stale prices get hit, orders queue unfairly, and a platform’s credibility with institutional counterparties quietly erodes trade by trade. For any carbon exchange matching engine, the CORSIA futures recovery toward $10/tonne adds a second dimension to the same problem. Sudden regulatory price recoveries trigger bursts of compliance-driven buying from airlines racing to cover obligations, and that buying is concentrated, urgent, and unforgiving of friction. A carbon exchange matching engine that can’t distinguish a CORSIA-eligible tranche from general voluntary inventory at the moment of order placement isn’t just slow – it’s actively creating settlement risk for buyers who cannot legally clear an ineligible unit against their compliance target. The Architecture: What an Institution-Grade Carbon Exchange Matching Engine Actually Requires Building a carbon exchange matching engine that can absorb this kind of volume and volatility means moving off a basic relational query pattern entirely. In practice, that means a high-throughput central limit order book (CLOB) backed by an in-memory matching layer – think Redis-backed structures or a purpose-built matching service in a low-latency language – capable of resolving orders in sub-millisecond time rather than the multi-second round trips a conventional web stack produces under load. But raw speed isn’t the whole story. A carbon exchange matching engine handling CORSIA-eligible inventory needs specialized asset tagging baked into the order book itself, not bolted on as a front-end filter. Compliance buyers need to query and clear against CORSIA-eligible tranches specifically, instantly, without wading through a mixed pool of voluntary and compliance-grade units during a volatile trading window. That tagging has to live at the data layer the matching engine reads from – because a filter that only exists in the UI does nothing to stop an API call, a race condition, or an internal override from clearing a trade the buyer legally cannot accept. This is the part most legacy platforms miss: a carbon exchange matching engine isn’t just an order-matching component. It’s the single point in your architecture where speed, eligibility, and legal state all have to reconcile in the same instant, because a trade that clears fast but clears wrong is worse than a trade that clears slowly. Read our latest article about Cryptographic Proofs vs. PDF Uploads: Eliminating Letter of Authorization (LoA) Counterparty Risk in Compliance Trading The Sovereign Bridge: Registries, Corresponding Adjustments, and Standardized Pools The UNFCCC’s announcement that foundational Article 6 registries will be fully operational by year-end changes what a carbon exchange matching engine has to talk to, not just how fast it has to talk. Once sovereign state ledgers go live, platforms need an asynchronous Registry Integration Layer built on durable webhooks and automated reconciliation queues – infrastructure that can absorb a national registry’s own timeline for issuing corresponding adjustments without stalling the matching engine itself. A carbon exchange matching engine that waits synchronously on a sovereign registry response is a matching engine that will eventually time out during exactly the compliance rush it needs to survive. Macao’s move toward standardized CCP-labeled spot contracts points at a related but distinct requirement: pooling. Heterogeneous, project-specific credits need to be lockable into escrow and re-minted as a uniform, tradable pool token – a Tech-CCP or Nature-CCP equivalent- so a carbon exchange matching engine can offer the deep, standardized liquidity institutional desks actually want, instead of forcing every buyer to underwrite project-level risk on every single lot. This is the exact problem NFT and blockchain-backed exchange infrastructure was built to solve: each underlying credit is minted as a traceable NFT, lockable into an escrow contract that issues a standardized pool token on top, so a carbon exchange matching engine can trade the pool as one liquid instrument while still tracing
There is a specific kind of dread that hits a compliance desk about ninety minutes after a large trade clears. The order looks clean. The counterparty is reputable. The registry serial numbers match. And yet someone on the legal team quietly asks: has the host country’s Letter of Authorization actually been confirmed, or did we just trust a PDF that someone uploaded three weeks ago? That question, multiplied across every CORSIA Phase I compliance buyer racing to cover obligations in 2026, is the single biggest unpriced risk sitting inside carbon market infrastructure today. And it lives in one deceptively boring document type: the Letter of Authorization. This post is about why letter of authorization carbon credits verification has become the highest-stakes clearing problem in environmental markets, why the manual PDF-review model most platforms still run on cannot survive CORSIA-scale volume, and what a programmatic, cryptographically verified alternative actually looks like at the architecture level. If you operate an exchange, a registry, or a compliance desk that touches Article 6-eligible inventory, this is the engineering conversation your team should already be having. Why Letter of Authorization Carbon Credits Have Become a Boardroom Problem A Letter of Authorization is the formal instrument by which a host country’s national authority confirms it will apply a corresponding adjustment to a unit, permitting it to move internationally for compliance purposes. Without it, a credit stays landlocked, usable only domestically. With it, the unit becomes eligible to clear against schemes like CORSIA. For years, this was a slow-moving legal formality that compliance teams handled with a folder of scanned documents. That era is over. CORSIA Phase I mandates have created a surge of buying pressure from airlines that have never had to think about host-country treaty mechanics before, and every one of them is now asking the same question their legal counsel taught them to ask: can you prove this letter of authorization is real, current, and not already used somewhere else? The honest answer, on most platforms today, is no. Not with certainty. Not at the speed a trading desk needs. And that gap between “we have a document” and “we can prove authorization status at the moment of settlement” is exactly where multi-million-dollar counterparty exposure lives. The Structural Problem: Manual PDF Review Was Never Built for This Volume Walk through how letter of authorization carbon credits get verified on a typical legacy platform, and the fragility becomes obvious fast. A seller uploads a PDF of the host country’s authorization letter. An internal compliance admin opens it, reads it, cross-references it against whatever registry documentation is available, and manually marks the underlying credit lot as “authorized” in the platform’s database. That status then sits there, unchanged, until someone remembers to check again. Every step in that sequence is a point of failure. This is why the manual review model for letter of authorization carbon credits isn’t just slow – it’s a liability surface. Every trade cleared against an unverified or stale authorization is a trade a compliance buyer will eventually have to unwind, disclose, or defend in front of a regulator actively looking for exactly this kind of gap under anti-greenwashing enforcement regimes. What Regulators Are Actually Asking The shift in regulatory posture matters here. Examiners evaluating exchange-grade carbon infrastructure are no longer satisfied by “we collect documentation.” The question they’re asking exchange operators is whether the platform’s architecture made an unauthorized or fraudulent clearing possible in the first place. That’s a fundamentally different bar. It’s not “did you have a compliance process.” It’s “did your system structurally prevent this trade from clearing without verified authorization.” A folder of PDFs, however diligently reviewed, cannot answer that question the way a regulator now expects. Something has to sit between the order book and settlement that can prove, cryptographically, that letter of authorization carbon credits status was live-verified at the exact moment capital changed hands. Architecting the Split: Managing Dynamic State Mutations Between Article 6.4 AERs and Mitigation Contribution Units (MCUs) The Software Architecture Solution: A Programmatic Validation Layer The fix is not a faster PDF review team. It’s removing the human read-and-approve step from the critical settlement path entirely and replacing it with a programmatic validation layer that treats authorization status as a governed, cryptographically verifiable state, not a document sitting in a compliance folder. Why “Just Add a Verification Checkbox” Doesn’t Solve This There’s a familiar shortcut teams reach for: add an attestation step where the seller checks a box confirming the authorization letter is current and hasn’t been used elsewhere. This does almost nothing. A checkbox shifts liability onto a seller’s honesty at the exact moment they have the strongest incentive to move inventory quickly. It doesn’t stop an API call that bypasses the front end, doesn’t catch a race condition where status changes between page load and order submission, and doesn’t prevent the same PDF from being reused across two listings. Neither does a nightly reconciliation batch that flags mismatches twelve hours after a trade has already cleared. At that point you’re not preventing counterparty risk on letter of authorization carbon credits – you’re documenting your own incident report, after the exposure already sits on someone else’s balance sheet. What This Means for Exchange Founders and Compliance Buyers If you’re a CTO or founder building or operating a compliance-grade exchange: CORSIA Phase I demand isn’t slowing down, which means trading volume against Article 6-eligible inventory is only going to increase pressure on whatever verification process sits between your order book and settlement. A manual review team that works fine today at moderate volume becomes the exact bottleneck — and the exact liability surface – once volume triples. If you’re an ESG director or compliance officer evaluating counterparties, the question worth asking any platform you’re sourcing letter of authorization carbon credits from is blunt: can you show me, cryptographically, that this specific lot’s authorization was verified against the issuing registry at the moment of settlement, or are you asking me to trust a
Every founder has heard the pitch: “We’ll have your MVP ready in six months.” And every founder has lived the reality that follows: six months quietly becoming eight, budgets doubling, and a competitor launching first. At Techaroha, we got tired of watching good ideas die in development purgatory. So we rebuilt our entire delivery process around one core discipline: AI MVP development. Not “AI-assisted coding” as a buzzword, but a genuinely different operating system for building software, one where business requirements become machine-executable specifications, and AI agents do the heavy lifting while human engineers focus on judgment, architecture, and quality. This is the story of how that shift let us compress a traditional 6-month MVP timeline into 6 weeks and why we’re now applying the same approach to build something far more complex. If you’re a founder, CTO, or product lead evaluating how to actually ship fast without cutting corners, this one’s for you. Why Traditional MVP Timelines Break Down Before we get to the “how,” it’s worth understanding why the old model fails so predictably. A typical MVP build follows a familiar rhythm: discovery workshops, requirement documents that get reinterpreted by three different people, a design phase that runs long, a development phase where developers guess at intent because the spec was never precise enough, and a testing phase where all those guesses surface as bugs. By the time you reach launch, you’ve spent six months building something that only loosely resembles what the business actually needed. The problem isn’t the developers. It’s the translation layer between “what the business wants” and “what gets built.” Every handoff from founder to product manager to designer to engineer introduces ambiguity. Ambiguity is expensive. It’s the single biggest hidden cost in software development, and it’s exactly what AI MVP development is designed to eliminate. What Is Spec-Driven Development (SDD)? Spec-Driven Development is the methodology that makes true AI MVP development possible. In plain terms: instead of writing loose requirement documents and hoping engineers interpret them correctly, we write hyper-precise specifications and acceptance criteria so detailed and unambiguous that an AI coding agent can execute them correctly on the first pass. Think of it as the difference between telling a contractor “build me a nice kitchen” versus handing them an architectural blueprint with exact measurements, materials, and load calculations. One invites interpretation and rework. The other produces a predictable, high-quality outcome. In practice, spec-driven development for AI MVP development means: This is the foundation of every AI MVP development engagement we run at Techaroha. Before a single line of code is written, we’ve already defined success in terms precise enough for a machine to understand – which means when the AI agents start generating code, they’re not guessing. They’re executing. The Real Numbers: Traditional Timeline vs. Techaroha’s AI MVP Development Timeline Here’s the comparison that matters most to founders evaluating build partners. This isn’t theoretical — it’s the actual phase-by-phase breakdown from a recent engagement. Phase Traditional Timeline Techaroha AI MVP Development Timeline Boilerplate & Setup 2 Weeks 2 Hours (Automated Agents) Feature Implementation 2 Months 10 Days (Parallel AI Generation) Testing & QA / Bug Fixes 3 Weeks 2 Days (AI-Assisted TDD) Total ~6 Months ~6 Weeks Let’s unpack what’s actually happening in each row, because the “3x faster” headline only means something once you understand the mechanics behind it. Boilerplate & Setup: 2 Weeks → 2 Hours In a traditional build, the first two weeks disappear into scaffolding – setting up authentication, database schemas, CI/CD pipelines, environment configs, and folder structures. It’s necessary work, but it’s also entirely repeatable and low-judgment. In our AI MVP development workflow, this is where automated agents shine. Once the spec defines the tech stack and data models, agents generate the entire boilerplate – auth flows, API scaffolding, deployment pipelines in a couple of hours. Engineers review and approve it rather than typing it from scratch. Two weeks of grunt work becomes an afternoon. Feature Implementation: 2 Months → 10 Days This is the phase where the compounding value of spec-driven development really shows. Because every feature has already been broken into atomic, testable specifications, AI agents can work on multiple features in parallel rather than a single engineering team working sequentially through a backlog. A traditional team builds feature A, then feature B, then feature C, each waiting on the last, each subject to a single developer’s bandwidth and context-switching fatigue. Our AI MVP development approach runs feature generation in parallel streams, with engineers acting as reviewers and integrators rather than line-by-line authors. Two months of sequential feature work compresses into roughly ten days. Testing & QA: 3 Weeks → 2 Days Because acceptance criteria were written as testable conditions from day one, test suites are generated alongside the code, not bolted on afterward. This is AI-assisted Test-Driven Development (TDD): the AI agent writes the feature and the corresponding tests simultaneously, referencing the same spec. Bugs that would normally surface three weeks into a QA cycle get caught in hours, because the test criteria were baked into the build from the start. The result: a 3-week bug-hunting marathon becomes a 2-day validation pass. Why This Matters More Than Just “Speed” It’s tempting to read this as simply “AI makes things faster.” That’s true, but it undersells the real shift. What AI MVP development actually changes is risk. A 6-month MVP timeline isn’t just slow – it’s risky. Markets shift. Competitors launch. Budgets run out before validation happens. Founders spend six months building based on assumptions that were true in month one but stale by month six. Compressing that into six weeks means you’re testing your product hypothesis against a live market almost immediately. You’re not betting six months of runway on an untested idea; you’re validating in weeks and adjusting based on real user behavior, not committee guesswork. This is precisely why AI MVP development has become the default approach we recommend to early-stage founders: it doesn’t just save time, it de-risks the entire
