Project Management & Sprint Zero

Session Timeline

Learning Objectives

• Understand agile principles and why they matter for team projects
• Learn Scrum framework: sprints, roles, ceremonies
• Write user stories with acceptance criteria
• Create and prioritize product backlogs
• Use Kanban boards for visual workflow management
• Set up team repositories with proper structure
• Configure development environments and tooling
• Plan and execute Sprint Zero effectively

What is Agile Software Development?

Agile Manifesto Values:

• Individuals and interactions over processes and tools
• Working software over comprehensive documentation
• Customer collaboration over contract negotiation
• Responding to change over following a plan

Agile vs Waterfall

Scrum Framework

Key Elements:

• Sprint: Fixed time period (1-2 weeks) to complete selected work
• Product Backlog: Prioritized list of all desired features/tasks
• Sprint Backlog: Features selected for current sprint
• Daily Standup: Quick daily sync (15 min)
• Sprint Review: Demo completed work at sprint end
• Sprint Retrospective: Reflect on what went well/improve

Scrum Roles (Adapted for Student Teams)

• Product Owner: Defines vision, prioritizes backlog, accepts work
  Your team: Can rotate weekly or assign to most organized member
• Scrum Master: Facilitates process, removes blockers, coaches team
  Your team: Can rotate or share responsibility
• Development Team: Self-organizing, cross-functional, builds product
  Your team: Everyone! All team members contribute to development

The Sprint Cycle

Writing User Stories

Standard Format:

Examples:

Acceptance Criteria

Epic vs Story vs Task

• Epic: Large body of work, spans multiple sprints
  Example: "User Account Management" (includes registration, login, profile, password reset)
• User Story: Single feature from user perspective, completable in 1 sprint
  Example: "As a user, I want to register an account with email/password"
• Task: Technical work item to implement story, measured in hours/days
  Example: "Create user registration API endpoint," "Build signup form UI"

Kanban Boards for Visual Workflow

Basic Kanban Board Columns:

Tools: Trello, Jira, GitHub Projects, Asana, Notion

Story Point Estimation

Estimation Guidelines:

• 1-2 points: Simple story, few hours of work, low complexity
• 3-5 points: Moderate story, takes 1-2 days, some unknowns
• 8-13 points: Complex story, takes several days, many dependencies
• 21+ points: Too large - break into smaller stories

Daily Standup Meetings

Each team member answers three questions:

1. What did I do yesterday? (accomplishments)
2. What will I do today? (plan)
3. Any blockers? (impediments preventing progress)

Part B: Sprint Zero Setup

Sprint Zero Goals:

• Set up version control repository
• Define project folder structure
• Install and configure tech stack
• Establish team coding standards
• Set up development environments for all team members
• Complete initial project skeleton
• Plan Sprint 1

Why Sprint Zero Matters

Setting Up Your Team Repository

Step 1: Create Repository

# On GitHub/GitLab:
# 1. Create new repository (one team member)
# 2. Name it clearly (e.g., "study-space-finder")
# 3. Add description
# 4.Initialize with README.md
# 5. Add .gitignore (select language template)
# 6. Choose license (MIT is common for student projects)

Step 2: Grant Team Access

• Settings → Collaborators → Add team members by username
• Give everyone "Maintainer" or "Write" access

Step 3: Everyone Clones

git clone https://github.com/your-team/your-project.git
cd your-project

Defining Project Folder Structure

project-root/
├── README.md                 # Project overview and setup instructions
├── .gitignore                # Files to exclude from version control
├── docs/                     # Documentation
│   ├── design-brief.md
│   ├── architecture.md
│   └── setup.md
├── frontend/                 # Frontend application
│   ├── src/
│   ├── public/
│   ├── package.json
│   └── README.md
├── backend/                  # Backend application
│   ├── src/
│   ├── tests/
│   ├── package.json (or requirements.txt)
│   └── README.md
├── database/                 # Database schemas/migrations
│   ├── migrations/
│   └── seeds/
└── .github/                  # GitHub Actions (CI/CD)
    └── workflows/

Adjust based on your tech stack (mobile, ML, etc.)

Installing Tech Stack for All Team Members

Create setup.md with detailed instructions:

1. Prerequisites:
   • Node.js v16+ / Python 3.9+ / Java 11+ (specify versions)
   • Database (PostgreSQL 14, MongoDB 5, etc.)
   • Git 2.30+
2. Installation Commands:

   # Example for Node.js + React + Express
   # Backend setup
   cd backend
   npm install
   
   # Frontend setup
   cd ../frontend
   npm install
   
   # Database setup
   createdb project_db

3. Environment Configuration: Create .env.example file with required variables
4. Verification: Commands to test setup works

Establishing Team Coding Standards

• Code Style:
  • Indentation (2 spaces vs 4 spaces vs tabs)
  • Naming conventions (camelCase vs snake_case)
  • File naming (PascalCase for components, kebab-case for files)
• Commit Messages:
  • Format: "type: description" (e.g., "feat: add user login")
  • Types: feat, fix, docs, style, refactor, test
• Branch Naming:
  • Format: "type/description" (e.g., "feature/user-authentication")
• Code Review:
  • All code requires 1+ reviewer approval
  • No direct commits to main branch

Git Branching Strategy

# Main branch (always deployable)
main (or master)

# Create feature branch
git checkout -b feature/user-registration

# Work on feature, commit regularly
git add .
git commit -m "feat: add registration form validation"

# Push to remote
git push origin feature/user-registration

# Create Pull Request on GitHub
# → Team reviews code
# → Merge to main after approval
# → Delete feature branch

README.md Template

# Project Name

## Description
Brief description of what your project does and who it's for.

## Team Members
- Tom Johnson (Frontend Lead) - @Tomjohnson
- Bob Smith (Backend Lead) - @bobsmith
- Charlie Davis (Database) - @charliedavis

## Tech Stack
- Frontend: React 18, TypeScript
- Backend: Node.js, Express
- Database: PostgreSQL 14
- Hosting: Heroku

## Setup Instructions
\`\`\`bash
# See docs/setup.md for detailed instructions
npm install
npm run dev
\`\`\`

## Project Structure
See [Architecture Documentation](docs/architecture.md)

## Contributing
See [Contributing Guidelines](CONTRIBUTING.md)

## License
MIT

.gitignore Configuration

# Example .gitignore for Node.js project

# Dependencies
node_modules/
package-lock.json (if using yarn)

# Environment variables
.env
.env.local
.env.production

# Build outputs
dist/
build/
*.log

# IDE
.vscode/
.idea/
*.swp

# OS
.DS_Store
Thumbs.db

# Database
*.db
*.sqlite

Managing Environment Variables

Create .env.example (committed to Git):

# .env.example - Template for environment variables
DATABASE_URL=postgresql://username:password@localhost:5432/dbname
API_KEY=your_api_key_here
SECRET_KEY=your_secret_here
PORT=3000

Each team member creates .env (NOT committed):

# .env - Actual values (git ignored)
DATABASE_URL=postgresql://Tom:mypass@localhost:5432/project_dev
API_KEY=sk_test_abc123xyz
SECRET_KEY=my_super_secret_key_12345
PORT=3000

Planning Sprint 1

1. Review Backlog: Look at your prioritized user stories
2. Select Stories: Choose 3-5 stories team can complete in 1-2 weeks
3. Break into Tasks: For each story, list technical tasks
4. Assign Work: Team members volunteer for tasks
5. Set Sprint Goal: One sentence describing sprint objective
   Example: "Complete user authentication and basic product listing"
6. Commit: Team agrees this is achievable

Creating Initial Project Skeleton

Goal: Everyone can run "Hello World" from repo

Before Next Lecture

1. Submit to Moodle:
   • Link to your team repository
   • Screenshot of Kanban board with backlog
   • Sprint 1 plan (selected stories + tasks)
2. Complete Sprint Zero:
   • Finalize repository setup
   • Ensure all team members can run project
   • Update documentation
3. Start Sprint 1:
   • Begin working on assigned tasks
   • Hold first team standup
   • Update Kanban board as you progress
4. Research Architectures: Read about patterns relevant to your project (MVC, REST API, etc.)