Discover Phase: Practical Exercises

Learn GISE discovery methodology through hands-on exercises with real GitHub integration. These exercises will teach you to gather requirements, create user stories, and document processes using industry-standard tools and practices.

Exercise Overview

Prerequisites

Before starting these exercises, ensure you have:

• GitHub account with repository creation access
• Basic understanding of Git and version control
• Text editor or IDE (VS Code recommended)
• Access to GenAI tools (ChatGPT, Claude, or similar)

Exercise 1: Requirements Gathering Workshop

Duration: 2-3 hours
Objective: Learn structured requirements gathering using GISE methodology

Scenario: Local Restaurant Management System

You're working with "Bella's Bistro", a local restaurant wanting to improve their operations with a custom management system.

Step 1: Stakeholder Interview Simulation

Setup: You'll role-play interviewing different stakeholders. Use GenAI to simulate stakeholder responses.

GenAI Prompt Template:

You are [STAKEHOLDER_ROLE] at Bella's Bistro, a family-owned Italian restaurant. 
I'm a software engineer gathering requirements for a management system.
Please respond to my questions as this stakeholder would, including:
- Their specific pain points and challenges
- Their daily workflow and responsibilities  
- Their concerns about technology adoption
- Their success criteria for the project

Stakeholder context: [DETAILED_BACKGROUND]

Stakeholder Roles to Interview:

• Maria (Owner/Manager): Focus on business operations, costs, profitability
• Tony (Head Chef): Focus on kitchen operations, inventory, food preparation
• Lisa (Server): Focus on customer service, order management, POS system
• David (Customer): Focus on dining experience, reservations, feedback

Step 2: Requirements Documentation Template

Create a requirements.md file with this structure:

# Bella's Bistro Management System - Requirements

## Project Overview
- **Project Name**: Bella's Bistro Management System
- **Stakeholders**: [List key stakeholders]
- **Business Objectives**: [Primary goals]
- **Success Metrics**: [How success will be measured]

## Functional Requirements

### FR-001: Order Management
- **Description**: System must handle customer orders from placement to completion
- **Priority**: High
- **Source**: Lisa (Server), Tony (Head Chef)
- **Acceptance Criteria**:
  - [ ] Servers can enter orders via tablet interface
  - [ ] Orders automatically route to kitchen display
  - [ ] Order status updates visible to servers
  - [ ] Orders can be modified before kitchen preparation

### FR-002: Inventory Tracking
[Continue with more requirements...]

## Non-Functional Requirements

### NFR-001: Performance
- **Requirement**: Order processing must complete within 2 seconds
- **Rationale**: Maintain smooth service during busy periods
- **Measurement**: Response time monitoring

### NFR-002: Availability
[Continue with more requirements...]

## Business Rules
1. Orders cannot be modified after kitchen preparation begins
2. Inventory alerts trigger when stock falls below defined thresholds
3. Customer reservations require 2-hour minimum notice

## Constraints and Assumptions
- **Technical**: Must integrate with existing POS system
- **Budget**: Development budget not to exceed $50,000
- **Timeline**: System must be operational before summer season

Step 3: Requirements Validation Checklist

Use this checklist to validate your requirements:

• Complete: All identified needs addressed
• Consistent: No conflicting requirements
• Clear: Unambiguous and specific
• Testable: Can be verified through testing
• Traceable: Linked to business objectives
• Prioritized: Importance levels assigned

Exercise 2: User Story Creation Workshop

Duration: 3-4 hours
Objective: Transform requirements into actionable user stories with acceptance criteria

User Story Template

## Epic: [High-level feature group]

### User Story: [US-###] [Title]
**As a** [user role]  
**I want** [functionality]  
**So that** [benefit/value]

**Priority**: High/Medium/Low  
**Story Points**: [Complexity estimate]  
**Dependencies**: [Other stories this depends on]

### Acceptance Criteria
- [ ] **Given** [initial context]
  **When** [action performed]
  **Then** [expected outcome]
- [ ] [Additional criteria...]

### Definition of Done
- [ ] Functionality implemented and tested
- [ ] Code reviewed and approved
- [ ] Documentation updated
- [ ] Acceptance criteria verified by stakeholder

Step 1: Create User Story Epic Structure

Organize stories into logical epics:

# User Stories for Bella's Bistro Management System

## Epic 1: Order Management
Stories covering the complete order lifecycle from placement to completion.

## Epic 2: Inventory Management  
Stories covering ingredient tracking, supplier management, and stock alerts.

## Epic 3: Customer Management
Stories covering reservations, customer preferences, and feedback.

## Epic 4: Reporting & Analytics
Stories covering business intelligence and performance metrics.

Step 2: Write Detailed User Stories

Example: Complete User Story

### User Story: [US-001] Place Customer Order
**As a** server  
**I want** to enter customer orders on a tablet interface  
**So that** I can quickly and accurately capture orders during busy service periods

**Priority**: High  
**Story Points**: 5  
**Dependencies**: Menu system setup

### Acceptance Criteria
- [ ] **Given** I am logged in as a server
  **When** I select items from the digital menu
  **Then** the order appears in the current order summary
  
- [ ] **Given** I have items in the current order
  **When** I specify dietary restrictions or modifications
  **Then** the modifications are clearly displayed with the item
  
- [ ] **Given** I have completed entering an order
  **When** I submit the order
  **Then** the order is sent to the kitchen display system
  
- [ ] **Given** an order has been submitted
  **When** the kitchen updates the order status
  **Then** I can see the updated status on my tablet

### Definition of Done
- [ ] UI wireframes approved by server stakeholder
- [ ] Backend API implemented and tested
- [ ] Integration with kitchen display system tested
- [ ] Performance meets 2-second response time requirement
- [ ] User acceptance testing completed by actual server

Step 3: User Story Prioritization Matrix

Create a prioritization matrix using the MoSCoW method:

Story ID	Story Title	Must Have	Should Have	Could Have	Won't Have
US-001	Place Customer Order	✅
US-002	View Order Status	✅
US-003	Modify Order		✅
US-004	Generate Receipt	✅
US-005	Track Inventory		✅
US-006	Customer Feedback			✅

Exercise 3: Process Mapping with Mermaid

Duration: 2-3 hours
Objective: Create visual process flows using Mermaid diagrams

Current State Process Mapping

First, document how processes currently work:

Future State Process Design

Then design the improved process:

Step 1: Process Analysis Template

For each process, document:

## Process: [Process Name]

### Current State Analysis
- **Pain Points**: [What's not working well]
- **Bottlenecks**: [Where delays occur]
- **Manual Steps**: [What requires human intervention]
- **Error Points**: [Where mistakes happen]

### Future State Design
- **Automation Opportunities**: [What can be automated]
- **Integration Points**: [System connections needed]
- **Efficiency Gains**: [Expected improvements]
- **Success Metrics**: [How to measure improvement]

### Implementation Requirements
- **Technical**: [System capabilities needed]
- **Training**: [Staff training requirements]
- **Change Management**: [How to manage transition]

Step 2: Swimlane Diagrams for Complex Processes

For processes involving multiple roles:

Exercise 4: GitHub Integration & Workflow

Duration: 2-3 hours
Objective: Set up proper GitHub workflow for GISE discovery phase

Step 1: Repository Setup

Create a new GitHub repository for your project:

# Create and initialize repository
git init bella-bistro-management
cd bella-bistro-management

# Create GISE directory structure
mkdir -p docs/discover
mkdir -p docs/design  
mkdir -p docs/develop
mkdir -p docs/deploy

# Create initial files
touch README.md
touch docs/discover/requirements.md
touch docs/discover/user-stories.md
touch docs/discover/process-flows.md

Step 2: GitHub Issues for Requirements Tracking

Create GitHub issues for each requirement:

Issue Template for Requirements:

## Requirement: [REQ-001] Order Management System

### Description
System must handle customer orders from placement to completion.

### Stakeholder
- **Primary**: Lisa (Server)
- **Secondary**: Tony (Head Chef)

### Acceptance Criteria
- [ ] Servers can enter orders via tablet interface
- [ ] Orders automatically route to kitchen display
- [ ] Order status updates visible to servers
- [ ] Orders can be modified before kitchen preparation

### Priority
High

### Dependencies
- Menu system setup
- Kitchen display hardware

### Definition of Ready
- [ ] Stakeholder interview completed
- [ ] User stories created
- [ ] Process flows documented

Step 3: Feature Branch Workflow

Implement proper Git workflow for discovery:

# Create feature branch for requirements gathering
git checkout -b feature/requirements-gathering

# Add and commit discovery documents
git add docs/discover/
git commit -m "Add initial requirements documentation"

# Push feature branch
git push -u origin feature/requirements-gathering

Step 4: Pull Request Template

Create .github/pull_request_template.md:

## GISE Discovery Phase Pull Request

### Phase
- [ ] Discover
- [ ] Design
- [ ] Develop
- [ ] Deploy

### Changes Made
- [ ] Requirements documentation updated
- [ ] User stories created/modified
- [ ] Process flows added/updated
- [ ] Stakeholder feedback incorporated

### Review Checklist
- [ ] All requirements are testable and specific
- [ ] User stories follow proper format
- [ ] Process diagrams are clear and complete
- [ ] Documentation follows GISE standards
- [ ] Stakeholder approval obtained

### Related Issues
Closes #[issue-number]
Addresses #[issue-number]

### Next Steps
[What needs to happen after this PR is merged]

Step 5: GitHub Project Board Setup

Create a project board to track discovery progress:

Columns:

• Backlog: Items identified but not yet started
• In Progress: Currently being worked on
• Review: Awaiting stakeholder/team review
• Done: Completed and approved

Cards to Create:

• Stakeholder interviews
• Requirements documentation
• User story creation
• Process flow mapping
• Stakeholder review sessions

Exercise 5: Stakeholder Review & Validation

Duration: 2 hours
Objective: Present discovery findings and incorporate feedback

Step 1: Review Preparation

Create a stakeholder review presentation:

# Bella's Bistro Management System - Discovery Review

## Meeting Agenda
1. Project objectives review (5 min)
2. Requirements walkthrough (15 min)
3. User stories presentation (10 min)
4. Process flow demonstration (10 min)
5. Feedback and questions (15 min)
6. Next steps and timeline (5 min)

## Key Findings Summary

### Business Objectives
- Reduce order processing time by 50%
- Improve inventory management accuracy to 95%
- Increase customer satisfaction scores
- Reduce operational costs by 20%

### Critical Requirements
1. **Order Management**: Real-time order processing with kitchen integration
2. **Inventory Tracking**: Automated inventory updates and alerts
3. **Customer Experience**: Streamlined ordering and payment process
4. **Reporting**: Business intelligence and performance metrics

### Success Metrics
- Order processing time: < 2 seconds
- Inventory accuracy: > 95%
- Customer satisfaction: > 4.5/5.0
- Staff training time: < 4 hours per person

Step 2: Feedback Incorporation Process

Use this template to capture and address feedback:

## Stakeholder Feedback Log

### Feedback Session: [Date]
**Attendees**: [List participants]

| Feedback | Source | Priority | Action Required | Status |
|----------|--------|----------|----------------|---------|
| Need offline mode for orders | Lisa (Server) | High | Add requirement for offline capability | ✅ Added |
| Integration with current POS | Maria (Owner) | High | Research POS API compatibility | 🔄 In Progress |
| Mobile app for customers | David (Customer) | Medium | Consider for future phase | 📋 Backlog |

### Requirements Changes
- **Added**: REQ-012 Offline order capability
- **Modified**: REQ-001 to include POS integration requirement
- **Removed**: REQ-008 (out of scope per stakeholder feedback)

### User Story Updates
- **US-001**: Updated to include offline functionality
- **US-015**: Added new story for POS integration

Step 3: Discovery Sign-off Checklist

Before moving to Design phase, ensure:

• Requirements Complete: All identified needs documented
• User Stories Validated: Stakeholders approve story definitions
• Process Flows Finalized: Current and future state agreed upon
• Priorities Set: Must-have vs. nice-to-have clearly defined
• Budget Confirmed: Cost estimates align with available budget
• Timeline Agreed: Project timeline acceptable to all stakeholders
• Success Metrics Defined: Clear criteria for project success
• Risks Identified: Potential challenges and mitigation strategies documented

Practical Exercise Solutions

Solution Templates

GitHub Repository Structure:

bella-bistro-management/
├── README.md
├── .github/
│   ├── ISSUE_TEMPLATE/
│   │   ├── requirement.md
│   │   └── user-story.md
│   └── pull_request_template.md
├── docs/
│   └── discover/
│       ├── requirements.md
│       ├── user-stories.md
│       ├── process-flows.md
│       ├── stakeholder-interviews.md
│       └── review-notes.md
└── assets/
    └── diagrams/
        ├── current-state-process.png
        └── future-state-process.png

Quality Assessment Rubric

Rate your exercise completion:

Criteria	Excellent (4)	Good (3)	Satisfactory (2)	Needs Improvement (1)
Requirements Quality	Complete, testable, prioritized	Mostly complete, some gaps	Basic requirements captured	Incomplete or vague
User Stories	Professional format, clear acceptance criteria	Good format, adequate criteria	Basic stories present	Poor format or missing criteria
Process Documentation	Clear diagrams, improvement identified	Good diagrams, some improvements	Basic process documented	Unclear or missing diagrams
GitHub Integration	Proper workflow, good documentation	Mostly proper usage	Basic GitHub usage	Poor or inconsistent usage
Stakeholder Engagement	Comprehensive feedback incorporated	Good feedback incorporation	Some feedback addressed	Limited stakeholder input

Next Steps

After completing these exercises:

1. Self-Assessment: Use the quality rubric to evaluate your work
2. Peer Review: Have a colleague review your discovery documentation
3. Community Feedback: Share your work in GISE community forums
4. Iterate: Incorporate feedback and improve your documentation
5. Proceed to Design: Move to Phase 2 with validated requirements

---

Congratulations! You've completed the practical exercises for the Discover phase. Your requirements, user stories, and process documentation form the foundation for successful system design and development.

Next Phase: Design Phase Overview →