# Build your first system Install a signed One release archive, keep `distribution/` beside the executable, then run the same lifecycle used by every One application: ```console one init hello cd hello one setup one check one test one invoke say-hello request.json ``` `one init` creates canonical `.one` source, a small `one.one`, exact `one.lock`, and application-owned test data. The generated source declares a greeting contract, root, native One implementation, and no hidden Cargo project. The entry file is One source too. It contains exactly one project declaration: ```one one 1 semantic hello.one domain one.project@1 project Hello@1 source ./one/hello.one lock ./one.lock ``` The `one.project@1` declaration establishes project scope; the selected `one/hello.one` supplies the contracts, system declaration, root, and implementation claim. `one.one` cannot select itself as `source`, and neither declaration is a lock, plan, artifact, or runtime binding. `one setup` applies the reversible standard local configuration. It prints every provider package, configuration, selection constraint, and protected store it owns. Repeating setup is idempotent and preserves unrelated execution bindings. `one check` resolves the exact lock and verifies the selected semantic and implementation closure without executing it. `one test` runs the root's authored scenario through the same schema and operation contracts. `one invoke` accepts a positional JSON request only after the checked interface proves its schema. Build and release the same root locally: ```console one plan one build one observe local one release local build:sha256: one approve plan: one apply plan: one inspect operation: ``` The project plan selects an exact implementation and provider closure without mutation. Build consumes that selection without choosing again, and its reference resolves through the workspace CAS. Pass that exact Build reference to `release`, which commits the exact Build, provider configuration, observations, and Authority coordinates into an apply plan but stops before mutation. Approval remains distinct. Apply journals intent before dispatch; `one reconcile operation:` resumes the same operation after interruption without blind redispatch. Inspect the persistent loopback service without creating authority: ```console one inspect health one inspect logs ``` Export a directly consumable client from the exact Build: ```console one export client typescript build:sha256:… one export client rust build:sha256:… ``` Each export prints package identity, artifact digest, projection receipt, archive path, and installation command. Every displayed digest resolves to a complete owner record. Keep the project, lock, plan, Build report, release operation, and observations when you need the release to remain independently explainable or reproducible. You have followed One's ordinary path: ```text declare -> check -> test -> invoke -> plan -> build -> apply -> inspect ``` Starting from existing software? Follow [adopt an existing project](/one/start/adopt-project). Otherwise, continue to [the One mental model](/one/start/mental-model), then [the `.one` source language](/one/authoring/source-language).