Skip to main content
What you’ll learn in this lesson:
  • Review the complete end-to-end data flow of a production-ready project
  • Build a configuration checklist for model completeness
  • Understand testing strategy: unit, integration, and end-to-end testing
  • Identify the key verification points in the data pipeline
You’ve built individual components across Modules 1-4: event types, models, batch partitioning, LCA emissions, and ledger structures. Now it’s time to step back and see how all the pieces fit together — and verify that nothing is missing before going to production.

​
The complete Mangrove Biochar data flow

Here is the full end-to-end pipeline for your training project:
The data flow goes in one direction: events → models → batches → ledgers → reports. Each layer depends on the one before it. A missing link at any layer will cause downstream failures.

​
Configuration checklist

Before testing, walk through this checklist to verify every component is properly configured:
1

Event types and datapoints

  • All required event types are created in Data Inputs > Input Settings
  • Each event type has the correct datapoints with appropriate value types
  • Datapoint slugs match what the models expect
  • Required vs. optional flags are set correctly
2

Static inputs and constants

  • Emission factors are stored as static inputs in the resource library
  • Conversion constants (e.g., 3.67) are defined in the model
  • Values and units are correct
3

Models

  • All model nodes reference the correct datapoint slugs
  • Operators are appropriate for each calculation step
  • Intermediate nodes produce expected values in the Console
  • Output datapoint types match what the batch type expects
  • Model version is saved and validated
4

Batch types and partitioning

  • Batch type is configured with the correct partition cadence
  • Output datapoint types in the batch type match the model outputs
  • Feedstock partitioning is configured if needed
5

Ledgers and allocations

  • Ledgers are configured for each stage (if using mass balance )
  • Batch types are linked to the correct ledgers
  • Allocation rules between ledgers are set up

​
Testing strategy

Testing a production accounting project has three levels:
Test individual components in isolation.What to test:
  • Each model node produces the correct output for known inputs
  • Each event type accepts valid data and rejects invalid data
  • Each emission factor produces the expected result
How: Use the Model Editor Console with manually entered values. Test one calculation step at a time.

​
Key verification points

At each layer of the pipeline, there are specific things to verify:
Start testing from the bottom up: verify events first, then model calculations, then batches, then ledgers. This way you build confidence at each layer before adding complexity.

​
Check your understanding

Events (data entry) → Models (calculations) → Batches (partitioned outputs) → Ledgers (mass balance tracking) → Reports (aggregated for verification). Each layer depends on the previous one being correctly configured.
Unit testing verifies individual components in isolation — a single model node, a single event type, a single emission factor. Integration testing verifies the connections between components — that events feed correctly into models, models produce correct batch outputs, and allocation distributes properly. Unit tests catch formula errors; integration tests catch configuration mismatches.
Next, learn specific testing patterns and techniques in Lesson 5.2: Testing Patterns.