# How to standardize budget justification templates across NIH, NSF, and DoD

When one institution pursues concurrent funding from the National Institutes of Health (NIH), the National Science Foundation (NSF), and the Department of Defense (DoD), the budget justification is where a single source of financial truth splinters into three incompatible documents. NIH expects the Research & Related (R&R) budget module with a hard per-category character ceiling; NSF expects a narrative laid out against Research.gov’s fixed cost categories; DoD Broad Agency Announcements (BAAs) expect Federal Acquisition Regulation and Defense FAR Supplement (FAR/DFARS) cost-principle metadata that the civilian agencies never ask for. Maintain those three by hand and the predictable failure mode is portal rejection — a justification block silently truncated past NIH’s limit, a Research.gov upload bounced for rich-text artifacts, or a DoD submission returned for a missing depreciation schedule. This page shows how to collapse all three into one canonical model and generate each agency variant deterministically, a normalization discipline that sits directly under the site’s budget justification format standards work and enforces the field-level type checking those standards require before any document is rendered or transmitted.

# Phase 1 — Decompose each agency budget into a canonical model

Standardization begins by refusing to treat any single agency’s layout as the master format. Instead, every incoming budget is reduced to one internal representation, and each agency document becomes a view rendered from that representation. This mirrors the domain-decomposition discipline used across the broader Core Architecture & RFP Taxonomy and the same conditional-override approach documented in mapping NIH R01 FOA requirements to JSON.

Implement the decomposition as an explicit, ordered sequence:

1. Raw ingestion and artifact stripping. Parse incoming budget data from whatever the finance office exports — CSV, JSON, XML, or PDF form fields — and strip the agency-specific formatting artifacts that corrupt downstream comparisons: stray carriage returns (\r), non-breaking spaces ( ), zero-width joiners, and proprietary PDF form-field tags.
2. Canonical dictionary construction. Map every extracted value into one internal model with explicit type coercion. Fringe-benefit percentages, indirect-cost-rate identifiers, and personnel effort allocations are normalized to Decimal or canonical string forms so that a “33.5%” fringe from a spreadsheet and a “0.335” fringe from a form become the same value.
3. Agency variant routing. Tag the normalized payload with a target agency identifier. The routing engine then applies only presentation rules — NIH character truncation, NSF plain-text sanitization, DoD FAR/DFARS metadata injection — without ever mutating the underlying canonical numbers.

Keeping steps 2 and 3 separate is the whole point: the money is decided once, in the canonical model, and formatting is a pure function of (canonical_model, agency). Nothing about NIH’s character limit is allowed to change what a line item costs.

# Phase 2 — Build the canonical model and the agency router

The canonical model is a typed contract. Use pydantic v2 so that type mismatches, out-of-range effort percentages, and missing mandatory fields are caught at construction time rather than at portal ingestion. Effort is stored as a fraction in [0, 1] and cost as Decimal to avoid float drift in totals that auditors will re-add by hand.

from decimal import Decimal
from pydantic import BaseModel, field_validator

class PersonnelLineItem(BaseModel):
    name: str
    role: str
    effort_percent: Decimal          # canonical: fraction in [0.0, 1.0]
    base_salary: Decimal
    fringe_rate: Decimal
    justification_text: str

    @field_validator("effort_percent", "fringe_rate")
    @classmethod
    def validate_fraction(cls, v: Decimal) -> Decimal:
        if not (Decimal("0.0") <= v <= Decimal("1.0")):
            raise ValueError("effort_percent and fringe_rate must be fractions in [0.0, 1.0]")
        return v

class CanonicalBudget(BaseModel):
    project_id: str
    personnel: list[PersonnelLineItem]
    equipment: Decimal
    travel: Decimal
    participant_support: Decimal
    other_direct: Decimal
    indirect_rate_id: str            # references the institution's rate agreement

The router consumes a CanonicalBudget plus a target agency and dispatches to the correct transform. Each transform is deterministic and side-effect free, which is what makes the output reproducible across re-runs:

from typing import Callable

def render_nih(budget: CanonicalBudget) -> dict:
    """R&R module: enforce per-category character ceilings, keep Arial-safe text."""
    ...

def render_nsf(budget: CanonicalBudget) -> dict:
    """Research.gov: plain-text only, fixed cost-category buckets."""
    ...

def render_dod(budget: CanonicalBudget) -> dict:
    """BAA: inject FAR/DFARS cost-principle mappings and depreciation schedule."""
    ...

AGENCY_ROUTER: dict[str, Callable[[CanonicalBudget], dict]] = {
    "NIH": render_nih,
    "NSF": render_nsf,
    "DoD": render_dod,
}

def render_for(budget: CanonicalBudget, agency: str) -> dict:
    try:
        return AGENCY_ROUTER[agency](budget)
    except KeyError as exc:
        raise ValueError(f"No budget renderer registered for agency {agency!r}") from exc

The routing branch is the core of the transformation, and it is worth seeing as a flow:

# Phase 3 — Edge cases and agency-specific overrides

Every agency encodes at least one rule that will corrupt a naive render. Treat these as versioned overrides keyed by agency, not as constants baked into the transform.

Three overrides do the most damage if handled carelessly:

• Boundary-aware truncation. When a justification block exceeds NIH’s 6,000-character ceiling, never cut mid-word or mid-sentence. Truncate at the nearest sentence boundary at or below the limit and attach a flag that routes the block for manual review rather than shipping a mangled paragraph.
• Cross-referential integrity. Every personnel line references a role and every budget references an indirect_rate_id. Validate that those identifiers exist in the institution’s master rate agreement before rendering — an orphaned indirect-rate reference is a silent under- or over-recovery that surfaces only in an audit.
• Plain-text sanitization for NSF. Research.gov rejects smart quotes, non-breaking spaces, and any residual HTML. Collapse whitespace and normalize typographic characters as the last step of render_nsf, after the canonical text is otherwise final.

def truncate_on_sentence(text: str, limit: int) -> tuple[str, bool]:
    """Truncate at the last sentence boundary at or under `limit`.

    Returns (text, needs_review). needs_review is True when truncation
    occurred, so the caller can quarantine the block instead of shipping it.
    """
    if len(text) <= limit:
        return text, False
    window = text[:limit]
    cut = max(window.rfind(". "), window.rfind("? "), window.rfind("! "))
    if cut == -1:                      # no sentence boundary in range
        return window.rstrip(), True
    return text[: cut + 1], True

The character ceilings themselves are a compliance rule, not a rendering detail, so they belong in the same family as the page-limit and font enforcement checks — see enforcing NIH 12-page limit rules programmatically for the analogous document-length case.

# Phase 4 — Validate and verify before downstream handoff

A rendered payload is only trustworthy if it is verified against the agency’s own schema and accompanied by an audit trail. Run canonical validation first (Pydantic construction), then agency-payload verification, then emit a compliance manifest. This is the point where the pipeline hands off to the compliance validation rule engines; the same manifest structure is consumed by the schema validation with Pydantic gate on the ingestion side.

import hashlib
import json
from datetime import datetime, timezone

def build_manifest(budget: CanonicalBudget, agency: str, schema_version: str) -> dict:
    """Emit an immutable, verifiable record of one render+validate cycle."""
    payload = render_for(budget, agency)
    serialized = json.dumps(payload, sort_keys=True, default=str).encode("utf-8")
    return {
        "project_id": budget.project_id,
        "agency": agency,
        "schema_version": schema_version,
        "payload_sha256": hashlib.sha256(serialized).hexdigest(),
        "validated_at": datetime.now(timezone.utc).isoformat(),
        "compliance_status": "PASS",     # set only after all rules pass
    }

Before any payload is transmitted, confirm the following checklist:

1. Schema version hash recorded. The exact NIH R&R XSD, NSF Research.gov JSON schema, or DoD BAA element set used for validation is captured by version.
2. Payload checksum generated. A SHA-256 of the sorted, serialized payload detects any post-validation tampering.
3. Rule execution logged. Every rule that ran — including the governing standard (2 CFR 200.430, NSF PAPPG II.C.2.g, FAR Part 31) — is appended with a pass/fail result.
4. Pre-submission gate closed. Transmission is blocked unless compliance_status == "PASS" and the manifest is present. No payload reaches an agency portal without one.

With those four in place, budget justifications stay structurally consistent across agencies while every submission carries a reproducible proof of the rules it satisfied. The same pattern extends to the DoD BAA compliance matrix generation work, where FAR/DFARS metadata is verified the same way.

# Frequently asked questions

# Related

• Budget justification format standards — the parent standards this normalization enforces.
• How to map NIH R01 FOA requirements to JSON — the conditional-override pattern applied to solicitation rules.
• DoD BAA compliance matrix generation in Python — verifying FAR/DFARS metadata the same way.
• Compliance validation rule engines — where the rendered payloads are finally gated.
• Schema validation with Pydantic — the typed-contract technique used for the canonical model.

Up one level: Budget Justification Format Standards