Team Collaboration Patterns

Scenario: Configure a scaled Git Flow for 3 development teams

1. Set up repository structure for multi-team development:

   mkdir multi-team-collaboration
   cd multi-team-collaboration
   git init
   git remote add origin [your-repo-url]
   
   # Create initial structure
   echo "# Multi-Team Project
   This project demonstrates scaled Git Flow for multiple development teams.
   
   ## Teams:
   - **Frontend Team**: UI/UX components and user interfaces
   - **Backend Team**: API services and business logic  
   - **DevOps Team**: Infrastructure and deployment automation
   
   ## Branching Strategy:
   - main: Production releases
   - develop: Integration branch
   - feature/[team]-[feature]: Team feature branches
   - release/[version]: Release preparation
   - hotfix/[issue]: Production fixes
   " > README.md
   
   git add README.md
   git commit -m "Initial commit: project structure"

2. Create team-specific branch naming conventions:

   # Set up branch naming configuration
   git config branch.autoSetupMerge always
   git config branch.autoSetupRebase always
   
   # Create develop branch
   git checkout -b develop
   git push -u origin develop
   
   # Create team feature branches
   git checkout -b feature/frontend-dashboard develop
   echo "Dashboard component placeholder" > frontend-dashboard.js
   git add frontend-dashboard.js
   git commit -m "feat(frontend): add dashboard component scaffold"
   
   git checkout -b feature/backend-auth develop
   echo "Authentication service placeholder" > backend-auth.py
   git add backend-auth.py
   git commit -m "feat(backend): add authentication service scaffold"
   
   git checkout -b feature/devops-ci develop
   echo "CI/CD pipeline configuration" > .github/workflows/ci.yml
   git add .github/workflows/ci.yml
   git commit -m "feat(devops): add CI/CD pipeline configuration"

3. Implement team integration workflow:

   # Simulate team collaboration workflow
   # Frontend team completes their feature
   git checkout feature/frontend-dashboard
   echo "export const Dashboard = () => {
     return 
   Dashboard Component
   ;
   };" > frontend-dashboard.js
   git add frontend-dashboard.js
   git commit -m "feat(frontend): implement basic dashboard component"
   
   # Backend team completes their feature
   git checkout feature/backend-auth
   echo "def authenticate(username, password):
       # Authentication logic here
       return {'token': 'jwt_token', 'user': username}" > backend-auth.py
   git add backend-auth.py
   git commit -m "feat(backend): implement authentication logic"
   
   # Integrate features into develop
   git checkout develop
   git merge --no-ff feature/frontend-dashboard -m "integrate: frontend dashboard feature"
   git merge --no-ff feature/backend-auth -m "integrate: backend authentication feature"
   
   # Create release branch
   git checkout -b release/1.0.0 develop
   echo "version = '1.0.0'" > version.py
   git add version.py
   git commit -m "release: prepare version 1.0.0"

Scenario: Implement structured communication protocols for team coordination

1. Create commit message template and validation:

   # Set up commit message template
   cat > .gitmessage << 'EOF'
   [team] type(scope): brief description
   
   # Longer description if needed
   #
   # Breaking changes:
   # BREAKING CHANGE: describe the breaking change
   #
   # Affected teams: list teams that need to take action
   # Required actions: describe what other teams need to do
   #
   # Teams: frontend, backend, devops, mobile, data
   # Types: feat, fix, docs, style, refactor, test, chore
   EOF
   
   git config commit.template .gitmessage

2. Create team communication automation:

   # Create team notification script
   cat > notify-teams.sh << 'EOF'
   #!/bin/bash
   # Team notification script for major changes
   
   COMMIT_MSG=$(git log -1 --pretty=%B)
   BRANCH=$(git branch --show-current)
   
   # Extract team from branch name or commit message
   if [[ $BRANCH == feature/* ]]; then
       TEAM=$(echo $BRANCH | cut -d'/' -f2 | cut -d'-' -f1)
   elif [[ $COMMIT_MSG =~ ^\[([a-z]+)\] ]]; then
       TEAM="${BASH_REMATCH[1]}"
   else
       TEAM="general"
   fi
   
   # Check for breaking changes
   if echo "$COMMIT_MSG" | grep -q "BREAKING CHANGE:"; then
       echo "🚨 BREAKING CHANGE detected from team: $TEAM"
       echo "Affected teams should review: $COMMIT_MSG"
       
       # Extract affected teams
       AFFECTED=$(echo "$COMMIT_MSG" | grep "Affected teams:" | cut -d':' -f2)
       echo "Teams to notify: $AFFECTED"
   fi
   
   # Check for API changes
   if echo "$COMMIT_MSG" | grep -q -i "api\|endpoint\|interface"; then
       echo "📡 API changes detected - cross-team review recommended"
   fi
   EOF
   
   chmod +x notify-teams.sh

3. Test communication protocols:

   # Test the communication system
   git checkout feature/backend-api-changes
   echo "Breaking API changes example" > api-changes.md
   git add api-changes.md
   
   # Use the commit template to create a structured message
   git commit
   # Fill in the template:
   # [backend] feat(auth)!: migrate to JWT-based authentication
   #
   # BREAKING CHANGE: Session-based auth is deprecated
   # All authentication now uses JWT tokens
   #
   # Affected teams: frontend, mobile
   # Required actions: Update auth implementation by Dec 1st
   
   # Test notification
   ./notify-teams.sh

Scenario: Implement feature integration pipeline with dependency management

1. Set up integration testing workflow:

   # Create integration testing configuration
   mkdir -p .github/workflows
   cat > .github/workflows/integration-pipeline.yml << 'EOF'
   name: Multi-Team Integration Pipeline
   
   on:
     push:
       branches: [develop]
     pull_request:
       branches: [develop]
   
   jobs:
     detect-changes:
       runs-on: ubuntu-latest
       outputs:
         frontend: ${{ steps.changes.outputs.frontend }}
         backend: ${{ steps.changes.outputs.backend }}
         shared: ${{ steps.changes.outputs.shared }}
       steps:
         - uses: actions/checkout@v3
         - uses: dorny/paths-filter@v2
           id: changes
           with:
             filters: |
               frontend:
                 - 'frontend/**'
                 - 'shared/ui/**'
               backend:
                 - 'backend/**'
                 - 'shared/models/**'
               shared:
                 - 'shared/**'
                 
     frontend-tests:
       needs: detect-changes
       if: needs.detect-changes.outputs.frontend == 'true'
       runs-on: ubuntu-latest
       steps:
         - uses: actions/checkout@v3
         - name: Run frontend tests
           run: echo "Running frontend integration tests"
           
     backend-tests:
       needs: detect-changes
       if: needs.detect-changes.outputs.backend == 'true'
       runs-on: ubuntu-latest
       steps:
         - uses: actions/checkout@v3
         - name: Run backend tests
           run: echo "Running backend integration tests"
           
     integration-tests:
       needs: [frontend-tests, backend-tests]
       if: always()
       runs-on: ubuntu-latest
       steps:
         - uses: actions/checkout@v3
         - name: Cross-team integration tests
           run: echo "Running cross-team integration tests"
   EOF

2. Implement dependency tracking system:

   # Create team dependency matrix
   cat > TEAM_DEPENDENCIES.md << 'EOF'
   # Team Dependencies Matrix
   
   ## Current Sprint Dependencies
   
   ### Backend Team
   - **Provides:** User API v2.1, Authentication service
   - **Depends on:** Database migrations (DevOps), Design tokens (Frontend)
   - **Blockers:** None
   - **Ready for integration:** 2024-12-15
   
   ### Frontend Team  
   - **Provides:** User dashboard, Component library v1.3
   - **Depends on:** User API v2.1 (Backend), Analytics events (Data)
   - **Blockers:** Waiting for API specs
   - **Ready for integration:** 2024-12-20
   
   ### Mobile Team
   - **Provides:** iOS/Android apps v3.2
   - **Depends on:** User API v2.1 (Backend), Push notifications (DevOps)
   - **Blockers:** API testing environment
   - **Ready for integration:** 2024-12-22
   
   ## Integration Schedule
   - **Integration Branch Freeze:** 2024-12-10
   - **Cross-team Testing:** 2024-12-11-13
   - **Release Branch Creation:** 2024-12-15
   - **Production Deployment:** 2024-12-20
   EOF

3. Create feature flag management:

   # Set up feature flag configuration
   cat > feature-flags.json << 'EOF'
   {
     "flags": {
       "new-dashboard": {
         "enabled": false,
         "description": "New user dashboard redesign",
         "teams": ["frontend", "backend"],
         "dependencies": ["user-api-v2"],
         "rollout_date": "2024-12-20"
       },
       "mobile-auth-v2": {
         "enabled": true,
         "description": "Enhanced mobile authentication",
         "teams": ["mobile", "backend"],
         "dependencies": ["auth-service-v2"],
         "rollout_date": "2024-12-15"
       },
       "analytics-integration": {
         "enabled": false,
         "description": "Advanced analytics tracking",
         "teams": ["frontend", "mobile", "data"],
         "dependencies": ["analytics-service"],
         "rollout_date": "2025-01-10"
       }
     },
     "environments": {
       "development": {
         "new-dashboard": true,
         "mobile-auth-v2": true,
         "analytics-integration": true
       },
       "staging": {
         "new-dashboard": false,
         "mobile-auth-v2": true,
         "analytics-integration": false
       },
       "production": {
         "new-dashboard": false,
         "mobile-auth-v2": false,
         "analytics-integration": false
       }
     }
   }
   EOF
   
   # Create feature flag validation script
   cat > validate-flags.sh << 'EOF'
   #!/bin/bash
   # Validate feature flag dependencies before integration
   
   echo "🏁 Validating feature flag dependencies..."
   
   # Check if teams are ready for flag activation
   if jq -r '.flags[] | select(.enabled == true) | .teams[]' feature-flags.json | sort -u; then
       echo "✅ Active flags involve these teams - ensure coordination"
   fi
   
   # Check dependency readiness  
   echo "🔗 Checking dependencies for active flags..."
   jq -r '.flags[] | select(.enabled == true) | "Flag: \(.description), Dependencies: \(.dependencies | join(", "))"' feature-flags.json
   
   EOF
   chmod +x validate-flags.sh
   ./validate-flags.sh

Scenario: Set up asynchronous workflows for a global development team

1. Create daily handoff documentation system:

   # Set up automated handoff reports
   mkdir -p .github/workflows
   cat > .github/workflows/daily-handoff.yml << 'EOF'
   name: Daily Team Handoff
   on:
     schedule:
       # Run at end of each major timezone workday
       - cron: '0 17 * * 1-5'  # 5 PM UTC (US East end of day)
       - cron: '0 9 * * 1-5'   # 9 AM UTC (Europe end of day)
       - cron: '0 1 * * 1-5'   # 1 AM UTC (Asia end of day)
   
   jobs:
     generate-handoff:
       runs-on: ubuntu-latest
       steps:
         - uses: actions/checkout@v3
         - name: Generate handoff report
           run: |
             cat > handoff-$(date +%Y-%m-%d-%H).md << 'HANDOFF'
             # Daily Handoff Report - $(date)
             
             ## Completed Today
             $(git log --since="24 hours ago" --pretty=format:"- %s (%an)" --no-merges)
             
             ## In Progress  
             $(gh pr list --json title,author --template '{{range .}}{{printf "- %s (%s)\n" .title .author.login}}{{end}}')
             
             ## Blockers/Issues
             $(gh issue list --label "blocker" --json title,number --template '{{range .}}{{printf "- #%d: %s\n" .number .title}}{{end}}')
             
             ## Next Team Notes
             - Check integration tests after latest merges
             - Review any new PRs for cross-team impacts
             - Update team on any blocked items
             HANDOFF
             
             git add handoff-$(date +%Y-%m-%d-%H).md
             git commit -m "chore: daily handoff report $(date)" || echo "No changes"
   EOF

2. Implement async communication templates:

   # Create async communication templates
   mkdir -p .github/ISSUE_TEMPLATE
   cat > .github/ISSUE_TEMPLATE/cross-team-request.yml << 'EOF'
   name: Cross-Team Request
   description: Request support or coordination from another team
   title: "[TEAM-REQUEST] "
   labels: ["cross-team", "coordination"]
   body:
     - type: dropdown
       id: requesting-team
       attributes:
         label: Requesting Team
         options:
           - Frontend
           - Backend
           - Mobile
           - DevOps
           - Data
           - QA
       validations:
         required: true
     
     - type: dropdown
       id: target-team
       attributes:
         label: Target Team
         options:
           - Frontend
           - Backend
           - Mobile
           - DevOps
           - Data
           - QA
       validations:
         required: true
         
     - type: dropdown
       id: priority
       attributes:
         label: Priority
         options:
           - 🔥 Blocker (stops current work)
           - 🚨 High (needed this sprint)
           - 📋 Medium (needed next sprint)  
           - 💡 Low (nice to have)
       validations:
         required: true
         
     - type: textarea
       id: request
       attributes:
         label: Request Description
         description: What do you need from the target team?
         placeholder: Detailed description of the request...
       validations:
         required: true
         
     - type: textarea
       id: context
       attributes:
         label: Context
         description: Why is this needed? What's the business impact?
         placeholder: Background information and business justification...
       validations:
         required: true
         
     - type: input
       id: deadline
       attributes:
         label: Deadline
         description: When do you need this completed?
         placeholder: YYYY-MM-DD
       validations:
         required: true
   EOF

3. Set up async code review guidelines:

   # Create async review best practices
   cat > ASYNC_REVIEW_GUIDE.md << 'EOF'
   # Async Code Review Guidelines
   
   ## For Reviewers (Global Best Practices)
   
   ### Timing Expectations
   - **Initial Response:** Within 24 hours during weekdays
   - **Detailed Review:** Within 48 hours for standard PRs
   - **Complex Reviews:** May take 3-5 days with async discussions
   
   ### Review Depth by Change Size
   - **Small (< 50 lines):** Quick review, focus on logic and style
   - **Medium (50-200 lines):** Detailed review with context questions
   - **Large (> 200 lines):** May require video walkthrough or async meeting
   
   ### Communication Guidelines
   - **Be Explicit:** Assume no shared context
   - **Provide Examples:** Show don't just tell
   - **Record Explanations:** Use video for complex feedback
   - **Ask Questions:** Don't assume - ask for clarification
   
   ### Sample Review Comments
   ```
   ✅ Good: "This approach works well. Consider extracting lines 23-35 into a helper function for reusability. Here's an example: [code snippet]"
   
   ❌ Avoid: "Extract this" (too vague for async review)
   ```
   
   ## For Authors
   
   ### PR Preparation
   - **Detailed Description:** Explain the what, why, and how
   - **Self-Review:** Review your own code first and add comments explaining complex logic
   - **Test Coverage:** Include test results and coverage reports
   - **Visual Changes:** Include screenshots or videos for UI changes
   
   ### Responding to Feedback
   - **Acknowledge Quickly:** Respond within 24 hours even if not implementing yet
   - **Ask for Clarification:** Don't guess what the reviewer means
   - **Update Progress:** Comment on implementation progress for large changes
   
   ## Time Zone Considerations
   
   ### Asia-Pacific (UTC+8 to UTC+12)
   - **Best Review Times:** 1:00-9:00 UTC
   - **Handoff Notes:** End-of-day summary for Europe team
   
   ### Europe (UTC+0 to UTC+2)  
   - **Best Review Times:** 8:00-17:00 UTC
   - **Handoff Notes:** Status updates for Americas team
   
   ### Americas (UTC-5 to UTC-8)
   - **Best Review Times:** 13:00-22:00 UTC  
   - **Handoff Notes:** Summary for Asia-Pacific team
   EOF
   
   git add .
   git commit -m "docs: add async collaboration guidelines and templates"