How to Integrate with Google Meet 2025: Complete Developer Guide

Google Meet integration has evolved significantly in 2025. While Google’s official APIs still require $15,000+ verification processes and complex OAuth flows, ScreenApp’s open-source meeting bot offers a practical alternative. This production-ready, MIT-licensed automation platform addresses common developer challenges, providing enterprise-grade meeting intelligence that deploys in under 5 minutes.

With Google Meet commanding 31.4% of the video conferencing market, the demand for reliable integration continues to grow. This comprehensive guide shows how ScreenApp’s solution compares to traditional Google APIs, services like Recall.ai, and DIY WebRTC implementations—providing developers with the tools needed for meeting automation without excessive complexity or vendor lock-in.

Need help implementing meeting automation for your specific use case? Contact our team at inquiries@screenapp.io for personalized guidance.

The Current State of Google Meet Integration in 2025

The Google Meet API landscape transformed dramatically in April 2025 when Google’s Meet API reached general availability. However, many developers still face significant challenges with authentication complexity, limited functionality, and expensive verification processes. Here’s what’s available and what actually works in practice.

What’s New in 2025

Google Meet API General Availability (April 2025)

• Programmatic moderation settings and permissions
• Enhanced meeting management capabilities
• Still requires complex OAuth2.0 authentication

Google Meet Media API (Developer Preview)

• Real-time media access from Google Meet
• Limited availability and complex implementation
• Requires specialized WebRTC knowledge

Simplified Integration Options

• Open-source meeting bot solutions
• Enhanced browser automation capabilities
• Cost-effective alternatives to expensive enterprise APIs

6 Ways to Integrate with Google Meet in 2025

1. Create Google Meet Links Programmatically

Method A: Direct URL Construction (Workspace Users) For paid Google Workspace users, you can create consistent meeting URLs:

const createMeetingURL = (customName) => {
  return `https://meet.google.com/lookup/${customName}`;
};

// Example usage
const meetingURL = createMeetingURL('team-standup-monday');
console.log(meetingURL); // https://meet.google.com/lookup/team-standup-monday

Limitations:

• Requires paid Google Workspace subscription
• Meeting rooms persist indefinitely
• Limited customization options

Method B: Google Calendar API Integration Create meetings through calendar events with attached Google Meet links:

const { google } = require('googleapis');

const createMeetingWithCalendar = async (auth, eventDetails) => {
  const calendar = google.calendar({ version: 'v3', auth });
  
  const event = {
    summary: eventDetails.title,
    start: {
      dateTime: eventDetails.startTime,
      timeZone: 'America/Los_Angeles',
    },
    end: {
      dateTime: eventDetails.endTime,
      timeZone: 'America/Los_Angeles',
    },
    conferenceData: {
      createRequest: {
        requestId: 'sample123',
        conferenceSolutionKey: {
          type: 'hangoutsMeet'
        }
      }
    },
    attendees: eventDetails.attendees
  };

  const response = await calendar.events.insert({
    calendarId: 'primary',
    resource: event,
    conferenceDataVersion: 1
  });

  return response.data.conferenceData.entryPoints[0].uri;
};

Limitations:

• Requires user OAuth consent
• Meeting tied to calendar owner
• Complex authentication setup

Method C: ScreenApp’s Open-Source Meeting Bot (Recommended) The most straightforward approach uses ScreenApp’s production-ready meeting bot with MIT license:

const joinGoogleMeetWithScreenApp = async (meetingDetails) => {
  const response = await fetch('http://localhost:3000/google/join', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      bearerToken: 'your-auth-token',
      url: meetingDetails.meetingURL,
      name: 'Meeting Notetaker',
      teamId: meetingDetails.teamId,
      timezone: 'UTC',
      userId: meetingDetails.userId,
      botId: crypto.randomUUID()
    })
  });

  // Success Response (202 Accepted)
  const result = await response.json();
  /*
  {
    "success": true,
    "message": "Meeting join request accepted and processing started",
    "data": {
      "userId": "user123",
      "teamId": "team123", 
      "status": "processing"
    }
  }
  */
  return result;
};

Unique ScreenApp Advantages:

• Single Job Execution: Prevents system conflicts across all meetings
• Anti-Detection Technology: Advanced stealth mode for reliable meeting joins
• Built-in Prometheus Metrics: Enterprise monitoring out of the box
• MIT License: Complete commercial freedom with no restrictions
• Multi-Platform API: Same endpoint structure for Google Meet, Teams, and Zoom

2. Receive Real-Time Meeting Notifications

The Google API Limitation Google Meet provides no native webhook system for real-time notifications. Most developers resort to expensive workarounds or incomplete solutions.

Traditional Workarounds (Not Recommended)

• Google Meet attendance reports via email
• Admin SDK Reports API (enterprise only)
• Polling calendar events (inefficient)

ScreenApp’s Open-Source Solution ScreenApp’s open-source meeting bot addresses Google Meet API limitations with production-ready automation:

// Check if system is available before joining
const checkSystemStatus = async () => {
  const response = await fetch('http://localhost:3000/isbusy');
  const status = await response.json();
  
  if (response.status === 409) {
    // System busy - single job execution prevents conflicts
    console.log('System processing another meeting');
    return false;
  }
  return true;
};

// Join meeting with automatic recording and monitoring
const joinMeetingWithFullAutomation = async (meetingURL) => {
  if (!await checkSystemStatus()) return;
  
  const response = await fetch('http://localhost:3000/google/join', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      bearerToken: 'your-auth-token',
      url: meetingURL,
      name: 'ScreenApp Bot',
      teamId: 'your-team',
      timezone: 'UTC',
      userId: 'your-user-id',
      botId: crypto.randomUUID()
    })
  });

  return response.json(); // 202 Accepted with processing status
};

// Monitor system metrics with built-in Prometheus
const getSystemMetrics = async () => {
  const response = await fetch('http://localhost:3000/metrics');
  return response.text(); // Prometheus metrics format
};

ScreenApp’s Key Features:

• Single Job Architecture: Prevents resource conflicts and ensures reliable recording
• Playwright-Powered Automation: Advanced browser control with anti-detection measures
• Built-in Monitoring: Prometheus metrics for enterprise observability
• Graceful Resource Management: Proper cleanup and shutdown handling
• Docker-Native Deployment: Production containers available via GitHub Packages

Questions about implementing these features in your environment? Reach out to our team at inquiries@screenapp.io

3. Extract Participant Information

Google’s Limited Options Retrieving participant emails and details through official APIs requires expensive enterprise verification or incomplete data sources.

Google Calendar API Method

const getParticipantsFromCalendar = async (auth, eventId) => {
  const calendar = google.calendar({ version: 'v3', auth });
  
  const event = await calendar.events.get({
    calendarId: 'primary',
    eventId: eventId
  });

  return event.data.attendees || [];
};

Limitations:

• Only shows invited participants
• Doesn’t track actual attendance
• Missing uninvited attendees who join via link

ScreenApp’s Comprehensive Tracking

const getActualParticipants = async (meetingId) => {
  const response = await fetch(`http://localhost:3000/meetings/${meetingId}/participants`);
  const participants = await response.json();
  
  return participants.map(p => ({
    name: p.displayName,
    email: p.email || 'guest',
    joinTime: p.joinedAt,
    leaveTime: p.leftAt || null,
    duration: p.sessionDuration,
    isMuted: p.audioState === 'muted',
    isVideoOn: p.videoState === 'enabled'
  }));
};

Advanced Features:

• Real-time participant status tracking
• Guest participant detection
• Join/leave timestamps
• Audio/video state monitoring

4. Access Meeting Recordings Efficiently

Google’s Expensive Approach Google Drive API access for meeting recordings requires costly verification ($15,000-$75,000) and 2+ months approval time.

Traditional Method (Not Recommended)

// Expensive Google Drive API approach
const getRecordings = async (auth) => {
  const drive = google.drive({ version: 'v3', auth });
  
  const response = await drive.files.list({
    q: "parents in '1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms'",
    fields: 'files(id, name, createdTime)'
  });
  
  return response.data.files;
};

ScreenApp’s Direct Recording Solution

// Start recording immediately when bot joins
const startMeetingRecording = async (meetingConfig) => {
  const response = await fetch('http://localhost:3000/google/join', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      ...meetingConfig,
      recordingEnabled: true,
      maxDuration: 120 // minutes
    })
  });

  // Recording automatically saves to your infrastructure
  return response.json();
};

// Access recordings immediately
const getRecording = async (meetingId) => {
  const response = await fetch(`http://localhost:3000/recordings/${meetingId}`);
  return response.json(); // Direct file access, no Google Drive complexity
};

Key Advantages:

• No Google Drive API verification required
• Immediate recording access
• Self-hosted storage options
• Multiple output formats (MP4, WebM, audio-only)

Looking to implement meeting recording in your application? Contact our team at inquiries@screenapp.io for technical assistance.

5. Process Real-Time Audio and Video

Google’s Technical Challenges Official Google Meet APIs don’t provide real-time media streams. Developers must implement complex WebRTC extraction manually.

Manual WebRTC Implementation (Complex)

// Traditional approach - extremely complex
const extractMediaStreams = async () => {
  // 1. Launch Chrome/Chromium browser
  // 2. Navigate to Google Meet
  // 3. Handle authentication
  // 4. Extract WebRTC streams
  // 5. Process raw audio/video data
  // 6. Encode and store media
  // This requires hundreds of lines of complex code
};

ScreenApp’s Streamlined Solution

// Simple API call for real-time processing
const processRealTimeMedia = async (meetingURL) => {
  const botConfig = {
    url: meetingURL,
    features: {
      audioTranscription: true,
      videoAnalysis: true,
      realTimeInsights: true
    }
  };

  const response = await fetch('http://localhost:3000/google/join', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(botConfig)
  });

  // Automatic processing happens in the background
  return response.json();
};

// Access processed data in real-time
const getRealTimeData = async (meetingId) => {
  const response = await fetch(`http://localhost:3000/meetings/${meetingId}/live-data`);
  return response.json(); // Transcripts, insights, participant data
};

Advanced Processing Features:

• Real-time transcription with speaker identification
• Automatic meeting summaries and action items
• Sentiment analysis and engagement metrics
• Custom keyword detection and alerts

6. Advanced Meeting Analytics and AI Processing

Beyond basic integration, modern applications require intelligent meeting analysis. ScreenApp’s platform provides enterprise-grade AI capabilities that integrate seamlessly with the meeting bot.

Automated Meeting Intelligence

const enableMeetingAI = async (meetingConfig) => {
  return await fetch('http://localhost:3000/google/join', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      ...meetingConfig,
      aiFeatures: {
        autoTranscription: true,
        actionItemExtraction: true,
        sentimentAnalysis: true,
        topicSegmentation: true
      }
    })
  });
};

Integration with ScreenApp’s AI Suite The meeting bot connects seamlessly with ScreenApp’s comprehensive video analysis platform:

• AI Note Taker: Automatically generates structured meeting notes with key points, decisions, and action items
• AI Summarizer: Creates executive summaries tailored for different stakeholders
• Video Analyzer: Provides deep insights into meeting dynamics, participation patterns, and content analysis

Complete Implementation Guide: ScreenApp’s Production-Ready Meeting Bot

Lightning-Fast Setup (Under 5 Minutes)

1. Clone ScreenApp’s Open-Source Repository

git clone https://github.com/screenappai/meeting-bot.git
cd meeting-bot

2. Install Dependencies and Setup Environment

# Install Node.js dependencies
npm install

# Configure environment
cp .env.example .env
# Edit .env with your configuration (MAX_RECORDING_DURATION_MINUTES=60 by default)

3. Launch with Docker (Recommended)

# Start the complete development environment
npm run dev

# Server starts immediately on http://localhost:3000

4. Test Your First Google Meet Integration

curl -X POST http://localhost:3000/google/join \
  -H "Content-Type: application/json" \
  -d '{
    "bearerToken": "your-auth-token",
    "url": "https://meet.google.com/abc-defg-hij",
    "name": "Meeting Notetaker",
    "teamId": "team123",
    "timezone": "UTC",
    "userId": "user123",
    "botId": "'$(uuidgen)'"
  }'

# Expected Response (202 Accepted):
# {
#   "success": true,
#   "message": "Meeting join request accepted and processing started",
#   "data": {
#     "userId": "user123", 
#     "teamId": "team123",
#     "status": "processing"
#   }
# }

5. Monitor System Status and Metrics

# Check system availability (single job execution)
curl http://localhost:3000/isbusy

# Access built-in Prometheus metrics
curl http://localhost:3000/metrics

Enterprise Production Deployment

GitHub Packages Container Registry ScreenApp automatically builds and publishes production-ready containers:

# Pull latest stable release
docker pull ghcr.io/screenappai/meeting-bot:latest

# Deploy to production with custom configuration
docker run -d \
  --name screenapp-meeting-bot \
  -p 3000:3000 \
  -e MAX_RECORDING_DURATION_MINUTES=120 \
  -e NODE_ENV=production \
  -e PORT=3000 \
  ghcr.io/screenappai/meeting-bot:latest

Available Container Tags:

• latest - Latest stable release from main branch
• main - Latest commit from main branch
• sha-<commit-hash> - Specific commit builds for reproducible deployments

Enterprise Architecture Features:

• Single Job Execution System: Prevents resource conflicts across all meetings
• Advanced Browser Automation: Playwright-powered with anti-detection technology
• Production-Ready Monitoring: Built-in Prometheus metrics and health checks
• Graceful Shutdown: Proper resource cleanup and meeting session management

Google Meet Integration Comparison: 2025 Edition

Feature	Google Meet API	Recall.ai	ScreenApp Meeting Bot
Setup Complexity	High (OAuth2.0, verification)	Medium (API keys)	Low (Docker run)
Cost	$15k+ verification + usage	$0.30-0.70/hour	Free (MIT license)
Real-time Events	None	Limited	Complete
Recording Access	Complex Drive API	Vendor-dependent	Immediate
Customization	Limited	Proprietary	Full source access
Self-hosting	Not available	Not available	Complete control
Media Processing	Manual WebRTC	Basic	Advanced AI

Overcoming Common Google Meet Integration Challenges

Authentication Complexity

Problem: Google’s OAuth2.0 implementation requires complex token management and user consent flows.

ScreenApp Solution: Simple API token authentication eliminates OAuth complexity while maintaining security.

// Traditional Google OAuth (complex)
const auth = new google.auth.OAuth2(clientId, clientSecret, redirectUrl);
// Requires consent flow, token refresh logic, scope management

// ScreenApp approach (simple)
const headers = { 'Authorization': `Bearer ${apiToken}` };
// Single token, no user consent required

API Rate Limiting

Problem: Google APIs impose strict rate limits that can break applications during peak usage.

ScreenApp Solution: Self-hosted infrastructure eliminates rate limiting concerns.

Incomplete Event Data

Problem: Google’s APIs provide limited event information, missing crucial meeting dynamics.

ScreenApp Solution: Comprehensive event tracking with participant behavior, audio/video states, and interaction patterns.

Development and Testing Complexity

Problem: Testing Google Meet integrations requires complex mock setups and limited sandbox environments.

ScreenApp Solution: Local development environment with immediate testing capabilities.

# Start local development server
npm run dev

# Test with any Google Meet URL immediately
curl -X POST http://localhost:3000/google/join -d '{"url": "https://meet.google.com/test-meeting"}'

Advanced Use Cases and Examples

Meeting Analytics Dashboard

const buildMeetingDashboard = async () => {
  const meetings = await fetch('http://localhost:3000/meetings/recent').then(r => r.json());
  
  const analytics = meetings.map(meeting => ({
    id: meeting.id,
    duration: meeting.duration,
    participantCount: meeting.participants.length,
    averageEngagement: meeting.analytics.engagement,
    actionItems: meeting.ai.actionItems.length,
    sentiment: meeting.ai.sentiment,
    topTopics: meeting.ai.topics.slice(0, 5)
  }));
  
  return analytics;
};

Automated Meeting Workflows

const automatedMeetingWorkflow = {
  // Pre-meeting setup
  beforeMeeting: async (meetingConfig) => {
    await sendSlackNotification('Meeting bot joining in 2 minutes');
    return await joinMeeting(meetingConfig);
  },
  
  // During meeting processing
  duringMeeting: async (meetingId) => {
    const realTimeData = await getRealTimeData(meetingId);
    
    // Trigger alerts for important moments
    if (realTimeData.keywordDetected.includes('action item')) {
      await notifyProjectManager(realTimeData);
    }
  },
  
  // Post-meeting automation
  afterMeeting: async (meetingId) => {
    const summary = await generateSummary(meetingId);
    await sendToSlack(summary);
    await updateCRM(summary.actionItems);
    await scheduleFollowUps(summary.decisions);
  }
};

Universal Multi-Platform Meeting Bot

ScreenApp’s meeting bot provides identical API structure across all major video conferencing platforms:

// Google Meet Integration
const joinGoogleMeet = async (meetingConfig) => {
  return await fetch('http://localhost:3000/google/join', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      bearerToken: meetingConfig.token,
      url: 'https://meet.google.com/abc-defg-hij',
      name: 'Meeting Notetaker',
      teamId: meetingConfig.teamId,
      timezone: 'UTC',
      userId: meetingConfig.userId,
      botId: crypto.randomUUID()
    })
  });
};

// Microsoft Teams Integration  
const joinMicrosoftTeams = async (meetingConfig) => {
  return await fetch('http://localhost:3000/microsoft/join', {
    method: 'POST', 
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      bearerToken: meetingConfig.token,
      url: 'https://teams.microsoft.com/l/meetup-join/...',
      name: 'Meeting Notetaker',
      teamId: meetingConfig.teamId,
      timezone: 'UTC', 
      userId: meetingConfig.userId,
      botId: crypto.randomUUID()
    })
  });
};

// Zoom Integration
const joinZoomMeeting = async (meetingConfig) => {
  return await fetch('http://localhost:3000/zoom/join', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      bearerToken: meetingConfig.token,
      url: 'https://zoom.us/j/123456789',
      name: 'Meeting Notetaker', 
      teamId: meetingConfig.teamId,
      timezone: 'UTC',
      userId: meetingConfig.userId,
      botId: crypto.randomUUID()
    })
  });
};

// Universal meeting bot function
const joinAnyMeeting = async (platform, meetingConfig) => {
  const platformHandlers = {
    'google': joinGoogleMeet,
    'teams': joinMicrosoftTeams, 
    'zoom': joinZoomMeeting
  };
  
  return await platformHandlers[platform](/definitions/meeting-recording);
};

ScreenApp’s Universal Advantages:

• Identical API Structure: Same request format across all platforms
• Single Codebase: One meeting bot handles Google Meet, Teams, and Zoom
• Consistent Response Format: 202 Accepted with standardized status messages
• Platform-Agnostic Features: Recording, metrics, and monitoring work universally

Why Teams Choose ScreenApp’s Meeting Bot

Cost-Effective Solution

No Usage-Based Pricing: While Recall.ai charges $0.30-0.70 per hour and Google requires $15,000+ verification, ScreenApp’s MIT-licensed solution has no deployment or scaling costs.

Technical Advantages

Advanced Browser Automation: ScreenApp’s Playwright-powered engine with anti-detection technology provides reliable meeting joins, improving on basic WebRTC implementations.

Single Job Architecture: Prevents the resource conflicts and system crashes common in multi-threaded meeting bot solutions.

Enterprise Monitoring: Built-in Prometheus metrics provide production-grade observability without additional costs.

Complete Ownership and Control

MIT License: Unlike proprietary solutions, you own the code completely - modify, distribute, and commercialize without restrictions.

Self-Hosted Security: Keep sensitive meeting data on your infrastructure, eliminating vendor access and compliance concerns.

No Vendor Lock-In: Avoid concerns about pricing changes, service discontinuation, or API deprecation.

Evaluating meeting bot solutions for your organization? Contact us at inquiries@screenapp.io for a technical consultation.

Developer-Friendly Experience

Quick Setup: Go from repository clone to production meeting bot in under 5 minutes.

Universal API Design: Identical endpoints for Google Meet, Teams, and Zoom reduce platform-specific integration complexity.

Production-Ready Architecture: TypeScript codebase with proper error handling, graceful shutdown, and resource management built-in.

Common Questions About Google Meet Integration

Is ScreenApp’s meeting bot really free?

Yes, the meeting bot is completely open-source under the MIT license. You can use, modify, and deploy it commercially without restrictions.

How does this compare to Google’s official APIs?

ScreenApp’s solution eliminates the $15,000+ verification process, complex OAuth flows, and API limitations while providing enhanced functionality.

Can I customize the meeting bot for my specific needs?

Absolutely. Full source code access allows unlimited customization, from simple configuration changes to complete feature additions.

What about security and compliance?

Self-hosted deployment provides maximum security control. The solution supports enterprise security requirements including encryption, audit logging, and compliance certifications.

How quickly can I get started?

The Docker setup takes under 5 minutes. You can join your first meeting and start testing immediately.

Have specific questions about your implementation? Get in touch with our technical team at inquiries@screenapp.io

The Current Meeting Intelligence Landscape

The meeting bot landscape continues evolving toward open-source, AI-powered solutions that prioritize developer experience and data sovereignty. Traditional approaches like complex Google APIs or expensive services like Recall.ai present challenges that many organizations seek to avoid.

ScreenApp’s meeting bot offers teams:

• Scalability without vendor lock-in
• AI processing capabilities for meeting intelligence
• Complete transparency through open-source development
• Predictable costs with no usage-based pricing

Getting Started with ScreenApp’s Meeting Bot

ScreenApp’s open-source meeting bot provides an alternative to Google’s complex APIs, expensive verification processes, and vendor lock-in, delivering enterprise-grade meeting automation with straightforward deployment.

Quick Setup Guide

Simple Deployment Process:

# Clone ScreenApp's production-ready meeting bot
git clone https://github.com/screenappai/meeting-bot.git
cd meeting-bot

# Launch with a single command
npm run dev

# Join your first Google Meet immediately
curl -X POST http://localhost:3000/google/join \
  -H "Content-Type: application/json" \
  -d '{"bearerToken": "your-token", "url": "https://meet.google.com/your-meeting"}'

Implementation Steps

• Star the repository on GitHub to stay updated
• Deploy locally with Docker in under 5 minutes
• Test Google Meet integration using real meeting URLs
• Enable Prometheus monitoring for production insights
• Scale to production with GitHub Packages containers
• Integrate AI features with ScreenApp’s comprehensive platform

Need assistance with any of these steps? Our technical team is available at inquiries@screenapp.io

Benefits of Using ScreenApp

Quick Implementation:

• 5-minute setup vs months of API integration complexity
• $0 licensing costs vs $15,000+ Google verification fees
• Reliable meeting joins with anti-detection technology
• Universal platform support for Google Meet, Teams, and Zoom

Security and Control:

• Complete data ownership through self-hosted deployment
• MIT license with no commercial restrictions
• Production-grade monitoring with built-in Prometheus metrics
• Proper resource management preventing system crashes

Developer Experience:

• Identical API structure across all video platforms
• TypeScript codebase with proper error handling and types
• Docker-native deployment with GitHub Packages automation
• Single job architecture preventing resource conflicts

The ScreenApp Advantage: Beyond Just Meeting Bots

When you choose ScreenApp’s meeting bot, you’re not just getting meeting automation—you’re accessing a complete meeting intelligence ecosystem:

• AI Note Taker: Transform meeting recordings into structured, searchable notes automatically
• AI Summarizer: Generate executive summaries and action items from any meeting
• Video Analyzer: Extract insights from meeting dynamics, participation, and engagement

Getting Started with Meeting Automation

ScreenApp provides an open-source alternative to expensive, limited APIs, offering developers a practical solution for meeting automation needs.

Implementation process:

1. Clone the repository and test the meeting automation locally
2. Deploy to your environment with complete control over your data
3. Scale as needed using proven container infrastructure
4. Customize functionality based on your specific requirements

For organizations seeking meeting automation that’s transparent and fully controllable, ScreenApp offers a viable path forward.

Resources:

• GitHub Repository →
• Contact our team → for implementation guidance