OR-001a — Developer Operations

Go to OR-001 — Operation by Identified User Categories

Statement

Crucible SHALL enable a Developer to perform each Crucible operation identified for the Developer by the applicable operational scenario.

Derived From

This requirement derives from:

The Original Requirement states:

The system SHALL support operation by: Developers DevSecOps Engineers Platform Engineers System Administrators Security Engineers Compliance Officers[C1]

OR-001a preserves the portion of the Original Requirement that requires Crucible to support operation by Developers.

The separate requirements derived from OR-001 address:

Assessment

The Original Requirement uses operation without identifying the actions performed by a Developer.

The term operation can refer to:

Initiating a Crucible workflowProviding or selecting Controlled InputsInitiating a Machine Image buildMonitoring a buildReviewing build resultsReviewing captured dependenciesInitiating an Infrastructure DeploymentMonitoring an Infrastructure DeploymentReviewing generated EvidenceInvestigating a failed operationThe Original Requirement does not identify:

The Crucible operations performed by a DeveloperThe operational scenarios in which the Developer participatesWhether the Developer initiates, executes, configures, reviews, monitors, or observes an operationThe interfaces used by the DeveloperThe inputs provided by the DeveloperThe outputs received or reviewed by the DeveloperThe conditions applicable to the Developer operationThe acceptance condition demonstrating operation by a DeveloperOR-001a:

Identifies Crucible as the responsible systemReplaces support with the observable action enableIdentifies a Developer as the applicable user categoryIdentifies the applicable operational scenario as the source of the Developer operationsAvoids introducing an Operational Role, role-assignment mechanism, or role-based authorization modelSeparates Developer operation from operation by the other user categories listed in OR-001The Statement uses each Crucible operation identified for the Developer to apply one consistent enablement obligation across the operations assigned to the Developer by the applicable operational scenario.

When an operational scenario identifies independently testable Developer activities with different actors, objects, conditions, or completion criteria, those activities should be expressed through existing atomic requirements or additional requirements rather than embedded within OR-001a.

Concept of Operations Interpretation

The Concept of Operations identifies the following high-level Crucible operations:

Build — Crucible builds Machine Images while applying the applicable image-hardening configurationCapture — Crucible captures build dependencies and compliance findings into managed storageDeploy — Crucible provisions infrastructure and executes the applicable pre-deployment and post-deployment stepsThe cited Concept of Operations passage does not, by itself, state which of these operations a Developer performs.

A Developer can participate in a Crucible operation by:

Initiating the operationProviding inputs to the operationSelecting applicable configurationMonitoring executionReviewing resultsResponding to failuresThe applicable operational scenario should identify the Developer participation relevant to each operation.

OR-001a does not independently allocate Build, Capture, or Deploy to the Developer. The allocation must remain traceable to the Concept of Operations, an architecture section, or an existing requirement.

Requirement Reuse Assessment

Before creating a lower-level requirement to realize OR-001a, the requirements corpus should be checked for an existing requirement that already defines the applicable Developer behavior.

An existing requirement can be reused when:

The required Crucible behavior is the sameThe subject and object of the behavior are compatibleThe requirement applies to Developer participationThe operational conditions cover the applicable scenarioThe verification outcome demonstrates Developer operationReuse does not broaden or change the meaning of the existing requirementThe following requirements should be examined for reuse:

Image-management requirements governing Machine Image BuildConfiguration-management requirements governing Developer-provided configurationDependency-capture requirements governing CaptureDeployment-orchestration requirements governing DeployDevSecOps integration requirements governing workflow initiation and monitoringInterface requirements governing graphical, command-line, application programming, and automation interfacesSecurity requirements governing authentication and authorizationLogging requirements governing operational event recordsEvidence, Provenance, Auditability, and Traceability requirements governing preservation of operational resultsA new requirement should be created only when no existing requirement defines the required Developer behavior with the correct actor, object, conditions, and acceptance criteria.

OR-001a establishes that Developers can perform their identified Crucible operations. It does not duplicate the detailed requirements governing Build, Capture, Deploy, security, logging, or interfaces.

Rationale

Developers need access to the Crucible operations required to prepare, initiate, monitor, and evaluate development-related workflows.

Developer participation can include:

Preparing source contentPreparing configuration contentProviding Controlled InputsSelecting an applicable build or deployment descriptionInitiating a permitted workflowMonitoring workflow executionReviewing generated ArtifactsReviewing workflow resultsReviewing generated EvidenceInvestigating errors and failed operationsThe applicable operational scenario determines which activities apply to the Developer.

Enabling Developer operations supports:

Development workflow executionEarly validation of configuration changesRepeatable Machine Image BuildReview of captured dependenciesEvaluation of deployment resultsIdentification of defects before promotionIntegration with DevSecOps workflowsThis requirement does not require Developers to perform every Crucible operation.

This requirement does not establish the authorization model governing Developer access. Applicable Security Requirements establish authentication, authorization, and access-control behavior.

This requirement does not define the detailed Build, Capture, or Deploy behavior. Existing functional requirements should define and realize those operations.

Applies To

This requirement applies to:

DevelopersOperational scenariosDeveloper activitiesBuild operationsCapture operationsDeploy operationsControlled InputsMachine ImagesInfrastructure BaselinesInfrastructure DeploymentsUser interfacesCommand-line interfacesApplication programming interfacesAutomation interfacesWorkflow resultsFailure and exception resultsEvidenceProvenanceTraceability

Verification

Verification confirms that:

The applicable operational scenario is identifiedThe Developer operations identified by the operational scenario are enumeratedThe interface applicable to each Developer operation is identifiedThe inputs required by each Developer operation are identifiedThe outputs produced or presented by each Developer operation are identifiedA Developer can perform each identified Developer operationEach operation produces an identified resultFailed operations produce an observable resultExisting requirements used to realize each Developer operation are identifiedThe verification record preserves the required Evidence, Provenance, and TraceabilityVerification includes:

Operational scenario inspectionDeveloper activity inspectionRequirement reuse inspectionInterface inspectionControlled Input inspectionDeveloper workflow testingBuild-operation testing, when applicableCapture-operation testing, when applicableDeploy-operation testing, when applicableWorkflow monitoring testingResult-review testingFailure and exception testingEvidence inspectionProvenance inspectionTraceability inspectionThe verification record identifies:

The applicable operational scenarioThe DeveloperEach identified Developer operationThe interface used for each operationThe inputs provided for each operationThe existing requirement or requirements realizing each operationThe result of each operationEach generated ArtifactEach generated failure or exception resultEach identified coverage gapThe observed resultThe generated Evidence

Requirements Realized By

This requirement is realized by applicable existing requirements governing:

Configuration managementMachine Image managementDeployment orchestrationDevSecOps integrationDependency captureUser and automation interfacesAuthentication and authorizationLoggingEvidence, Provenance, Auditability, and TraceabilitySpecific realization links should be added only after confirming that each referenced requirement provides Developer access to the applicable operation.

Related Architecture Sections

Referenced By

The following pages reference this requirement:

Delivery Phase

Phase 1 and subsequent phases

Implementation Status

Not Assessed

Implementation status requires identification of the Crucible operations assigned to Developers by the applicable operational scenarios and verification that Developers can perform those operations.

Requirement Status

Draft

This requirement derives from OR-001 in the Crucible System Requirements Specification, Version 1.1 Draft.

Notes for Editors

This requirement page should retain the stable requirement identifier OR-001a.

This page is a leaf requirement page and omits a trailing :start from its namespace.

Changes to the Statement should preserve the requirement that Developers can perform the Crucible operations identified for them by applicable operational scenarios.

Do not introduce an Operational Role, role-assignment mechanism, authorization model, or access-control model unless a controlling source establishes that concept.

Before creating an additional Developer-operation requirement:

Review the applicable Concept of Operations scenarioIdentify the specific Developer activitySearch the existing requirements corpus for equivalent behaviorReuse an existing requirement when its actor, behavior, object, conditions, and verification outcome provide the required coverageCreate a new requirement only when the reuse review identifies a coverage gapThe operational scenario should identify:

The Developer activityThe applicable Crucible operationThe interface usedThe inputs providedThe outputs received or reviewedThe applicable starting conditionThe applicable completion conditionThe applicable failure conditionThe existing requirements governing the operationThe required EvidenceMaterial changes should receive review and should update the related verification criteria, requirements realization, related architecture sections, and source records.

To reference this requirement Statement from another wiki page, insert:

{{section>dido:02-crusible:99-annexes:annex-c-requirements:02-operational-requirements:or-001:or-001a#Statement&noheader&nofooter&noeditbtn}}

Do not rename this page after an external citation unless a redirect or move plan is in place.

© 2026 Dido Solutions, Inc. and Jackrabbit Consulting, Inc.