The Product Cycle 🔄

Collaborative Artifacts for Co-design

The Product Cycle refers the set common product design artifacts that inform each other throughout the sofware development and operational lifecycle. Common design artifacts capture information about user needs and business contexts that inform iterative development cycles.

Product Cycle Diagram Personas to Use Cases to Concept/Data Model to Wireframes to Screen Designs to Tested, Working Software, then repeat. Product Backlog Reflexive system — artifacts inform each other PM facilitates; aligns with users & business Personas Use Cases Concept Inventory → Data Model Wireframes sketches Screen Designs Tested, Working Software
Definition

A set of collaborative, structured artifacts that act as the conceptual interface between evolving user and business contexts and the operational reality of software in production — centered on a Product Backlog, facilitated by the Product Manager.

From visuals to data

Service blueprints, journey maps, and shared boards are invaluable for alignment — but as pictures and prose they rarely yield structured information that digital systems can act on. By leaning into the data objects these artifacts imply, we unlock modeling and automation that enable better Co‑Design across teams and organizations. As more organizational functions become software, these structured artifacts integrate directly with continuous integration pipelines.

Limitations of visual artifacts

  • Unstructured: hard to query, link, or compute on.
  • Stale quickly: updates don’t propagate across related docs.
  • Ambiguous: intent and scope aren’t machine‑checkable.
  • Hard to test: can’t express acceptance criteria or trace to outcomes.

Treat artifacts as data objects

  • Structured fields for personas, use cases, concepts, and states.
  • Traceability: link stories ↔ tests ↔ releases ↔ analytics.
  • Modeling: run queries, generate views, and automate handoffs.
  • Co‑Design: shared language and source of truth for all stakeholders.

The Product Cycle

Most software efforts move through the same essential steps — with more or less explicitness. Keep them lightweight, connected, and reflexive — changes in one artifact should inform the others. At the center is the Product Backlog, with the Product Manager as facilitator and point person aligning the product with users’ and business needs.

Personas

Start with user needs. Observe behaviors and goals, then group similar patterns into personas. Keep them brief, evidence‑based, and actionable.

Use Cases

For each persona, describe concrete scenarios: triggers, steps, and desired outcomes. These stories clarify scope and later become acceptance criteria.

Concept → Data Model

List the domain nouns (concept inventory) and their relationships; distill them into a structured data model that software and reports can rely on.

Wireframes & UI Design

Rough first: flows, navigation, and key screens. Then refine layouts and states. Make the path clear before polishing details.

Screen Designs

High‑fidelity screens with components, states, and accessibility in mind. Keep parts reusable and consistent.

Working, Tested Software

Ship small changes often. Automate checks. Test with users. Measure what happens and feed learning back into the backlog.

Surface area for learning

The Product Cycle provides deliberate surface area to assimilate useful information and signals:

  • Users and their needs
  • Concepts and the evolving data model
  • Specific product interfaces and states
  • How flows connect across steps, services, and teams
  • Analytics and operational metrics from production

These inputs inform iterative work that is captured in the Product Backlog in a common, repeatable way.

And repeat — Treat the cycle as a loop. Each cycle is an opportunity to refine understanding about users, needs, and product behavior.

Development workflow

Development work is expressed as user stories with clear user value and acceptance criteria that define an objective Definition of Done. Stories become automated tests; implementations follow the assertions. The Product Manager facilitates and serves as the point person for aligning the product with users’ and business needs — coordinating task information and work the way the team sees fit.

From story → tests → implementation

  • User stories articulate user value and acceptance criteria (Definition of Done).
  • Executable specs translate criteria into automated tests (BDD/TDD).
  • Implementations satisfy tests and trace back to story IDs.
  • Continuous integration runs tests; green builds evidence Done.
  • Backlog organizes and prioritizes work; inputs come from personas, use cases, analytics, and research.
  • Analytics & research update personas and use cases; new insights create or adjust stories.
  • Repeatable templates ensure signals are captured consistently across items.

Example

# User Story
As a program manager,
I want to capture feedback on a form,
so that I can measure service quality.

# Acceptance Criteria
- Given a published form,
  When a visitor submits all required fields,
  Then the response is persisted and visible in reports.

# Test (pseudo)
it('persists valid submissions and updates reports', () => {
  publish(form)
  submit(validSubmission)
  expect(db.responses.last()).toMatch(validSubmission)
  expect(report.count).toBeGreaterThan(0)
})

Product artifacts inform Continuous Integration

When artifacts are structured as data, CI can enforce and automate them.

  • Contracts: data models and API schemas gate incompatible changes.
  • Design tokens & states generate visual and interaction regression tests.
  • Use cases → executable specs drive end‑to‑end checks in CI.
  • Traceability: story IDs link commits, tests, releases, and analytics.
  • Telemetry expectations validate outcomes post‑release.

More organizational functions are software; software is the medium.

Make artifacts living

Design artifacts become most useful when they’re continuously updated to reflect evolving thought, design, and system architecture — like a garden that needs regular tending, pruning, and nourishment.

Get started in 30 minutes

Create a simple, living Product Cycle for your team:

  1. 1 List your artifacts: personas, use cases, models, flows, screens, working build.
  2. 2 Pick a home: a shared doc space or repo. One URL per artifact.
  3. 3 Connect them: link forward and back so context flows.
  4. 4 Set a cadence: review monthly; make tiny improvements.
  5. 5 Ship and learn: release, test, measure, and feed insights back into the cycle.

About

The Product Cycle describes a repeatable cycle; a meta-framework iterative product design. By considering how user needs inform the data model and the interaface design; The Product Cycle is reflexive, living system of artifacts centered on a Product Backlog, with a Product Manager as facilitator and point person aligning the product with users’ and business needs.