Breaking Down Uncertainty: Structuring Exploratory Research For Agile Teams

Understanding Uncertainty in Agile Development

Uncertainty is an inherent part of agile software development. Unlike traditional waterfall development where requirements are meant to be fully defined upfront, agile methodologies embrace change and new information throughout the development lifecycle.

While this flexibility provides many benefits, it also introduces uncertainty around goals, timelines, feasibility, and priorities. Unexplored areas of the product space or problem domain can hide risky assumptions, technical challenges, or gaps between client needs and the development team’s interpretation.

Performing exploratory research is key to breaking down sources of uncertainty. This involves structured investigation to analyze needs, validate assumptions, spike solutions, and clarify unknowns. Embedding exploratory practices into team workflows can uncover issues early, before they escalate and cause larger problems down the line.

Defining Exploratory Research

Exploratory research refers to iterative investigation focused on opening up new information. It centers around probing with an open mindset, seeking patterns and insights that challenge current perspectives. Key aspects include:

Probing product ideas, technical concepts, user needs
Investigating assumptions, knowledge gaps, feasibility concerns
Pursuing alternate interpretations, gathering missing context
Informing follow-on studies, driving reflective discussions

In agile delivery, exploratory practices help structure uncertainty. Short feedback cycles reveal unknowns, enabling teams to refine direction. Common techniques involve research spikes, design sprints, prototype evaluations, assumption mapping, and pre-mortems.

Spikes for Technical Investigation

Development spikes are timeboxed experiments that scope technical risk, unknowns, and feasibility. By building simplified prototypes, spikes let teams quickly:

Explore architecture, integrate 3rd party services
Trial algorithms, infrastructure strategies
Flush out blocking issues, surface integration challenges
Determine implementation approaches, verify velocity

Lessons learned guide follow-on estimation, inform appropriate abstractions, and steer architectural commitments. Development spikes shrink the cone of uncertainty around solution delivery.

Sprints for Concept Investigation

Design sprints enable rapid validation of product concepts and user flows. Common activities include:

User interviews on mental models, pain points
Sketching flows, task models, and taxonomies
Prototyping and testing interaction approaches
Capturing feedback on utility, usability, desirability

Condensed timeframes pressure teams to clearly articulate what needs discovery. Interactive sessions with actual users check interpretations against reality.

Inspections Catch Invalid Assumptions

Assumption mapping drives inspection of project foundations. By enumerating key assumptions, teams externalize plausibility assessments and knowledge gaps. Typical steps include:

Listing assumptions around user goals, behaviors, preferences
Rating assumption validity, identifying critical uncertainties
Defining tests to probe assumptions, improve confidence
Reviewing results, revisiting direction if needed

Making assumptions explicit separates verification from execution. Structured testing targets knowledge gaps, ensuring teams build the right solutions.

Structuring Uncertainty

Exploratory activities require planning and structure to yield actionable findings. Teams should clearly define the target of investigation before beginning. Framing research around key questions and metrics steers efforts toward usable outputs.

Scoping the Unknowns

Well-bounded spikes investigate slim aspects of larger challenges. Narrow focus and lightweight implementation allows for rapid trial-and-error. Teams might explore:

Microservice feasibility for a backend system
Computer vision approaches for key product features
Effectiveness of certain algorithms relative to needs

Tight scoping contains redirections to lessons learned, not full solutions. Timeboxing to 1-2 weeks ensures closure and follow-on planning.

Framing Research Questions

Good research questions exhibit several qualities:

Specificity – Questions target narrow concepts versus broad topic areas
Measurability – Question frames invite quantitative and qualitative data capture
Actionability – Findings provably inform decisions and next steps
Relevance – Connects directly to current project and sprint goals

For example, instead of asking “Do users like our concept?”, drill down to precise aspects that need validation.

Defining Success Metrics

Metrics quantify progress, outcomes, and learnings. Strong metrics for exploratory research exhibit several factors:

Tied to questions – Directly measure responses the team needs
Mix of qualitative and quantitative – Capture subjective insights plus counts
Leading indicators – Reveal findings quickly from small samples
Easy to analyze – Simple calculations and summaries

Capturing both soft insights and hard data speeds useful interpretations.numbers provide anchors for discussing what was learned.

Embedding Flexibility in Team Workflows

Agile teams can embed lightweight exploratory practices within standard delivery workflows:

Exploration Spikes

Introduce a recurring spike slot into each sprint. One spike might investigate a backend API while another examines computer vision libraries. Spike findings get demoed alongside main sprint work to inform planning.

Assumption Backlogs

Maintain a backlog of assumptions around target users, roadmap concepts, and technical directions. Schedule regular reviews to probe top uncertainties, learning what still requires validation.

Design Sprints

Run an abbreviated design sprint before starting larger initiatives. Quickly probe user needs, desirable features, and workable interaction models to validate focus areas and success factors.

Lightweight Pre-Mortems

Ask team members to imagine project failure modes before each new sprint, reflecting on:

Where potential breakdowns might occur
Reasons efforts could miss goals or lose priority
Ways to monitor and avoid these pitfalls

Discussing possible failure illuminates hidden assumptions and unchecked risks.

Using Iterative Validation Cycles

Validation testing progresses understanding over multiple feedback loops. Short iterations with actual users quickly probe assumptions and concepts. Structuring cycles establishes rhythm and consistency:

Define the Focus

Bound the target for each feedback session around clear goals and metrics. Narrow questions drive productive engagement. Establish success factors upfront.

Engage Participants

Interact with a small number of users that represent target personas. Brief them on goals and logistics to set context. 3-4 participants works best.

Probe and Capture

Drive sessions with a guide that links goals to specific questions and activities. Capture both subjective feedback and measurable behaviors. Take notes on surprises, workarounds, and insights.

Synthesize and Socialize

Debrief findings as a team immediately after sessions while memory stays fresh. Summarize keytakeaways relative to the defined goals. Celebrate new learnings through demos, broadcasts, team meetings, etc.

Plan Next Tests

Quickly determine adjustments for the next validation cycle based on what was uncovered. Over multiple passes, identify gaps needing deeper research. Discoveries trigger spikes, feed backlogs, and shape sprint plans.

Managing Changing Requirements

Exploratory practices reveal new information about users, technologies, and desired outcomes. This drives requirement changes.

Clarifying Drivers

Requirements reflect assumptions, goals, and known constraints. Trace shifts back to new learnings that update these foundations. Explain connections to maintain integrity:

Updated user research guides changes
Spikes prove technical capabilities
Client feedback captures evolving needs

Factually documenting sources limits questioning impact. Show why modifications map to discoveries.

Localizing Scope

New information rightly shifts direction, but contained scope reduces downstream disruption. Consider localizing changes first:

Adjust user personas before changing all interfaces
Refine algorithms before rewriting infrastructure
Revise journey steps before scrapping entire flow

Gradual, incremental updates isolate downstream dependencies. Significant revelations may still require larger changes across multiple systems, teams, and timelines depending on interconnectedness.

Updating Roadmaps

Fixing requirements in multi-year roadmaps wastes exploratory gains. Instead, introduce flexibility:

Frame long-term initiatives as goal-focused versus specification-driven
Capture emerging technical and user insights frequently
Clearly designate uncertainty with TBD placeholders
Review direction quarterly with fresh research findings

Updating rollout plans yearly or quarterly incorporates new learnings smoothly. Continuously evolving understanding should improve solutions, not break them.

Adapting Agile Frameworks

Standard agile practices complement exploratory efforts:

Backlogs

Capture assumption tests and spike findings as backlog items
Add research requests from team members to backlogs
Schedule light exploratory items around other priorities

User Stories

Write explicit questions into stories needing discovery
Create lightweight stories just to probe concepts
Tag stories with affected assumptions

Standups

Call out blocks needing spikes or design sprints
Demo key learnings from recent tests
Discuss insights that might update stories

Retrospectives

Review validation practices what worked and didn’t
Discuss process improvements to embed more discovery
Plan assumption checks needed in next sprint

Lightweight exploratory practices integrate smoothly into agile ceremonies for continuous uncertainty reduction.

Example Code Snippets for Validation Checks

Here are some sample code snippets for validating key assumptions:

User Profile Accuracy

This script checks whether defined user personas match real analytics data on behavior:

“`python
import users_model from db
import segments from analytics

def validate_personas():

for persona in user_model:
mapping = match_persona(persona)
for key,value in mapping.items():
if value < 0.8: print("Persona", persona["name"], "does not match analytics for", key) def match_persona(persona): mappings = {} for key in persona: if key in segments: mappings[key] = cosine_similarity(persona[key], segments[key]) return mappings ```

Algorithm Performance

This script compares the accuracy of recommendation algorithms:

“`python
import EvaluationMetrics as EM

algorithms = [“collab_filter”, “content_based”]
test_data = load_test_set()

for algorithm in algorithms:

recs = get_recommendations(algorithm, test_data)

precision = EM.precision(recs)
recall = EM.recall(recs)

print(algorithm, “precision:”, precision, “recall:”, recall)
“`

Transaction Checkout Funnel

This snippet checks key funnel conversion metrics on transaction flows:

“`js

// Capture checkout funnel performance
const funnel = new Funnel(checkoutSteps);

funnel.addEventListener(‘step’, event => {

const step = event.step;
const convRate = step.converted/step.entered;

console.log(step.name, “Conversion Rate:”, convRate);

});

funnel.trackVisit(); // begin tracking
“`

These snippets demonstrate simple programmatic tests tailored to assumptions, usability, algorithms, and other key uncertainties uncovered during exploratory research. Automated checks provide fast feedback for updates.

Key Takeaways for Reducing Uncertainty

Key lessons on structuring exploratory practices:

Probe unknowns through spikes, sprints, rapid testing
Tightly scope efforts around key questions
Define metrics to gauge discoveries and progress
Embed lightweight discovery practices into team workflows
Iteratively validate with users early and often
Localize changes from new learnings when possible
Adapt agile frameworks to support ongoing discovery
Automate scripted tests aligned to assumptions

Continuous experimentation informed by direct external feedback yields faster learning, greater certainty, and better solutions.