Labs
Labs are the practice and reasoning layer of ASI Backbone Learning.
Tutorials explain architectural boundaries.
Executable samples demonstrate them.
Labs ask you to work with those boundaries yourself.
The intended progression is:
Tutorial
↓
Executable Sample
↓
Hands-On Lab
↓
Alternative Approach
↓
Working Repository
Current Status
The lab navigation foundation is established, with four beginner labs, five intermediate labs, and two advanced labs now available.
Additional labs will appear in this section as the learning path expands into deeper architecture, security, and AI-governance topics.
The foundational labs pair all five governance tutorials with executable companion samples and ask learners to modify, challenge, extend, and threat-model the demonstrated boundaries. The ASP.NET Core diagnostic lab begins the next learning area by requiring learners to predict, observe, repair, and explain middleware-ordering behavior.
Available Labs
Decision Before Execution
Difficulty: Beginner
Break the execution boundary deliberately, observe why correct decision values are insufficient when the host ignores them, repair the boundary, and add a new policy constraint without moving governance logic into the executor.
Related material:
Policy Context and Explicit Decision Outcomes
Policy Context and Explicit Decision Outcomes
Difficulty: Beginner
Collapse structured decisions back to a boolean to observe the information loss, extend the explicit policy context, add a stable reason-coded rule, and make rule precedence observable and testable.
Related material:
- Policy Context and Explicit Decision Outcomes tutorial
- Policy Context and Explicit Decision Outcomes sample
Identify and Remove a Hidden Execution Side Effect
Identify and Remove a Hidden Execution Side Effect
Difficulty: Beginner
Start from deliberately flawed policy code that quietly starts an external deployment while it is still "checking" the request, make the denied-side-effect invariant fail visibly, and refactor the workflow so evaluation is observational and execution occurs only after an explicit decision boundary.
Related material:
Identify Middleware Ordering Problems
Identify Middleware Ordering Problems
Difficulty: Beginner
Run the deliberately incorrect ASP.NET Core pipeline, predict and observe the failure boundary, encode the repaired behavior in a focused test, reorder a disposable copy of the sample, and explain the changed request/response behavior in terms of wrapping, reachability, and coverage rather than a memorized middleware list.
Related material:
- Middleware Ordering Changes Behavior
- Middleware Ordering Changes Behavior sample
- ASP.NET Core learning area
Acknowledgment and Audit Residue
Acknowledgment and Audit Residue
Difficulty: Intermediate
Break the acknowledgment boundary deliberately, add another response-binding failure, expose replay as a state problem, preserve correlated evidence behind an in-memory store, and distinguish an allowed decision from a failed execution.
Related material:
Scoped Capability and Host-Owned Execution
Scoped Capability and Host-Owned Execution
Difficulty: Intermediate
Break expiration and resource-freshness checks deliberately, observe how stale authority can reach execution, restore narrow execution-boundary validation, and extend the sample with additional binding and replay exercises.
Related material:
- Scoped Capability and Host-Owned Execution tutorial
- Scoped Capability and Host-Owned Execution sample
Replay Protection and Bounded-Use Authority
Replay Protection and Bounded-Use Authority
Difficulty: Intermediate
Reproduce a deterministic check-then-act race, repair it with atomic TryConsume semantics, prove that exactly one concurrent final-use consumer reaches protected execution, and reason about evidence, cancellation, durable state, idempotency, and the failure window between consumption and execution.
Related material:
- Replay Protection and Bounded-Use Authority tutorial
- Replay Protection and Bounded-Use Authority sample
- Data Access Boundaries and Transaction Reasoning
Policy-Version Evidence in Governance Decisions
Policy-Version Evidence in Governance Decisions
Difficulty: Intermediate
Preserve the policy identity that produced a decision, detect policy drift across acknowledgment, capability issuance, and execution, and distinguish useful provenance from perfect replay or cryptographic proof.
Related material:
- Policy Context and Explicit Decision Outcomes sample
- Acknowledgment and Audit Residue lab
- Scoped Capability and Host-Owned Execution lab
Build a Governed API Operation
Build a Governed API Operation
Difficulty: Intermediate
Extend an authorized ASP.NET Core account-disable endpoint into a governed operation with explicit intent, authoritative context, structured outcomes, acknowledgment, scoped authority, host-owned execution, audit residue, and integration tests that prove blocked paths never invoke the underlying account service.
Related material:
- When ASP.NET Core Authorization Is Enough
- Policy Context and Explicit Decision Outcomes
- Acknowledgment and Audit Residue
- Scoped Capability and Host-Owned Execution
- ASP.NET Core learning area
Governed AI Tool Gateway
Difficulty: Advanced
Compose the foundational patterns into one AI-assisted execution boundary, deliberately weaken proposal, context, acknowledgment, capability, replay, prompt, credential, and failure-mode controls, then threat-model the complete gateway.
Related material:
Safe Degraded Mode and Fail-Safe Governance
Safe Degraded Mode and Fail-Safe Governance
Difficulty: Advanced
Classify which trust or operational property is unavailable, compare low-consequence and consequential operations, design explicit deny/defer/escalate or bounded degraded behavior, and prove that policy, replay, verification, acknowledgment, evidence, and executor failures do not silently manufacture execution authority.
Related material:
- Governed AI Tool Gateway sample
- Replay Protection and Bounded-Use Authority
- Signing, Verification, Key Custody, and Tamper Evidence
- Centralized Error Handling and Problem Details
- Policy Versioning and Decision Provenance
Start with the Tutorials
The foundational tutorial sequence establishes the concepts that the initial labs will build upon:
Topics include:
- Decision before execution
- Explicit policy context and decision outcomes
- Acknowledgment and audit residue
- Scoped capability and host-owned execution
- Governed AI tool gateways
Study the Executable Samples
The executable sample area provides small runnable demonstrations corresponding to the tutorial concepts.
Samples demonstrate known behavior.
Labs will increasingly ask learners to modify, repair, critique, or extend that behavior.
Inspect the Working Repositories
After working through a teaching example or lab, compare the smaller architecture with fuller implementations.
AsiBackbone
A .NET governance and policy-control framework providing fuller implementations of policy evaluation, structured decisions, acknowledgment workflows, audit residue, scoped capability, and host-owned execution.
NetCoreApplicationTemplate
AsiBackbone/NetCoreApplicationTemplate
An ASP.NET Core reference architecture demonstrating secure defaults, middleware organization, structured logging, rate limiting, authentication-ready design, data-access patterns, and operational application structure.
Learning Principle
The objective of a lab is not simply to reproduce a tutorial.
A useful lab should require you to make a decision, identify a failure mode, improve an architecture, or explain why one implementation is preferable under a particular set of constraints.
Read it. Run it. Question it. Improve it.