Teams & User Management

Action	Org Admin	Org Member	Team Owner	Team Admin	Team Member	Team Viewer
Create Teams	✅	❌	❌	❌	❌	❌
Add Team Members	✅	❌	✅	❌	❌	❌
Manage Services	✅	Team-based	✅	✅	✅	❌
Create Alerts	✅	Team-based	✅	✅	✅	❌
Acknowledge Alerts	✅	Team-based	✅	✅	✅	❌
View Team Resources	✅	Team-based	✅	✅	✅	✅
Delete Resources	✅	❌	✅	Limited	❌	❌

Action	Org Admin	Org Member	Team Owner	Team Admin	Team Member	Team Viewer
Create Teams	✅	❌	❌	❌	❌	❌
Add Team Members	✅	❌	✅	❌	❌	❌
Manage Services	✅	Team-based	✅	✅	✅	❌
Create Alerts	✅	Team-based	✅	✅	✅	❌
Acknowledge Alerts	✅	Team-based	✅	✅	✅	❌
View Team Resources	✅	Team-based	✅	✅	✅	✅
Delete Resources	✅	❌	✅	Limited	❌	❌

Overview

Teams in Warrn provide organizational structure for managing services, alerts, and access control. The system supports flexible team hierarchies, role-based permissions, and collaborative incident management workflows.

Team Organization

Flexible team structures with ownership-based service and alert management.

Access Control

Role-based permissions with granular control over resources and operations.

Team Structure

Team Hierarchy

Teams in Warrn can be organized in a flat or hierarchical structure based on your organization’s needs:

interface Team {
  id: string;
  name: string;
  description?: string;
  organization_id: string;
  
  // Hierarchy (optional)
  parent_team_id?: string;
  child_teams: Team[];
  
  // Ownership
  services: Service[];
  members: TeamMember[];
  
  // Configuration
  settings: TeamSettings;
  
  // Metadata
  created_at: string;
  updated_at: string;
}

Team Types

User Management

User Roles & Permissions

Permission Matrix

Team Collaboration

Incident Response Workflows

Alert Assignment

Alerts are automatically assigned to teams based on service ownership and escalation rules.

Team Notification

Team members receive notifications through configured channels (email, Slack, SMS).

Collaborative Triage

Multiple team members can collaborate on incident investigation and resolution.

Knowledge Sharing

Post-incident reviews and documentation shared within team context.

Communication Channels

In-App Comments

Real-time commenting system for alert and incident collaboration.

Slack Integration

Dedicated Slack channels for team notifications and discussions.

Email Notifications

Configurable email alerts for team activities and escalations.

Shared Resources

Teams can share resources and collaborate across organizational boundaries:

interface SharedResource {
  resource_id: string;
  resource_type: 'service' | 'alert' | 'status_page';
  owner_team_id: string;
  
  // Sharing configuration
  shared_with_teams: {
    team_id: string;
    permission_level: 'read' | 'write' | 'admin';
    shared_at: string;
    shared_by: string;
  }[];
  
  // Access control
  public_within_org: boolean;
  require_approval: boolean;
}

Team Settings & Configuration

Team Preferences

Notification Settings

Default notification channels
Escalation preferences
Quiet hours and weekends
Urgency-based routing

Operational Settings

Auto-assignment rules
Default service ownership
Alert acknowledgment policies
Integration preferences

Escalation Policies

Configure automatic escalation for unacknowledged alerts:

interface EscalationPolicy {
  id: string;
  team_id: string;
  name: string;
  
  // Escalation rules
  rules: {
    level: number;
    delay_minutes: number;
    targets: {
      type: 'user' | 'team' | 'external';
      target_id: string;
      notification_method: 'email' | 'sms' | 'slack' | 'webhook';
    }[];
  }[];
  
  // Conditions
  applies_to: {
    severity_levels: string[];
    service_ids?: string[];
    alert_types?: string[];
  };
  
  // Schedule
  active_schedule?: {
    timezone: string;
    business_hours_only: boolean;
    custom_schedule?: ScheduleRule[];
  };
}

User Invitation & Onboarding

Invitation Process

Send Invitation

Organization admins or team owners can invite users via email address.

Role Assignment

Specify initial role and team memberships during invitation process.

Account Creation

Invited users receive email with account setup instructions and secure link.

Team Integration

New users automatically gain access to assigned teams and resources.

Onboarding Workflow

interface OnboardingWorkflow {
  user_id: string;
  organization_id: string;
  
  // Progress tracking
  steps_completed: {
    profile_setup: boolean;
    team_introduction: boolean;
    service_overview: boolean;
    alert_training: boolean;
    first_response: boolean;
  };
  
  // Guidance
  assigned_mentor?: string;
  training_resources: Resource[];
  next_steps: string[];
  
  // Timeline
  started_at: string;
  target_completion: string;
  completed_at?: string;
}

Team Analytics & Insights

Team Performance Metrics

Reporting Dashboard

Team leaders can access comprehensive analytics through dedicated dashboards:

Team Health: Overall team performance and satisfaction metrics
Resource Utilization: Service ownership and alert handling efficiency
Growth Tracking: Team expansion, skill development, and retention
Incident Analysis: Post-incident learnings and improvement opportunities

Multi-tenant Architecture

Organization Isolation

All team operations respect strict multi-tenant boundaries to ensure complete data isolation between organizations.

// Example: Team queries automatically scope to current organization
const useTeams = () => {
  return useQuery(['teams'], async () => {
    // Organization context automatically applied
    const response = await api.get('/teams');
    return response.data; // Only returns current org's teams
  });
};

Cross-Organization Collaboration

While maintaining security boundaries, Warrn supports limited cross-organization collaboration:

Partner Integration: Controlled sharing with external partner organizations
Vendor Management: Limited vendor access to specific services or alerts
Audit Access: Read-only access for compliance and audit purposes
Support Escalation: Warrn support team access with explicit customer approval

Team Integration APIs

Team Management

# List teams
GET /api/teams

# Get team details
GET /api/teams/{id}

# Create team
POST /api/teams
{
  "name": "Platform Engineering",
  "description": "Core platform and infrastructure team",
  "parent_team_id": "parent-team-uuid"
}

# Update team
PATCH /api/teams/{id}
{
  "description": "Updated team description"
}

# Delete team
DELETE /api/teams/{id}

Member Management

# List team members
GET /api/teams/{id}/members

# Add team member
POST /api/teams/{id}/members
{
  "user_email": "user@example.com",
  "role": "member"
}

# Update member role
PATCH /api/teams/{id}/members/{user_id}
{
  "role": "admin"
}

# Remove team member
DELETE /api/teams/{id}/members/{user_id}

Invitation Management

# Send invitation
POST /api/invitations
{
  "email": "newuser@example.com",
  "team_ids": ["team-1", "team-2"],
  "role": "member",
  "message": "Welcome to our incident response team!"
}

# List pending invitations
GET /api/invitations?status=pending

# Resend invitation
POST /api/invitations/{id}/resend

# Cancel invitation
DELETE /api/invitations/{id}

Best Practices

Team Organization

Clear Ownership

Establish clear service ownership with designated primary and secondary teams.

Balanced Size

Maintain teams of 5-12 members for optimal communication and coordination.

Skill Diversity

Include diverse skill sets within teams for comprehensive incident response.

Regular Review

Periodically review team structure and adjust based on organizational changes.

Access Control Strategy

Collaboration Enhancement

Shared Documentation: Maintain team runbooks and incident response procedures
Cross-training: Regular knowledge sharing sessions between team members
Rotation Programs: Implement on-call rotation and skill development programs
Feedback Loops: Establish feedback mechanisms for continuous team improvement

Integration Examples

Slack Bot Integration

// Example: Slack bot for team notifications
const slackBot = {
  async notifyTeam(teamId, message, urgency = 'normal') {
    const team = await getTeam(teamId);
    const channel = team.settings.slack_channel;
    
    const slackMessage = {
      channel,
      text: message,
      attachments: urgency === 'high' ? [{
        color: 'danger',
        text: '🚨 High Priority Alert'
      }] : undefined
    };
    
    return await slack.chat.postMessage(slackMessage);
  },
  
  async escalateToTeam(alertId, teamId) {
    const alert = await getAlert(alertId);
    const team = await getTeam(teamId);
    
    return await this.notifyTeam(teamId, 
      `Alert escalated to ${team.name}: ${alert.name}`, 
      'high'
    );
  }
};

LDAP/Active Directory Integration

# Configure LDAP sync for team management
POST /api/integrations/ldap
{
  "server": "ldap://ldap.company.com",
  "base_dn": "ou=users,dc=company,dc=com",
  "team_mapping": {
    "group_attribute": "memberOf",
    "team_mappings": {
      "CN=Platform Team,OU=Groups,DC=company,DC=com": "platform-team-uuid",
      "CN=Security Team,OU=Groups,DC=company,DC=com": "security-team-uuid"
    }
  },
  "sync_schedule": "0 2 * * *"  // Daily at 2 AM
}

See the Teams API documentation for complete endpoint details and team management examples.

Core Components

API Integration

​Overview

Team Organization

Access Control

​Team Structure

​Team Hierarchy

​Team Types

​User Management

​User Roles & Permissions

​Permission Matrix

​Team Collaboration

​Incident Response Workflows

​Communication Channels

In-App Comments

Slack Integration

Email Notifications

​Shared Resources

​Team Settings & Configuration

​Team Preferences

​Escalation Policies

​User Invitation & Onboarding

​Invitation Process

​Onboarding Workflow

​Team Analytics & Insights

​Team Performance Metrics

​Reporting Dashboard

​Multi-tenant Architecture

​Organization Isolation

​Cross-Organization Collaboration

​Team Integration APIs

​Team Management

​Member Management

​Invitation Management

​Best Practices

​Team Organization

​Access Control Strategy

​Collaboration Enhancement

​Integration Examples

​Slack Bot Integration

​LDAP/Active Directory Integration

Overview

Team Structure

Team Hierarchy

Team Types

User Management

User Roles & Permissions

Permission Matrix

Team Collaboration

Incident Response Workflows

Communication Channels

Shared Resources

Team Settings & Configuration

Team Preferences

Escalation Policies

User Invitation & Onboarding

Invitation Process

Onboarding Workflow

Team Analytics & Insights

Team Performance Metrics

Reporting Dashboard

Multi-tenant Architecture

Organization Isolation

Cross-Organization Collaboration

Team Integration APIs

Team Management

Member Management

Invitation Management

Best Practices

Team Organization

Access Control Strategy

Collaboration Enhancement

Integration Examples

Slack Bot Integration

LDAP/Active Directory Integration