Orbit Framework

Problem-First Software Development for Precise Product Delivery and Flow

Orbit is a lightweight, semi-structured, breadth-first methodology that mirrors how humans naturally break down complex problems. It encourages teams to see the full picture, understand why they're building, and continuously turn ambiguity into predictable action.

Explore the Orbit Flow Map See the Practice Loop
Diagram showing the cyclical nature of the Orbit Framework process

The Foundational Beliefs: Four Pillars of Orbit

These four pillars represent the foundational beliefs that underpin every aspect of the Orbit framework, shaping its processes and guiding its adoption.

Problem-Driven Development

No work begins until the underlying problem is clearly defined from a user or business perspective. Orbit insists that understanding why we are building is paramount, shifting the focus from output to outcome.

Clarity and Predictability

Decisions and forecasts must be based on transparently understood complexity and resolved ambiguity. Orbit provides tools to systematically surface unknowns for realistic expectations, fostering stakeholder trust.

Value-Oriented Learning Cycles

"Value is created through small, incremental builds and continuously validated with real-world feedback. This fosters a robust cycle of adaptation that constantly refines the product and its delivery.

Agility is Dependent on Craftsmanship

True agility is directly tied to the skill level and continuous learning of the development team. Teams must reflect on their skill status and actively acquire new skills to ensure well-crafted artifacts and quality.


The Orbit Product Flow and Hierarchy

Orbit is a dynamic, cyclical, and integrated process. The Orbit Flow Map (Hierarchy) is its central artifact, providing a shared, holistic view that the entire team "orbits" around, ensuring alignment at all levels.

The Orbit Flow Map: Layered Structure and Shared Context

The entire team collaborates to build this map, ensuring a shared understanding from abstraction to detail.

1. Problem Statement

The Why and For Whom. Must be concise and outcome-oriented. (Product Focus)

2. Solution Journey

The high-level user path (4-6 steps). Charts the intended user experience. (Product/Design Focus)

3. Deliverables

Tangible components (code, designs) required for each journey step. (Design/Engineering Focus)

4. Executable Actions

The granular tasks broken down from Deliverables. These are the items scored for complexity. (Engineering Focus)

Workshop: The Problem Flow Map Workshop is a 2–4 hour session used to collaboratively build this structure and flag initial Vague items.

Hierarchical diagram showing the flow from Problem Statement down to Executable Actions.

Clarity, Risk, and Predictability: Complexity Scoring

Orbit replaces unreliable, time-based estimates with an objective Weighted Scoring Model based on five key complexity factors. This approach highlights risks and drives proactive discovery.

The Five Complexity Factors (Scored 1-5)

Domain Clarity

Understanding of business rules, requirements, and edge cases. Are the rules clear?

Technical Dependencies

Reliance on legacy components, external services, or integrations. Are the systems reliable?

External Dependencies

Relying on coordination or decisions from other internal teams. Are the people aligned?

Team Familiarity

Familiarity with the required technologies, tools, or codebase. Are the skills present?

What is a Vague Item? (The Critical Risk Signal)

An Executable Action whose average score across all factors is > 3.5 is categorized as Vague. This signals that there is not enough clarity to accurately estimate or begin implementation.

Action: Resolve Vague items through a time-boxed spike (exploration) before committing to the main build.

Complexity Buckets (Informing Forecasts)

After scoring, actions are categorized into these buckets to quickly communicate overall complexity and inform adaptive forecasts (based on empirical cycle velocity, not rigid dates):

Tiny (1.0 - 1.5)

Very low complexity. Clear requirements, familiar tech, minimal dependencies.

Medium (1.6 - 2.5)

Moderate complexity. Well-understood but may involve minor dependencies or a slightly less familiar domain.

Large (2.6 - 3.5)

Significant complexity. Likely involves several dependencies, some ambiguity, or notable cross-team coordination.

Vague (> 3.5)

High Ambiguity. Requires a dedicated discovery spike before it can be re-scored into a bucket for implementation.


Team Flow: Roles in Orbit vs. Traditional Titles

In Orbit, roles are functions of contribution, emphasizing deep cross-functional collaboration. Ownership is shared, and expertise is contextual. What matters is who can best contribute to clarity at a given phase, not their rigid organizational title.

Diagram showing the four collaborative Orbit roles: Problem Facilitator, Solution Builder, Discovery Catalyst, and Delivery Steward.

Problem & Purpose Facilitator

Traditional equivalent: Product Owner/Product Manager.

Involvement: Defines Problem, Shapes Journey, Manages Stakeholder Expectations.

Solution Enabler/Builder

Traditional equivalent:Senior Engineer/Architect/Tech Lead.

Involvement: Breaks into Executable Actions, Leads Complexity Scoring, Resolves Vague items.

Discovery Catalyst

Traditional equivalent: UX Designer/Product Designer.

Involvement: Refines Solution Journey, Identifies Design Deliverables, Contributes to Complexity Scoring.

Delivery Facilitator / Steward

Traditional equivalent: Scrum Master/Team Lead (Process Focus).

Involvement: Facilitates Workshops, Ensures Correct Level of Abstraction, Mediates Ambiguity.

The Orbit Practice Loop: Turning Principles into Action

The Practice Loop is a dynamic set of twenty core practices across five areas—Discovery & Framing, Collaboration, Delivery, Validation, and Team Growth. They animate the Orbit structure, creating a culture of high-trust collaboration and continuous learning.

Discovery & Framing

Problem Framing, Assumption Surfacing, Vague Item Logging.

Collaboration & Design

Cross-Functional Pairing, Lightweight Design Sketching, Feedback Seeking Early.

Delivery & Execution

Just-In-Time Decomposition, Executable Action Scoring, Spike Before Build.

Validation & Learning

Outcome Review, Backward Thinking (Retros), Learning Metrics Reflection.

Team Growth & Sustainability

Skill Feedback Loop, Rhythm Calibration, Slack Time for Learning.

The goal is momentum, alignment, and learning. Start with a few practices, build rituals, reflect, and grow.

Ready to Master Product Clarity?

The Orbit Framework is ready to transform your team's development process, giving you the clarity needed to deliver predictable value. Start your journey today.

Read Chapter 1 & Get Started ▸ Follow Orbit on LinkedIn ▸