Under Construction

This page is under construction. Please check back later for comprehensive guidance

Google Workspace Security Dashboards and Executive Reporting

This guide provides comprehensive frameworks, templates, and implementation strategies for creating effective security dashboards and executive-level reporting for Google Workspace environments.

Executive Security Dashboard Framework

Dashboard Design Principles

Creating effective security dashboards for executive consumption requires balancing detail with clarity:

1. Audience-Centered Design
2. Focus on business impact and risk
3. Limit technical jargon and details
4. Align metrics with organizational priorities

5. Present actionable insights

6. Visual Clarity

7. Use consistent visualization methods
8. Implement intuitive color schemes (green/yellow/red)
9. Provide clear trend indicators

10. Balance data density with readability

11. Context and Benchmarking

12. Include relevant industry benchmarks
13. Provide historical trend context
14. Show comparison to security targets

15. Include peer organization comparison when available

16. Actionable Insights

17. Highlight specific recommended actions
18. Connect metrics to business outcomes
19. Provide priority guidance
20. Include improvement trajectories

Executive Dashboard Templates

1. Google Workspace Security Posture Dashboard

This dashboard provides a high-level view of overall security posture and compliance status.

Key Components

1. Overall Security Score
2. Composite rating (0-100) based on security controls
3. Trend indicator (improving/declining)
4. Comparison to industry benchmark
5. Risk-level indicator (Low/Medium/High/Critical)

Implementation:
- Aggregate scores from security controls across services
- Weight components based on risk impact
- Calculate trend based on 90-day historical data
- Update weekly for consistency

1. Service Security Compliance
2. Matrix showing security compliance by service
3. Color-coded status indicators
4. Critical service highlighting
5. Non-compliant control count

Service Compliance Matrix Example:

Service	Security Score	Critical Controls	Trend	Status
Gmail	92/100	100% (15/15)	↑ 3%	✅
Drive	78/100	93% (14/15)	↓ 2%	⚠️
Identity	95/100	100% (12/12)	↑ 5%	✅
Meet	85/100	100% (10/10)	↔ 0%	✅
Groups	72/100	89% (8/9)	↑ 12%	⚠️
Calendar	88/100	100% (8/8)	↑ 2%	✅

1. Critical Risk Summary
2. Count of critical security issues
3. Remediation status metrics
4. Time-to-remediate trends
5. Top risk categories

# Python function to generate critical risk summary data
def generate_critical_risk_summary(admin_sdk_service, reports_service):
    """Generate data for critical risk summary component"""
    # Time ranges for comparison
    current_period_start = (datetime.now() - timedelta(days=30)).strftime('%Y-%m-%d')
    previous_period_start = (datetime.now() - timedelta(days=60)).strftime('%Y-%m-%d')
    previous_period_end = (datetime.now() - timedelta(days=30)).strftime('%Y-%m-%d')
    
    # Get current critical issues
    current_critical_issues = get_critical_security_issues(
        admin_sdk_service, 
        reports_service,
        start_date=current_period_start
    )
    
    # Get previous period issues for comparison
    previous_critical_issues = get_critical_security_issues(
        admin_sdk_service, 
        reports_service,
        start_date=previous_period_start,
        end_date=previous_period_end
    )
    
    # Calculate metrics
    current_count = len(current_critical_issues)
    previous_count = len(previous_critical_issues)
    count_trend = calculate_percentage_change(previous_count, current_count)
    
    # Calculate remediation metrics
    remediated_issues = [i for i in current_critical_issues if i['status'] == 'remediated']
    remediation_percentage = (len(remediated_issues) / max(current_count, 1)) * 100
    
    # Calculate average time to remediate
    remediation_times = [i['remediation_time_days'] for i in remediated_issues if 'remediation_time_days' in i]
    avg_remediation_time = sum(remediation_times) / max(len(remediation_times), 1)
    
    # Get top risk categories
    risk_categories = {}
    for issue in current_critical_issues:
        category = issue.get('category', 'Uncategorized')
        if category not in risk_categories:
            risk_categories[category] = 0
        risk_categories[category] += 1
        
    top_categories = sorted(
        [{'category': k, 'count': v} for k, v in risk_categories.items()],
        key=lambda x: x['count'],
        reverse=True
    )[:5]  # Top 5 categories
    
    return {
        'current_count': current_count,
        'previous_count': previous_count,
        'count_trend': count_trend,
        'remediation_percentage': remediation_percentage,
        'avg_remediation_time': avg_remediation_time,
        'top_categories': top_categories,
        'unremediated_count': current_count - len(remediated_issues)
    }

def get_critical_security_issues(admin_sdk_service, reports_service, start_date, end_date=None):
    """Get critical security issues from various sources"""
    # This would aggregate data from multiple sources:
    # 1. Admin alerts from admin_sdk_service
    # 2. Security audit findings
    # 3. DLP violations
    # 4. Authentication alerts
    # 5. Custom security rules
    
    # Implementation depends on your specific monitoring setup
    # This is a simplified placeholder
    return [
        {
            'id': 'CRIT-001',
            'title': 'External sharing of sensitive data',
            'category': 'Data Exposure',
            'status': 'active',
            'detected_date': '2023-05-15',
            'severity': 'critical'
        },
        # Additional issues would be included here
    ]

1. Regulatory Compliance Status
2. Compliance scores by framework
3. Failed control count
4. Remediation progress indicators
5. Audit readiness status

Compliance Status Example:

Framework	Compliance	Controls	Gap Count	Trend
ISO 27001	92%	115/125	10	↑ 3%
NIST CSF	88%	93/106	13	↑ 5%
HIPAA	95%	57/60	3	↑ 2%
SOC 2	91%	83/91	8	↔ 0%
GDPR	89%	72/81	9	↑ 4%

2. Threat and Incident Dashboard

This dashboard focuses on security incidents, threat detection, and response metrics.

Key Components

1. Incident Summary
2. Total incidents by severity
3. Mean time to detect (MTTD)
4. Mean time to respond (MTTR)
5. Mean time to remediate (MTTR)
6. Incident status breakdown

Incident Summary Visualization:

┌─ Incident Summary (Last 30 Days) ──────────┐
│                                            │
│  Critical: 3 (+1)   High: 12 (-2)          │
│  Medium: 27 (-5)    Low: 41 (-8)           │
│                                            │
│  MTTD: 2.3 hours (↓ 15%)                   │
│  MTTR: 3.8 hours (↓ 12%)                   │
│  TTR: 3.2 days (↓ 8%)                      │
│                                            │
│  Open: 8   In Progress: 5   Resolved: 70   │
│                                            │
└────────────────────────────────────────────┘

1. Threat Intelligence Overview
2. Active threat campaigns
3. Workspace-specific threat indicators
4. Blocked attack attempts
5. User security awareness status

# Python function to generate threat intelligence summary
def generate_threat_intelligence_summary(reports_service):
    """Generate threat intelligence summary data"""
    # Time range for analysis
    start_date = (datetime.now() - timedelta(days=30)).strftime('%Y-%m-%d')
    
    # Get security events
    security_events = reports_service.activities().list(
        userKey='all',
        applicationName='login,token,admin,mobile',
        startTime=start_date,
        maxResults=1000
    ).execute()
    
    # Analyze phishing attempts
    phishing_attempts = count_phishing_attempts(reports_service, start_date)
    
    # Analyze login blocks
    login_blocks = count_login_blocks(reports_service, start_date)
    
    # Count malware detected
    malware_detected = count_malware_detected(reports_service, start_date)
    
    # Count data exfiltration attempts
    exfiltration_attempts = count_exfiltration_attempts(reports_service, start_date)
    
    # Get awareness training status
    awareness_stats = get_awareness_training_stats(start_date)
    
    return {
        'phishing_attempts': phishing_attempts,
        'login_blocks': login_blocks,
        'malware_detected': malware_detected,
        'exfiltration_attempts': exfiltration_attempts,
        'awareness_stats': awareness_stats
    }

# Helper functions would implement the specific counting logic
# These are simplified placeholders
def count_phishing_attempts(reports_service, start_date):
    """Count phishing attempts"""
    return {'count': 245, 'trend': -12}
    
def count_login_blocks(reports_service, start_date):
    """Count blocked login attempts"""
    return {'count': 1872, 'trend': 8}
    
def count_malware_detected(reports_service, start_date):
    """Count malware detected in email and Drive"""
    return {'count': 87, 'trend': -5}
    
def count_exfiltration_attempts(reports_service, start_date):
    """Count potential data exfiltration attempts"""
    return {'count': 23, 'trend': -15}
    
def get_awareness_training_stats(start_date):
    """Get security awareness training stats"""
    return {
        'completion_rate': 92,
        'phish_test_failure_rate': 8,
        'trend': -3
    }

1. Account Security Status
2. MFA adoption metrics
3. Account compromise attempts
4. Password health statistics
5. Account security policy compliance

Account Security Visualization:

┌─ Account Security Status ───────────────────┐
│                                             │
│  MFA Adoption: 97% (+2%)                    │
│  Hardware Key Usage: 85% (+5%)              │
│                                             │
│  Account Compromise Attempts: 37 (-12%)     │
│  Successful Compromises: 0 (0%)             │
│                                             │
│  Password Policy Compliance: 100%           │
│  Advanced Protection Enrollment: 100%       │
│                                             │
└─────────────────────────────────────────────┘

1. Data Protection Metrics
2. DLP violation trends
3. Sensitive data exposure incidents
4. External sharing statistics
5. Data access anomalies

Data Protection Matrix Example:

Category	Count	Trend	Auto-Remediated	Risk Level
PII Exposure	17	↓ 35%	15 (88%)	Medium
Financial Data	4	↓ 50%	4 (100%)	Low
Source Code	8	↓ 20%	7 (88%)	Medium
Customer Data	3	↓ 70%	3 (100%)	Low
Employee Data	5	↓ 45%	5 (100%)	Low

3. Risk Management Dashboard

This dashboard provides strategic risk overview and remediation status.

Key Components

1. Risk Posture Overview
2. Enterprise risk score
3. Risk breakdown by category
4. Highest risk areas
5. Risk trend over time

Implementation strategy:
- Aggregate risks from all Workspace services
- Calculate composite risk score based on:
  * Control implementation
  * Threat intelligence
  * Vulnerability status
  * User behavior
- Weight risks by potential business impact
- Update weekly with trend analysis

1. Top Security Gaps
2. Critical control failures
3. Highest impact vulnerabilities
4. Remediation status
5. Business impact assessment

Top Gaps Example Table:

Gap	Service	Impact	Status	Age (days)
External sharing controls	Drive	Critical	In Progress	7
Admin 2FA enforcement	Identity	Critical	Planning	12
DLP policy exceptions	Gmail	High	In Progress	15
OAuth app restrictions	API Controls	High	Completed	0
Group access controls	Groups	Medium	In Progress	4

1. Security Investment ROI
2. Security spending effectiveness
3. Cost per incident
4. Risk reduction per dollar
5. Comparative security program efficiency

# Python function to calculate security ROI metrics
def calculate_security_roi_metrics(current_month, baseline_month):
    """Calculate security ROI metrics for dashboard"""
    # This would require integrating cost data with security metrics
    # Simplified example with placeholder data
    
    security_investment = {
        'baseline': 100000,  # Baseline monthly security spend
        'current': 125000,   # Current monthly security spend
        'increase_percentage': 25
    }
    
    # Incident metrics
    incident_metrics = {
        'baseline_count': 35,           # Baseline month incident count
        'current_count': 22,            # Current month incident count
        'reduction_percentage': 37.1,   # Percent reduction
        'baseline_cost': 175000,        # Estimated baseline incident cost
        'current_cost': 85000,          # Estimated current incident cost
        'cost_reduction': 90000         # Cost reduction
    }
    
    # Calculate ROI
    roi = {
        'additional_investment': security_investment['current'] - security_investment['baseline'],
        'cost_savings': incident_metrics['baseline_cost'] - incident_metrics['current_cost'],
        'roi_percentage': ((incident_metrics['baseline_cost'] - incident_metrics['current_cost']) / 
                          (security_investment['current'] - security_investment['baseline'])) * 100,
        'risk_reduction_per_dollar': incident_metrics['reduction_percentage'] / security_investment['increase_percentage']
    }
    
    return {
        'security_investment': security_investment,
        'incident_metrics': incident_metrics,
        'roi': roi
    }

1. Regulatory Risk Exposure
2. Compliance gap analysis
3. Potential regulatory penalties
4. Documentation completeness
5. Audit readiness status

Regulatory Risk Visualization:

┌─ Regulatory Risk Exposure ─────────────────┐
│                                            │
│  Overall Compliance: 93% (+2%)             │
│  Estimated Risk Exposure: $375K (-$125K)   │
│                                            │
│  Gap Analysis:                             │
│  ├─ GDPR: 4 gaps ($200K exposure)          │
│  ├─ HIPAA: 2 gaps ($100K exposure)         │
│  ├─ SOC 2: 3 gaps ($50K exposure)          │
│  └─ ISO 27001: 2 gaps ($25K exposure)      │
│                                            │
│  Audit Readiness: 95% (+5%)                │
│                                            │
└────────────────────────────────────────────┘

4. Security Operations Dashboard

This dashboard focuses on operational security metrics and team performance.

Key Components

1. Security Control Efficacy
2. Control implementation rates
3. Control effectiveness ratings
4. Failed control attempts
5. Control coverage metrics

Control Efficacy Matrix Example:

Control Category	Implementation	Effectiveness	Coverage	Trend
Authentication	98%	97%	100%	↑ 2%
Data Protection	92%	88%	95%	↑ 5%
Threat Detection	95%	93%	100%	↔ 0%
Admin Security	100%	98%	100%	↑ 1%
Device Security	87%	85%	93%	↑ 8%

1. Security Team Performance
2. Alert handling metrics
3. Incident response times
4. Backlog status
5. Team capacity indicators

# Python function to calculate security team metrics
def calculate_security_team_metrics(reports_service, start_date):
    """Calculate security team performance metrics"""
    # This would integrate with your security operations platform
    # Simplified example with placeholder calculations
    
    # Alert metrics
    alert_metrics = {
        'total_alerts': 1245,
        'alerts_per_day': 41.5,
        'alert_trend': -8,  # percentage change
        'alerts_by_severity': {
            'critical': 37,
            'high': 186,
            'medium': 422,
            'low': 600
        },
        'false_positive_rate': 12  # percentage
    }
    
    # Response metrics
    response_metrics = {
        'average_triage_time_minutes': 12,
        'average_response_time_hours': 2.3,
        'average_resolution_time_hours': 8.7,
        'sla_compliance_percentage': 97
    }
    
    # Backlog metrics
    backlog_metrics = {
        'total_open_items': 23,
        'backlog_trend': -15,  # percentage change
        'average_age_days': 3.2,
        'items_overdue': 2
    }
    
    # Team capacity
    capacity_metrics = {
        'team_utilization_percentage': 85,
        'available_capacity_hours': 45,
        'utilization_trend': 5  # percentage change
    }
    
    return {
        'alert_metrics': alert_metrics,
        'response_metrics': response_metrics,
        'backlog_metrics': backlog_metrics,
        'capacity_metrics': capacity_metrics
    }

1. Automation Effectiveness
2. Automated response rate
3. Automation failure rate
4. Time saved through automation
5. Automation coverage metrics

Automation Effectiveness Display:

┌─ Security Automation Metrics ──────────────┐
│                                            │
│  Automated Response Rate: 78% (+8%)        │
│  Manual Investigation Rate: 22% (-8%)      │
│                                            │
│  Automation Success Rate: 97% (+2%)        │
│  Estimated Time Saved: 187 hours           │
│                                            │
│  Top Automated Workflows:                  │
│  1. Phishing Response (412 incidents)      │
│  2. Access Anomalies (253 incidents)       │
│  3. DLP Remediation (201 incidents)        │
│                                            │
└────────────────────────────────────────────┘

1. Vulnerability Management Status
2. Open vulnerability trends
3. Time-to-patch metrics
4. Vulnerability risk exposure
5. Patch compliance status

Vulnerability Management Table Example:

Category	Open Count	Avg Age (days)	SLA Compliance	Trend
Critical	0	0	100%	↔ 0%
High	3	4.2	100%	↓ 40%
Medium	12	12.5	92%	↓ 25%
Low	27	23.8	85%	↓ 10%

Implementation Strategies

1. Data Collection and Integration

Implement comprehensive data collection to power executive dashboards:

1. Google Workspace API Integration

   # Python example for Workspace API integration
   from googleapiclient.discovery import build
   from oauth2client.service_account import ServiceAccountCredentials
   
   def initialize_workspace_services():
       """Initialize Google Workspace API services"""
       # Define the scopes required for API access
       SCOPES = [
           'https://www.googleapis.com/auth/admin.reports.audit.readonly',
           'https://www.googleapis.com/auth/admin.reports.usage.readonly',
           'https://www.googleapis.com/auth/admin.directory.user.readonly',
           'https://www.googleapis.com/auth/admin.directory.domain.readonly',
           'https://www.googleapis.com/auth/admin.directory.group.readonly',
           'https://www.googleapis.com/auth/apps.alerts'
       ]
       
       # Service account credentials from JSON key file
       credentials = ServiceAccountCredentials.from_json_keyfile_name(
           'service-account-key.json', SCOPES)
       
       # Delegate to an admin user
       delegated_credentials = credentials.create_delegated('admin@yourdomain.com')
       
       # Build services
       services = {
           'reports': build('admin', 'reports_v1', credentials=delegated_credentials),
           'directory': build('admin', 'directory_v1', credentials=delegated_credentials),
           'alerts': build('alertcenter', 'v1beta1', credentials=delegated_credentials)
       }
       
       return services
   

2. Security Information Integration

3. Security information and event management (SIEM) integration
4. Log aggregation and normalization
5. Cross-platform security data correlation

6. Custom security metric calculation

7. Metrics Definition and Collection

8. Define clear metric calculation methodologies
9. Establish data quality controls
10. Implement data validation procedures
11. Create historical data storage and trending

2. Dashboard Platform Options

Select appropriate platforms for dashboard implementation:

1. Google Data Studio (Looker Studio)
2. Native integration with Google services
3. Rich visualization capabilities
4. Interactive filtering and exploration
5. Shareable and embeddable reports

Implementation Notes:

- Connect directly to Google Workspace audit logs
- Create calculated fields for security metrics
- Use date-range comparison for trend analysis
- Implement parameter controls for interactive exploration
- Schedule automatic refresh for near real-time data

1. Custom Dashboard Development
2. Flexibility for specialized requirements
3. Integration with existing security portals
4. Custom business logic implementation
5. Tailored visualization options

Technology Stack Options: - Frontend: React with D3.js or Chart.js - Backend: Python (Flask/Django) or Node.js - Data processing: Apache Airflow or custom ETL - Storage: Google BigQuery or Cloud SQL

1. Third-Party Security Platforms
2. Pre-built Google Workspace integrations
3. Specialized security visualization
4. Cross-platform security correlation
5. Compliance-focused reporting

Integration Considerations: - API access and authentication - Data refresh frequency - Custom field mapping - Historical data availability

3. Reporting Cadence and Distribution

Establish effective reporting workflows:

1. Report Scheduling
2. Weekly operational summaries
3. Monthly executive briefings
4. Quarterly board-level reviews

5. On-demand critical incident reporting

6. Distribution Methods

7. Automated email delivery
8. Secure dashboard access
9. Interactive presentation materials

10. Executive briefing sessions

11. Notification Thresholds

12. Define alert thresholds for key metrics
13. Implement notification workflows
14. Create escalation procedures
15. Establish acknowledgment tracking

Executive Presentation Strategies

1. Presentation Templates

Develop standardized presentation materials:

1. Executive Summary Template

   1. Security Posture Overview (1 slide)
      - Overall security score with trend
      - Key risk indicators
      - Significant changes since last report
   
   2. Critical Issues and Response (1-2 slides)
      - High-priority security concerns
      - Mitigation status and timeline
      - Business impact assessment
   
   3. Security Program Progress (1 slide)
      - Initiative status updates
      - Key milestone achievements
      - Resource utilization metrics
   
   4. Strategic Recommendations (1 slide)
      - Prioritized security enhancements
      - Resource requirements
      - Expected business benefits
   

2. Board Presentation Template

   1. Security Risk Overview (1 slide)
      - Enterprise security posture
      - Risk trend analysis
      - Peer comparison benchmarks
   
   2. Security Investment ROI (1 slide)
      - Security spending effectiveness
      - Risk reduction metrics
      - Cost avoidance calculations
   
   3. Strategic Risk Areas (1 slide)
      - Highest business impact risks
      - Mitigation strategy overview
      - Governance considerations
   
   4. Regulatory and Compliance Status (1 slide)
      - Compliance posture by framework
      - Audit readiness status
      - Material findings and remediation
   

3. Security Committee Template

   1. Security Program Status (1-2 slides)
      - Initiative progress against roadmap
      - Resource allocation and utilization
      - Key performance indicators
   
   2. Operational Metrics (2-3 slides)
      - Incident response effectiveness
      - Control performance data
      - Vulnerability management metrics
      - Threat landscape overview
   
   3. Risk Management (1-2 slides)
      - Critical risk status
      - Risk acceptance decisions
      - Emerging risk areas
   
   4. Strategic Planning (1-2 slides)
      - Future initiative proposals
      - Technology evaluation results
      - Capability enhancement recommendations
   

2. Narrative Development

Create compelling security narratives for executives:

1. Business Impact Focus
2. Connect security metrics to business outcomes
3. Quantify risk in financial terms when possible
4. Relate security posture to business goals

5. Demonstrate ROI of security investments

6. Simplified Technical Translation

7. Convert technical details to business language
8. Use analogies for complex security concepts
9. Provide context for technical terminology

10. Create executive-friendly security glossary

11. Forward-Looking Analysis

12. Include predictive risk trending
13. Anticipate evolving threat landscape
14. Connect security strategy to business roadmap
15. Provide proactive recommendations

Dashboard Implementation Examples

1. Google Workspace Security Posture Dashboard

Implementation Example in Google Looker Studio:

1. Data Source Configuration
2. Create BigQuery tables for processed security data
3. Implement ETL for Google Workspace audit logs
4. Establish calculated security metrics

5. Configure data refresh schedules

6. Dashboard Structure

7. Overall security score card
8. Service compliance heat map
9. Critical control implementation status
10. Historical trend charts

11. Compliance status by framework

12. Interactivity Options

13. Date range selectors
14. Service-specific filtering
15. Drill-down capabilities for details
16. Comparison period toggling

2. Security Risk Trend Dashboard

Implementation Example with Custom Development:

1. Data Processing Pipeline
2. Google Workspace audit log ingestion
3. Security metrics calculation in Python
4. Storage in time-series database

5. Automated risk scoring algorithms

6. Visualization Components

7. Risk trend line charts with confidence intervals
8. Categorical risk breakdown
9. Risk factor correlation matrix

10. Predictive risk trajectory

11. Interactive Features

12. Risk factor contribution analysis
13. Scenario modeling capabilities
14. Control effectiveness simulation
15. Comparative benchmark overlay

Continuous Improvement Framework

1. Dashboard Effectiveness Assessment

Regularly evaluate and improve executive reporting:

1. Executive Feedback Loops
2. Structured feedback collection
3. Usability evaluation sessions
4. Comprehension testing

5. Decision support effectiveness measurement

6. Metric Refinement Process

7. Periodic metric relevance review
8. Calculation methodology validation
9. Benchmark accuracy verification

10. New metric identification and development

11. Visual Design Enhancement

12. Clarity and comprehension testing
13. Information density optimization
14. Accessibility improvements
15. Mobile and large-display format optimization

2. Analytics Maturity Evolution

Progress through increasing analytics sophistication:

1. Descriptive Analytics (What happened?)
2. Historical security events
3. Control performance metrics
4. Compliance status reporting

5. Incident summaries

6. Diagnostic Analytics (Why did it happen?)

7. Root cause analysis
8. Control failure investigation
9. Correlation analysis

10. Comparative performance evaluation

11. Predictive Analytics (What will happen?)

12. Risk trajectory forecasting
13. Threat trend prediction
14. Security posture projection

15. Vulnerability exploitation likelihood

16. Prescriptive Analytics (What should we do?)

17. Optimal control recommendations
18. Resource allocation optimization
19. Risk mitigation prioritization
20. Security architecture improvement guidance

Resources and References

1. Google Workspace Reporting Tools
2. Google Workspace Admin Console Reports
3. Google Workspace Audit API

4. Looker Studio (formerly Data Studio)

5. Security Metrics Guidance

6. CIS Security Metrics Guide
7. NIST SP 800-55: Performance Measurement Guide

8. OWASP Security Metrics Project

9. Executive Communication Resources

10. SANS: Communicating Security to the Board
11. Gartner: Security Metrics That Matter to the Board
12. FAIR Institute: Risk Quantification

---

Note: This guide should be adapted to your organization's specific Google Workspace configuration, security posture, and executive reporting requirements.