Good software
is a living loop.

Goal: establish whose problem is worth solving and what improvement would look like. Discovery reduces the risk of building a polished solution to the wrong need.

• Interview users and observe the existing workflow.
• Map pain points, constraints, alternatives, and affected systems.
• Test assumptions with prototypes, data, or a small experiment.
• Define outcomes and baseline measures before choosing features.

Outputs: problem statement, user journeys, opportunity hypotheses, risks, success measures, and an initial product brief.

Goal: turn the problem into a shared, testable direction while keeping the solution open enough to learn.

• Describe user needs, functional behavior, and acceptance examples.
• Set non-functional requirements: availability, privacy, latency, accessibility, and scale.
• Prioritize a thin first release and make exclusions explicit.
• Estimate uncertainty, dependencies, cost, and delivery risk.

Outputs: outcome brief, prioritized backlog, acceptance criteria, constraints, release boundaries, and a plan for unresolved questions.

Goal: choose an experience and technical approach that meet user needs and fit operational constraints.

• Prototype key journeys, content, empty states, errors, and edge cases.
• Design service boundaries, data models, APIs, and integration contracts.
• Review security, privacy, accessibility, reliability, and migration implications.
• Record important decisions and alternatives so future changes have context.

Outputs: tested flows, interface specification, architecture decisions, data/API contracts, threat considerations, and an implementation plan.

Goal: turn validated design into maintainable, reviewable software in small increments.

• Set up version control, reproducible environments, CI, and coding conventions.
• Implement vertical slices across UI, services, data, and integrations.
• Review changes for behavior, readability, security, and operability.
• Add focused unit and integration checks alongside implementation.

Outputs: reviewed code, automated checks, updated technical documentation, and a deployable artifact tied to a known source revision.

Goal: gather enough evidence that the software behaves correctly, safely, and predictably for the intended release.

• Run unit, contract, integration, end-to-end, and regression checks at the right layer.
• Test accessibility, performance, security, failure handling, and supported environments.
• Validate important workflows with users or product owners against acceptance criteria.
• Triage defects by user impact and release risk; document known limitations.

Outputs: test results, defect decisions, security findings, release risks, and a clear go/no-go recommendation.

Goal: move a known build into the intended environment with a safe path forward and a safe path back.

• Package and identify the exact artifact, configuration, and source revision.
• Use staged rollout, canaries, feature flags, or limited cohorts where appropriate.
• Manage schema/data migrations and backward compatibility deliberately.
• Prepare release notes, support guidance, monitoring, and rollback or roll-forward steps.

Outputs: deployed version, release record, migration result, change communication, and verified recovery plan.

Goal: keep the live product healthy and make its real behavior observable to the people responsible for it.

• Track service-level indicators such as availability, latency, and error rate.
• Use logs, metrics, and traces to diagnose behavior without exposing sensitive data.
• Handle incidents with clear ownership, communication, mitigation, and learning.
• Support users, manage access, patch dependencies, and maintain backups/recovery.

Outputs: service health, support insights, incident records, operational runbooks, and evidence about real-world usage.

Goal: use product and service evidence to improve the next iteration—or retire the product responsibly when it no longer creates enough value.

• Compare outcomes with the original measures and user feedback.
• Prioritize fixes, usability improvements, new capabilities, and technical debt.
• Refresh dependencies, data policies, security controls, and architecture as context changes.
• When retiring, migrate users/data, communicate timelines, revoke access, and decommission infrastructure.

Outputs: a new set of priorities, revised assumptions, improvement work, or a retirement and migration plan.