Implementation Guide: Analyze revpar trends and competitor rate intelligence

Hardware Procurement

Software Procurement

Prerequisites

• Operational Property Management System (PMS) with API access enabled — supported PMS platforms include Cloudbeds, Mews, Oracle OPERA Cloud, Apaleo, MEWS, little hotelier, Clock PMS+, Protel, or any PMS with an open API or RoomPriceGenie/Lighthouse integration listed on their integration pages.
• Minimum 12 months of historical booking data loaded in the PMS (essential for AI demand forecasting calibration; 24 months is ideal).
• Active channel manager connections to at least Booking.com and Expedia (e.g., SiteMinder, Cloudbeds Distribution, or built-in PMS channel manager). Required for rate push automation.
• Internet service: minimum 50 Mbps download / 25 Mbps upload with an available second WAN connection (LTE failover or secondary ISP) for dual-WAN configuration.
• Hotel management has identified an initial competitive set of 5–10 properties in the same market segment and geographic area for rate benchmarking.
• A designated revenue decision-maker on the hotel side (Revenue Manager, GM, or owner) who will review rate recommendations and approve pricing strategy parameters.
• Active Microsoft 365 tenant or willingness to provision one for Power BI and Teams-based communication.
• Chrome 90+ or Microsoft Edge 90+ browser installed on all workstations that will access the platforms.
• PCI DSS compliance: confirm that the PMS environment maintains PCI DSS 4.0.1 compliance and that network segmentation prevents rate analytics traffic from traversing the cardholder data environment (CDE).
• Physical access to the network closet / MDF for router and switch installation, including available 120V outlets and rack space (1U minimum).

Installation Steps

Step 1: Site Assessment & Discovery Audit

Conduct an on-site or remote discovery session to document the client's current technology stack, PMS platform and version, channel manager, existing internet service, network topology, and current rate management workflow (manual spreadsheets vs. existing tool). Interview the revenue decision-maker to understand pricing strategy, competitor set, seasonal patterns, and key performance goals. Document all findings in a standardized discovery template.

# Run network assessment from a laptop connected to the hotel LAN
nmap -sn 192.168.1.0/24 > hotel_network_scan.txt
# Test current internet speeds
speedtest-cli --simple > hotel_speedtest_results.txt
# Document PMS version and API endpoint (example for Cloudbeds)
curl -s -o /dev/null -w '%{http_code}' https://hotels.cloudbeds.com/api/v1.1/getHotelDetails -H 'Authorization: Bearer TEST_TOKEN'

Step 2: Network Infrastructure Deployment

Install the Ubiquiti UDM-Pro as the primary gateway/router, replacing or supplementing the existing router. Configure dual-WAN with the primary ISP on WAN1 and a secondary connection (LTE or second ISP) on WAN2 with automatic failover. Install the USW-24-PoE switch in the network closet. Connect the APC UPS and plug in the modem/ONT, UDM-Pro, and switch. Configure VLANs to segment back-office/revenue management traffic from guest Wi-Fi.

BackOffice-Revenue VLAN:
  Name: BackOffice-Revenue
  VLAN ID: 10
  Subnet: 10.10.10.0/24
  DHCP Range: 10.10.10.100 - 10.10.10.200

Guest-WiFi VLAN:
  Name: Guest-WiFi
  VLAN ID: 20
  Subnet: 10.10.20.0/24
  Guest Network: Enable
  Client Isolation: Enable

Step 3: Workstation & Dashboard Display Setup

Deploy the Dell OptiPlex 7020 Micro in the revenue office. Connect both Dell P2425H monitors via DisplayPort. Install Windows 11 Pro, join to client's domain or Entra ID (if M365 is in use), install Chrome, Microsoft Edge, Power BI Desktop, and Microsoft 365 apps. Enroll the iPad Air in Apple Business Manager or manually configure it with Power BI mobile app, RoomPriceGenie app (if available), and Lighthouse web shortcut.

winget install Microsoft.PowerBIDesktop
winget install Google.Chrome
winget install Microsoft.Office

Step 4: PMS API Access & Credential Provisioning

Work with the hotel's PMS vendor to enable API access for third-party integrations. Obtain API keys or OAuth credentials for RoomPriceGenie and Lighthouse. For Cloudbeds, generate API tokens in the Cloudbeds admin panel under Integrations > API. For Mews, generate a Client Token in Mews Commander under Settings > Integrations. Document all credentials in the MSP's password vault (e.g., IT Glue, Hudu, or Bitwarden).

# Test API connectivity:
curl -X GET 'https://hotels.cloudbeds.com/api/v1.1/getRooms' \
  -H 'Authorization: Bearer YOUR_API_TOKEN' \
  -H 'Content-Type: application/json'
# Expected: HTTP 200 with JSON room list

# Mews Connector API test:
curl -X POST 'https://api.mews.com/api/connector/v1/configuration/get' \
  -H 'Content-Type: application/json' \
  -d '{"ClientToken":"YOUR_CLIENT_TOKEN","AccessToken":"YOUR_ACCESS_TOKEN","Client":"MSP Integration"}'

Step 5: RoomPriceGenie Account Setup & PMS Integration

Create the RoomPriceGenie account for the property. Select the Advanced plan (€179/mo) for full features including competitor rate integration and multi-room-type support. Connect RoomPriceGenie to the PMS using the integration wizard. Configure room types to match PMS room categories exactly. Set initial pricing parameters: minimum rate (floor), maximum rate (ceiling), and base rate per room type as guided by hotel management.

Step 6: Lighthouse Rate Insight Setup & Competitor Configuration

Provision the Lighthouse Rate Insight account for the property. Configure the primary competitive set (comp set) with 5–10 hotels identified during discovery. Enable the AI-powered Smart Compset feature to discover additional competitors the hotel may not have considered. Set up rate alert thresholds for significant competitor rate changes. Configure the look-ahead window (typically 90–365 days forward).

Step 7: STR Subscription Activation & Comp Set Registration

Register the property with STR (CoStar Group) for the Trend Report subscription. This requires submitting the hotel's actual performance data (occupancy, ADR, revenue) monthly in exchange for receiving anonymized competitive set benchmarking data. Work with hotel management to define the STR comp set (must be approved by STR and typically includes 5–8 properties within the same market and class).

Step 8: Zapier Automation Workflows Configuration

Configure Zapier automations to bridge data between platforms that lack direct integrations and to create alert/notification workflows. Set up three core Zaps: (1) Lighthouse rate alert → Microsoft Teams channel notification, (2) RoomPriceGenie daily rate recommendation summary → email to GM, (3) PMS daily stats → Google Sheets staging for Power BI ingestion.

Zap 1: Lighthouse Rate Alert → Microsoft Teams Notification

Zap 2: Daily Rate Recommendation Email

Zap 3: PMS Daily Stats → Google Sheets

Step 9: Power BI RevPAR Analytics Dashboard Development

Build a custom Power BI dashboard that consolidates data from Google Sheets (PMS daily stats via Zapier), RoomPriceGenie export data, and Lighthouse export data into a unified RevPAR trend analysis view. The dashboard includes: (1) RevPAR trend line (daily/weekly/monthly), (2) ADR and Occupancy decomposition, (3) Competitor rate positioning heatmap, (4) Pace report (bookings on-the-books vs. same time last year), (5) Day-of-week and seasonality analysis.

-- Date Dimension Table
Date_Dim = CALENDAR(DATE(2024,1,1), DATE(2025,12,31))
-- Add columns: Year, Month, MonthName, WeekOfYear, DayOfWeek, DayName, IsWeekend

-- DAX Measures
RevPAR = DIVIDE([Total_Revenue], [Total_Rooms_Available])
ADR = DIVIDE([Total_Revenue], [Total_Rooms_Sold])
Occupancy = DIVIDE([Total_Rooms_Sold], [Total_Rooms_Available])
RevPAR_YoY_Change = ([RevPAR] - [RevPAR_SPLY]) / [RevPAR_SPLY]
RevPAR_Index = DIVIDE([My_RevPAR], [CompSet_Avg_RevPAR]) * 100

Step 10: Shadow Testing Period (Weeks 4–6)

Run all systems in parallel for 2–3 weeks without automated rate pushes. RoomPriceGenie operates in 'Suggest Only' mode. Each morning, the revenue manager reviews AI-recommended rates against their own judgment and Lighthouse competitor data. The MSP tracks recommendation accuracy: percentage of AI recommendations the revenue manager agrees with, cases where the human overrode the AI (and why), and actual booking performance. Calibrate min/max rates and sensitivity settings based on feedback.

Step 11: Go-Live: Enable Automated Rate Pushing

After successful shadow testing with 80%+ recommendation acceptance rate, enable RoomPriceGenie's automated rate push mode. Rates will now flow automatically: RoomPriceGenie AI → PMS → Channel Manager → OTAs (Booking.com, Expedia, etc.) and Booking Engine. Configure guardrails: rate change frequency limits, maximum single-day rate change percentage, and blackout dates for special events where manual control is needed.

Step 12: Client Training & Documentation Delivery

Conduct a 2-hour on-site or video training session with the revenue manager and GM. Cover: (1) RoomPriceGenie daily workflow — how to review recommendations, override rates, set blackout dates, (2) Lighthouse Rate Insight — how to read competitor rate grids, set alerts, analyze trends, (3) Power BI dashboard — how to navigate pages, filter by date range, interpret KPIs, access on iPad, (4) Escalation procedures — when to contact the MSP vs. vendor support. Deliver a branded SOP document and quick-reference cards.

• Training agenda:
• 09:00–09:30 — RoomPriceGenie walkthrough (live on hotel's account)
• 09:30–10:00 — Lighthouse Rate Insight walkthrough
• 10:00–10:15 — Break
• 10:15–10:45 — Power BI dashboard deep-dive
• 10:45–11:00 — Q&A, escalation procedures, next steps

Custom AI Components

RevPAR Anomaly Detection Alert System

Type: workflow

A Power Automate workflow that monitors the daily RevPAR data flowing into Google Sheets (via the Zapier automation in Step 8) and triggers alerts when RevPAR deviates significantly from expected values based on historical patterns. This catches issues like sudden occupancy drops (possible integration failure), abnormal ADR spikes (possible rate push error), or competitive displacement events early. It supplements vendor-native alerts with MSP-controlled monitoring.

Implementation

Power Automate Cloud Flow: RevPAR Anomaly Detection — Trigger: Recurrence, Daily at 8:00 AM

revpar_yoy_change = (yesterday_revpar - sply_revpar) / sply_revpar
revpar_vs_30d_avg = (yesterday_revpar - avg_revpar_30d) / avg_revpar_30d

Step 5 — YES branch (anomaly detected):

• Action: Send Teams Message to 'Revenue Alerts' channel
• Action: Send Email to MSP technician + hotel revenue manager

'⚠️ RevPAR Anomaly Detected\n'
+ 'Date: ' + yesterday_date + '\n'
+ 'RevPAR: $' + yesterday_revpar + '\n'
+ '30-Day Avg: $' + avg_revpar_30d + ' (Variance: ' + revpar_vs_30d_avg_pct + '%)\n'
+ 'Same Day Last Year: $' + sply_revpar + ' (YoY: ' + revpar_yoy_change_pct + '%)\n'
+ 'Occupancy: ' + yesterday_occ + '% | ADR: $' + yesterday_adr + '\n'
+ 'Action Required: Review RoomPriceGenie and Lighthouse for potential issues.'

Step 5 — NO branch (no anomaly):

• Action: (optional) Log 'Normal' status to tracking sheet

Anomaly Thresholds (configurable)

• RevPAR deviation from 30-day rolling average: ±25%
• RevPAR YoY change: ±35%
• Occupancy below 30% on a non-holiday weekday: alert
• ADR above max rate ceiling: alert (possible system error)

Weekly Revenue Intelligence Digest Generator

Type: prompt

A GPT-4-powered prompt template that generates a weekly narrative revenue intelligence summary for the hotel GM and ownership. It takes structured data inputs (RevPAR, ADR, occupancy, competitor rates, booking pace) and produces a human-readable executive brief with insights and recommended actions. This is delivered via email every Monday morning and forms the basis of the MSP's monthly revenue consulting service.

Implementation

# System Prompt for Weekly Revenue Intelligence Digest
# Model: GPT-4 (via OpenAI API or Microsoft Copilot)
# Deployment: Power Automate flow triggered every Monday at 6:00 AM
# Input: Structured JSON data from Google Sheets + Lighthouse exports

SYSTEM_PROMPT = """
You are an expert hotel revenue management analyst. Your task is to generate a concise, actionable weekly revenue intelligence digest for a hotel's general manager and ownership group.

You will receive structured performance data for the past week and comparison periods. Analyze the data and produce a professional report following this exact structure:

Weekly Revenue Intelligence Digest — [Hotel Name]

Week of [Date Range]

Executive Summary (2-3 sentences: Overall performance assessment — was it a good week or bad week and why?)

Key Performance Indicators

• RevPAR: This Week $XXX | Last Week $XXX | Same Week LY $XXX | Trend ↑/↓/→
• ADR: This Week $XXX | Last Week $XXX | Same Week LY $XXX | Trend ↑/↓/→
• Occupancy: This Week XX% | Last Week XX% | Same Week LY XX% | Trend ↑/↓/→
• RevPAR Index: This Week XXX | Last Week XXX | Same Week LY XXX | Trend ↑/↓/→

Competitor Intelligence (Top 3 observations about competitor rate movements from Lighthouse data. Were competitors raising or lowering rates? Any new competitors appearing?)

Booking Pace Analysis (Are forward bookings ahead or behind the same time last year? Which dates in the next 30/60/90 days need attention?)

Recommended Actions (3-5 specific, actionable recommendations. Examples: 'Raise weekend rates by $15 for the next 3 weekends — competitor rates have increased and occupancy pace is strong' or 'Investigate the drop in Wednesday occupancy — consider midweek packages')

Risks & Opportunities (Any upcoming events, holidays, weather forecasts, or market changes that could impact next week's performance)

Rules

• Use the hotel's actual data provided, never fabricate numbers
• Keep the tone professional but accessible — the GM is not a data scientist
• Always explain the 'so what' — don't just state numbers, explain what they mean
• Recommendations must be specific: include dollar amounts, date ranges, and room types
• If RevPAR Index is below 100, flag this prominently — it means the hotel is underperforming the comp set
• Limit to 500-700 words total

USER_PROMPT_TEMPLATE

Generate the Weekly Revenue Intelligence Digest for {hotel_name} for the week of {week_start} to {week_end}.

Performance Data:
{performance_json}

Competitor Rate Data (from Lighthouse):
{competitor_json}

Forward Booking Pace (next 90 days):
{pace_json}

Local Events & Notes:
{events_notes}

Power Automate Implementation

{
  "url": "https://api.openai.com/v1/chat/completions",
  "headers": {
    "Authorization": "Bearer {OPENAI_API_KEY}"
  },
  "body": {
    "model": "gpt-4",
    "messages": [
      { "role": "system", "content": "SYSTEM_PROMPT" },
      { "role": "user", "content": "formatted_USER_PROMPT" }
    ],
    "temperature": 0.3,
    "max_tokens": 1500
  }
}

• Estimated OpenAI API cost: ~$0.05-0.10 per weekly digest (GPT-4 input/output tokens)
• Annual cost: ~$3-5 per property per year for AI generation

Competitor Rate Change Tracker & Trend Analyzer

Type: integration

A Python-based data pipeline that runs daily as an Azure Function (or local scheduled task) to export Lighthouse Rate Insight data, calculate competitor rate change trends over 7/14/30/90 day windows, detect patterns like consistent undercutting or rate convergence, and append results to the Power BI dataset for visualization on the competitor analysis dashboard page.

Implementation

# Core pipeline: loads Lighthouse exports, calculates multi-window rate
# trends, detects competitive patterns, and pushes results to Google
# Sheets/Power BI

# competitor_rate_tracker.py
# Deployment: Azure Function (Timer Trigger) or Windows Task Scheduler on hotel workstation
# Schedule: Daily at 11:30 PM
# Dependencies: pip install pandas requests openpyxl

import pandas as pd
import requests
import json
import os
from datetime import datetime, timedelta

# Configuration
LIGHTHOUSE_EXPORT_PATH = os.getenv('LIGHTHOUSE_EXPORT_PATH', './data/lighthouse_exports/')
OUTPUT_PATH = os.getenv('OUTPUT_PATH', './data/competitor_trends/')
GOOGLE_SHEETS_WEBHOOK = os.getenv('ZAPIER_WEBHOOK_URL')  # Zapier webhook to append to Google Sheets
HOTEL_NAME = os.getenv('HOTEL_NAME', 'Client Hotel')

def load_latest_lighthouse_export():
    """Load the most recent Lighthouse Rate Insight CSV/Excel export.
    Lighthouse allows manual or scheduled exports of competitor rate data.
    Expected columns: date, competitor_name, room_type, rate, source_ota"""
    import glob
    files = glob.glob(f'{LIGHTHOUSE_EXPORT_PATH}/*.csv')
    if not files:
        files = glob.glob(f'{LIGHTHOUSE_EXPORT_PATH}/*.xlsx')
    latest_file = max(files, key=os.path.getctime)
    if latest_file.endswith('.csv'):
        return pd.read_csv(latest_file)
    else:
        return pd.read_excel(latest_file)

def calculate_rate_trends(df):
    """Calculate rate change trends per competitor over multiple windows."""
    today = datetime.now().date()
    results = []
    
    for competitor in df['competitor_name'].unique():
        comp_data = df[df['competitor_name'] == competitor].copy()
        comp_data['date'] = pd.to_datetime(comp_data['date']).dt.date
        comp_data = comp_data.sort_values('date')
        
        for window_days in [7, 14, 30, 90]:
            window_start = today - timedelta(days=window_days)
            window_data = comp_data[(comp_data['date'] >= window_start) & (comp_data['date'] <= today)]
            
            if len(window_data) < 2:
                continue
            
            avg_rate = window_data['rate'].mean()
            rate_start = window_data.iloc[0]['rate']
            rate_end = window_data.iloc[-1]['rate']
            rate_change_pct = ((rate_end - rate_start) / rate_start) * 100 if rate_start > 0 else 0
            rate_volatility = window_data['rate'].std()
            
            results.append({
                'analysis_date': today.isoformat(),
                'competitor_name': competitor,
                'window_days': window_days,
                'avg_rate': round(avg_rate, 2),
                'rate_start': round(rate_start, 2),
                'rate_end': round(rate_end, 2),
                'rate_change_pct': round(rate_change_pct, 2),
                'rate_volatility': round(rate_volatility, 2),
                'trend_direction': 'UP' if rate_change_pct > 2 else ('DOWN' if rate_change_pct < -2 else 'STABLE'),
                'data_points': len(window_data)
            })
    
    return pd.DataFrame(results)

def detect_patterns(trends_df):
    """Detect notable competitive patterns for alerting."""
    alerts = []
    today = datetime.now().date().isoformat()
    
    # Pattern 1: Competitor consistently undercutting (30-day window, rate decreasing)
    undercut_comps = trends_df[
        (trends_df['window_days'] == 30) & 
        (trends_df['rate_change_pct'] < -10)
    ]
    for _, row in undercut_comps.iterrows():
        alerts.append({
            'date': today,
            'alert_type': 'COMPETITOR_UNDERCUTTING',
            'competitor': row['competitor_name'],
            'detail': f"{row['competitor_name']} has dropped rates by {abs(row['rate_change_pct'])}% over the last 30 days (from ${row['rate_start']} to ${row['rate_end']})",
            'severity': 'HIGH'
        })
    
    # Pattern 2: Market-wide rate increase (>5% avg across all competitors in 14-day window)
    market_14d = trends_df[trends_df['window_days'] == 14]
    if len(market_14d) > 0:
        avg_market_change = market_14d['rate_change_pct'].mean()
        if avg_market_change > 5:
            alerts.append({
                'date': today,
                'alert_type': 'MARKET_RATE_INCREASE',
                'competitor': 'ALL',
                'detail': f"Market-wide rate increase detected: average {round(avg_market_change, 1)}% increase across all competitors in the last 14 days. Consider raising rates.",
                'severity': 'MEDIUM'
            })
    
    # Pattern 3: High volatility competitor (std dev > 20% of mean)
    volatile_comps = trends_df[
        (trends_df['window_days'] == 30) & 
        (trends_df['rate_volatility'] > trends_df['avg_rate'] * 0.20)
    ]
    for _, row in volatile_comps.iterrows():
        alerts.append({
            'date': today,
            'alert_type': 'HIGH_VOLATILITY',
            'competitor': row['competitor_name'],
            'detail': f"{row['competitor_name']} shows high rate volatility (std dev: ${row['rate_volatility']}) — they may be using aggressive dynamic pricing",
            'severity': 'LOW'
        })
    
    return alerts

def push_to_google_sheets(trends_df, alerts):
    """Send data to Google Sheets via Zapier webhook for Power BI consumption."""
    if GOOGLE_SHEETS_WEBHOOK:
        for _, row in trends_df.iterrows():
            requests.post(GOOGLE_SHEETS_WEBHOOK, json=row.to_dict())
        
        for alert in alerts:
            requests.post(GOOGLE_SHEETS_WEBHOOK, json=alert)

def main():
    print(f'[{datetime.now()}] Starting competitor rate trend analysis...')
    
    # Load data
    df = load_latest_lighthouse_export()
    print(f'Loaded {len(df)} rate records for {df["competitor_name"].nunique()} competitors')
    
    # Calculate trends
    trends = calculate_rate_trends(df)
    print(f'Calculated {len(trends)} trend data points')
    
    # Detect patterns
    alerts = detect_patterns(trends)
    print(f'Generated {len(alerts)} alerts')
    
    # Export locally
    today_str = datetime.now().strftime('%Y%m%d')
    trends.to_csv(f'{OUTPUT_PATH}/competitor_trends_{today_str}.csv', index=False)
    
    if alerts:
        alerts_df = pd.DataFrame(alerts)
        alerts_df.to_csv(f'{OUTPUT_PATH}/competitor_alerts_{today_str}.csv', index=False)
        print('ALERTS:')
        for alert in alerts:
            print(f"  [{alert['severity']}] {alert['detail']}")
    
    # Push to Google Sheets / Power BI pipeline
    push_to_google_sheets(trends, alerts)
    
    print(f'[{datetime.now()}] Analysis complete.')

if __name__ == '__main__':
    main()

Deployment: Azure Function

func azure functionapp publish <APP_NAME>

Deployment: Windows Scheduled Task (simpler for single-property)

schtasks /create /tn "CompetitorRateTrends" /tr "python C:\RevIntel\competitor_rate_tracker.py" /sc daily /st 23:30

Rate Parity Monitor

Type: agent

An automated monitoring agent that checks rate parity across the hotel's distribution channels (direct booking engine, Booking.com, Expedia) to ensure that automated rate pushes from RoomPriceGenie are reaching all channels correctly and that no channel has stale or incorrect rates. Rate parity violations can lead to OTA penalties and lost direct booking revenue.

Implementation:

# A lightweight monitoring agent that verifies rate consistency across
# channels. Deployment: Runs as a scheduled script every 6 hours on the
# hotel workstation or as an Azure Function. Dependencies: pip install
# requests beautifulsoup4 selenium

import requests
import json
import os
from datetime import datetime, timedelta

# Configuration
PMS_API_BASE = os.getenv('PMS_API_BASE')  # e.g., https://hotels.cloudbeds.com/api/v1.1
PMS_API_TOKEN = os.getenv('PMS_API_TOKEN')
ALERT_WEBHOOK = os.getenv('TEAMS_WEBHOOK_URL')  # Microsoft Teams incoming webhook
PARITY_THRESHOLD = 2.00  # Maximum acceptable rate difference in dollars
CHECK_DATES_FORWARD = 14  # Check rates for next 14 days

def get_pms_rates(check_date):
    """Fetch rates from PMS API for a given date."""
    headers = {'Authorization': f'Bearer {PMS_API_TOKEN}'}
    response = requests.get(
        f'{PMS_API_BASE}/getRates',
        headers=headers,
        params={'date': check_date.strftime('%Y-%m-%d')}
    )
    if response.status_code == 200:
        return response.json().get('data', [])
    return None

def get_booking_engine_rates(check_date, property_url):
    """Check rates on the hotel's direct booking engine.
    Implementation varies by booking engine provider.
    This is a template — adapt for the specific booking engine API."""
    # Many booking engines provide an API or embeddable widget that returns rates
    # For Cloudbeds booking engine:
    response = requests.get(
        f'{property_url}/api/availability',
        params={
            'checkin': check_date.strftime('%Y-%m-%d'),
            'checkout': (check_date + timedelta(days=1)).strftime('%Y-%m-%d'),
            'adults': 2
        }
    )
    if response.status_code == 200:
        return response.json()
    return None

def check_parity(pms_rate, channel_rate, channel_name, room_type, check_date):
    """Compare rates and return an alert if parity is violated."""
    if pms_rate is None or channel_rate is None:
        return {
            'date': check_date.strftime('%Y-%m-%d'),
            'room_type': room_type,
            'channel': channel_name,
            'status': 'DATA_MISSING',
            'pms_rate': pms_rate,
            'channel_rate': channel_rate,
            'difference': None,
            'severity': 'WARNING'
        }
    
    diff = abs(float(pms_rate) - float(channel_rate))
    if diff > PARITY_THRESHOLD:
        return {
            'date': check_date.strftime('%Y-%m-%d'),
            'room_type': room_type,
            'channel': channel_name,
            'status': 'PARITY_VIOLATION',
            'pms_rate': pms_rate,
            'channel_rate': channel_rate,
            'difference': diff,
            'severity': 'HIGH' if diff > 10 else 'MEDIUM'
        }
    return None  # Parity OK

def send_teams_alert(violations):
    """Send parity violation alerts to Microsoft Teams."""
    if not violations or not ALERT_WEBHOOK:
        return
    
    message = {
        '@type': 'MessageCard',
        'summary': f'Rate Parity Alert — {len(violations)} violations detected',
        'themeColor': 'FF0000',
        'title': f'⚠️ Rate Parity Alert — {len(violations)} Violations',
        'sections': [{
            'facts': [
                {'name': f"{v['date']} | {v['room_type']} | {v['channel']}",
                 'value': f"PMS: ${v['pms_rate']} vs Channel: ${v['channel_rate']} (Diff: ${v['difference']})"}
                for v in violations[:10]  # Limit to 10 for readability
            ]
        }],
        'potentialAction': [{
            '@type': 'OpenUri',
            'name': 'Open Channel Manager',
            'targets': [{'os': 'default', 'uri': PMS_API_BASE.replace('/api/v1.1', '')}]
        }]
    }
    
    requests.post(ALERT_WEBHOOK, json=message)

def main():
    print(f'[{datetime.now()}] Starting rate parity check...')
    violations = []
    
    for day_offset in range(CHECK_DATES_FORWARD):
        check_date = datetime.now().date() + timedelta(days=day_offset)
        pms_rates = get_pms_rates(check_date)
        
        if not pms_rates:
            print(f'  Could not fetch PMS rates for {check_date}')
            continue
        
        # Check each room type's rate against known channels
        for room in pms_rates:
            room_type = room.get('roomTypeName', 'Unknown')
            pms_rate = room.get('rate', None)
            
            # Check booking engine
            # be_rates = get_booking_engine_rates(check_date, PROPERTY_URL)
            # violation = check_parity(pms_rate, be_rate, 'Direct Booking Engine', room_type, check_date)
            # if violation: violations.append(violation)
            
            # Note: Checking Booking.com and Expedia rates programmatically
            # requires either their partner APIs (Booking.com Connectivity API,
            # Expedia EPC API) or the channel manager's rate verification endpoint.
            # Adapt this section based on the client's channel manager.
    
    if violations:
        print(f'  ALERT: {len(violations)} parity violations detected!')
        send_teams_alert(violations)
    else:
        print('  All rates in parity. ✓')
    
    print(f'[{datetime.now()}] Parity check complete.')

if __name__ == '__main__':
    main()

Testing & Validation

• NETWORK TEST: Simulate primary WAN failure by disconnecting WAN1 cable from UDM-Pro. Verify that WAN2 failover engages within 30 seconds. Confirm that RoomPriceGenie, Lighthouse, and PMS remain accessible from the revenue workstation. Reconnect WAN1 and verify failback. Document failover time.
• PMS API TEST: Execute a GET request to the PMS API endpoint from the revenue workstation using curl or Postman. Verify HTTP 200 response with valid JSON containing room types, current rates, and availability data.
• ROOMPRICEGENIE INTEGRATION TEST: In RoomPriceGenie dashboard, navigate to the Integration Status page and verify green checkmarks for PMS connection and Channel Manager connection. Trigger a manual rate recommendation refresh and verify that rates appear for all configured room types for the next 365 days. Confirm that 'Suggest Only' mode is active.
• RATE PUSH END-TO-END TEST: In RoomPriceGenie, manually approve a rate change for one room type for a date 30+ days in the future. Within 15 minutes, verify the new rate appears in: (1) the PMS rate calendar, (2) the channel manager outbound queue, (3) Booking.com extranet (Partner Hub), and (4) Expedia Partner Central. If any channel shows the old rate after 60 minutes, investigate the channel manager sync.
• LIGHTHOUSE DATA VERIFICATION: Login to Lighthouse Rate Insight and verify that competitor rate data is populating for all 5–10 configured competitors. Check that rates appear for check-in dates across the next 90 days. Verify that at least 3 OTA sources (Booking.com, Expedia, Google Hotels) show data for each competitor. If any competitor shows 'No data', verify the property mapping is correct.
• POWER BI DASHBOARD VALIDATION: Open the Power BI dashboard on the revenue workstation. Verify that: (1) RevPAR trend chart shows at least 30 days of historical data, (2) ADR and Occupancy metrics match the PMS reports for the same period (cross-reference manually for 3 random dates), (3) Competitor rate data from Lighthouse appears on the competitor analysis page, (4) All filters (date range, room type, day of week) function correctly.
• POWER BI MOBILE TEST: Open the Power BI app on the iPad Air. Navigate to the hotel's workspace and open the RevPAR dashboard. Verify all pages render correctly in mobile layout. Test landscape and portrait orientations. Confirm that the GM can access the dashboard with their Power BI Pro credentials.
• ZAPIER AUTOMATION TEST: Manually trigger each Zap and verify: (1) Lighthouse rate alert webhook → Teams message appears in the Revenue Alerts channel within 2 minutes, (2) Daily rate recommendation email arrives in the GM's inbox with correctly formatted data, (3) PMS daily stats are appended as a new row in the Google Sheets Hotel_Daily_Performance_Log with correct date and values.
• ANOMALY DETECTION TEST: Insert a deliberately anomalous RevPAR value into the Google Sheets log (e.g., set yesterday's RevPAR to $10 when the 30-day average is $120). Run the Power Automate anomaly detection flow manually. Verify that an alert is sent to both the Teams channel and email with the correct anomaly details and that the severity is marked appropriately.
• UPS FAILOVER TEST: Unplug the UPS from wall power. Verify the UDM-Pro, switch, and modem continue operating on battery. Check the APC UPS LCD display for estimated remaining runtime (should show 15+ minutes minimum). Verify the UPS sends an SNMP or email alert for power loss (if configured). Restore wall power and verify normal operation resumes.
• SHADOW TESTING ACCEPTANCE RATE: After 2 weeks of shadow testing, calculate the acceptance rate: (number of AI recommendations accepted without override) / (total recommendations reviewed) × 100. Target is 80%+. If below 70%, flag for RoomPriceGenie calibration. Document the top 3 reasons for overrides.
• SECURITY & COMPLIANCE TEST: Verify VLAN segmentation by attempting to ping the revenue workstation (VLAN 10) from a device on the guest WiFi (VLAN 20) — ping should fail / time out. Verify that PMS API credentials are stored only in the MSP password vault and not in any plaintext configuration files on the workstation. Confirm Windows auto-lock is set to 5 minutes.

# expected response includes room type IDs and names with HTTP 200 status

curl -X GET 'https://hotels.cloudbeds.com/api/v1.1/getRooms' -H 'Authorization: Bearer TOKEN'

Client Handoff

The client handoff should be a structured 2-hour session (on-site preferred, video acceptable) with both the revenue decision-maker (Revenue Manager or GM) and the hotel's IT contact (if any). Cover the following:

1. Platform Walkthrough (45 minutes)

• RoomPriceGenie: Daily login routine, reviewing rate recommendations, how to override a rate, how to set blackout dates for events/renovations, how to adjust min/max rate guardrails, how to switch between Suggest Only and Auto modes.
• Lighthouse Rate Insight: Reading the rate grid, filtering by competitor/date/OTA, understanding the Smart Compset, setting up personal rate alerts, exporting data for ad-hoc analysis.
• Power BI Dashboard: Navigating between pages (Executive Summary, Trends, Competitors, Pace), using date range filters, understanding each KPI, accessing on iPad, and interpreting the Weekly Revenue Intelligence Digest email.

2. Standard Operating Procedures (30 minutes)

• Walk through the printed/PDF SOP document that covers daily, weekly, and monthly revenue management tasks.
• Daily (5 min): Review RoomPriceGenie recommendations at 8 AM, check Lighthouse for competitor changes, review Power BI pace report.
• Weekly (15 min): Review the Monday AI-generated revenue digest email, adjust strategy for upcoming week.
• Monthly (30 min): Review STR Trend Report when received, compare RevPAR Index to goals, attend MSP monthly review call.

3. Escalation & Support (15 minutes)

• Tier 1 (hotel handles): Rate override decisions, blackout date management, reviewing dashboards.
• Tier 2 (contact MSP): Integration errors (rates not pushing to OTAs), Power BI data not refreshing, Zapier automation failures, network connectivity issues.
• Tier 3 (MSP escalates to vendor): RoomPriceGenie AI calibration issues, Lighthouse data gaps, PMS API changes.
• Provide MSP support contact card: email, phone, portal URL, SLA response times.

4. Success Criteria Review (15 minutes)

• Confirm RevPAR baseline has been established (trailing 30/60/90 day averages documented).
• Set target goals: RevPAR improvement target (typically 10–15% within 90 days), occupancy targets, ADR targets.
• Schedule the first monthly review call (30 days post-go-live).
• Confirm all login credentials are in the hotel's password manager.

5. Documentation Deliverables

Maintenance

Ongoing MSP Responsibilities & Maintenance Schedule:

Daily (Automated — 5 minutes MSP review)

• Monitor RevPAR anomaly detection alerts in Teams channel. Investigate any HIGH severity alerts within 2 hours.
• Monitor rate parity agent alerts. Investigate any parity violations > $5 within 4 hours.
• Verify Zapier automation task logs — confirm all 3 Zaps ran successfully overnight.

Weekly (30 minutes)

• Review the AI-generated Weekly Revenue Intelligence Digest before it's sent to the client. Spot-check data accuracy.
• Check Power BI scheduled refresh logs — confirm data is current.
• Review UDM-Pro WAN uptime statistics — flag any failover events to the client.
• Check RoomPriceGenie integration status page for any sync warnings.

Monthly (2–3 hours)

• Conduct a 30-minute monthly revenue review call with the hotel GM/revenue manager. Review: RevPAR trend vs. baseline, ADR and occupancy decomposition, competitor positioning changes, AI recommendation acceptance rate, upcoming events/seasons requiring strategy adjustments.
• Update Power BI dashboard if new data sources or visualizations are requested.
• Review and update RoomPriceGenie min/max rate guardrails for the upcoming season (quarterly at minimum).
• Review Lighthouse comp set — add or remove competitors as market changes.
• Apply firmware updates to UDM-Pro and USW-24-PoE (schedule during low-occupancy periods, typically Tuesday 2–4 AM).
• Review Zapier task usage — ensure Professional plan allocation is not exceeded.

Quarterly (4–6 hours)

• Comprehensive platform audit: verify all integrations are healthy, API tokens are not expiring, PMS version is still compatible.
• Review STR competitive set relevance — propose changes if new hotels have entered the market.
• Power BI dashboard refresh: update DAX measures if business logic changes, refresh date dimension table for new year.
• Security review: rotate API tokens, verify VLAN segmentation, confirm PCI DSS compliance posture.
• Prepare a Quarterly Business Review (QBR) deck showing: total RevPAR improvement since implementation, ROI calculation (revenue increase vs. platform costs + MSP fees), competitive positioning trends, recommendations for next quarter.

Annual

• Renegotiate vendor subscriptions (RoomPriceGenie, Lighthouse, STR) — check for annual prepay discounts.
• Evaluate whether to upgrade from RoomPriceGenie to IDeaS or Duetto if the property has grown or added rooms.
• Full network hardware lifecycle review — UDM-Pro and switch warranty status, UPS battery health test.
• Update all SOPs and training documentation for any platform UI changes.

SLA Considerations

• MSP response time for integration-down alerts (rates not pushing to OTAs): 1-hour response, 4-hour resolution during business hours.
• MSP response time for dashboard/reporting issues: 4-hour response, next-business-day resolution.
• Network infrastructure issues (WAN down, both links): 30-minute response, on-site within 2 hours if remote resolution fails.
• Vendor escalation SLAs: RoomPriceGenie support typically responds within 24 hours; Lighthouse within 24–48 hours; PMS vendor varies.

Model Retraining / AI Calibration Triggers

• RoomPriceGenie AI recalibration recommended when: acceptance rate drops below 75%, after major property renovation (room count or category change), after significant market disruption (new competitor opens, major event venue closes), or at the start of each peak/off-peak season transition.
• Lighthouse Smart Compset should be re-evaluated quarterly or when booking patterns shift significantly.

Alternatives

PriceLabs Instead of RoomPriceGenie

PriceLabs offers a lower-cost entry point at $19.99/listing/month (US/UK/EU) compared to RoomPriceGenie's €119–€179/month. PriceLabs supports 150+ PMS integrations and offers a built-in Market Dashboard with competitive rate data from Booking.com. Founded in 2014, it prices over 500,000 units across 150+ countries.

Tradeoffs

• Cost: Significantly cheaper (~$20/month vs. ~$195/month for a standard hotel with one listing per room type). However, PriceLabs' per-listing pricing can become expensive for hotels with many room types.
• Capability: PriceLabs originated in the vacation rental market and its UI reflects this — it's less intuitive for traditional hoteliers. The built-in competitor data from PriceLabs Market Dashboard is less comprehensive than Lighthouse Rate Insight (pulls only from Booking.com public data vs. Lighthouse's 16.4 billion daily data points across all OTAs).
• Recommend PriceLabs when: the client is a small independent property (under 20 rooms), is extremely cost-sensitive, or operates a mixed hotel + vacation rental portfolio.

happyhotel for Budget-Conscious Properties

happyhotel offers AI-driven revenue management at just €5 per hotel room per month for the yielding tool, with free analytics from PMS data. This makes it the lowest-cost entry point for small hotels wanting to move from manual spreadsheet-based pricing to AI-assisted dynamic pricing.

• Cost: Dramatically cheaper (a 30-room hotel pays just €150/month vs. €179/month for RoomPriceGenie).
• Capability: happyhotel has a smaller integration ecosystem and less market coverage than RoomPriceGenie or PriceLabs. The AI pricing engine is less mature with fewer data inputs.
• Best for: Very small properties (10–30 rooms) in secondary markets who are making the first jump from manual pricing. The MSP can use this as a 'land' strategy and upgrade to RoomPriceGenie as the hotel sees ROI.

IDeaS G3 RMS for Enterprise/Multi-Property

IDeaS G3 RMS is the global leader in AI-driven revenue management, powered by SAS High-Performance Analytics. It provides scientific pricing, forecasting, and rate availability decisions at the room type and rate code level. Custom pricing typically ranges from $3–$10/room/month. Best for properties with 150+ rooms or multi-property hotel groups.

Tradeoffs

• Cost: Higher total cost ($450–$1,500/month for a 150-room property vs. $195/month for RoomPriceGenie) plus implementation fees of $5,000–$20,000.
• Complexity: Requires significantly more implementation time (12–16 weeks vs. 6–8 weeks) and ongoing calibration by a trained revenue management professional.
• Capability: Far more sophisticated forecasting and optimization — considers group business, function space, F&B revenue — making it suitable for full-service hotels and resorts.
• Recommend when: the client is a full-service hotel with 150+ rooms, has a dedicated revenue manager, or is part of a multi-property management company. The MSP should partner with an IDeaS certified implementation partner for deployment.

Duetto GameChanger for Luxury/Casino Properties

Duetto is rated the #1 overall RMS and is best known for its Open Pricing methodology, which prices each segment, channel, and room type independently rather than using fixed BAR pricing. Enterprise-tier with custom pricing. Dominant in luxury chains and casino/resort properties.

Tradeoffs

• Cost: Enterprise pricing — typically $2,000–$5,000+/month for a single luxury property.
• Complexity: Most complex implementation (16–24 weeks), requires dedicated revenue management expertise and Duetto certification. The MSP would need to partner with a Duetto implementation consultant.
• Capability: Most advanced dynamic pricing — handles complex revenue streams (casino, spa, F&B, event space) and multi-property portfolio optimization.
• Recommend when: the client is a luxury resort, casino hotel, or large multi-property group where the ROI of a 1–2% RevPAR improvement justifies the premium investment.

Lighthouse Only (No RMS) for Phase 1

Deploy only Lighthouse Rate Insight for competitor rate intelligence without an automated RMS. The hotel continues to set rates manually but now has data-driven visibility into competitor pricing. This is a lower-risk, lower-cost entry point that builds trust before adding AI-driven automated pricing.

• Cost: $150–$300/month for Lighthouse alone vs. $350–$500/month for Lighthouse + RoomPriceGenie.
• Complexity: Much simpler implementation (2–3 weeks) with no PMS integration required for Lighthouse's core rate shopping functionality.
• Capability: No automated pricing — the hotel still sets rates manually, just with better data. RevPAR improvement is likely 3–5% vs. 10–20% with full RMS.
• Recommend when: hotel management is skeptical of AI pricing, when the PMS lacks API access for RMS integration, or as a Phase 1 trust-building step before Phase 2 RMS deployment.
• The MSP can upsell the full solution in 3–6 months once the hotel sees the value of competitive intelligence.

Open-Source Analytics Stack (Metabase + Python)

Replace Power BI with the open-source Metabase BI tool and build custom Python analytics scripts for RevPAR trending and competitor analysis. Eliminates Microsoft Power BI Pro license costs and provides more customization flexibility. Deployed as Docker containers on a small cloud VM (e.g., DigitalOcean Droplet at $12/month).

Tradeoffs

• Cost: Saves $20–$30/month in Power BI licenses but adds $12–$24/month in cloud hosting. Net savings are minimal.
• Complexity: Significantly higher — requires MSP to have Python and Docker expertise, ongoing maintenance of custom code, and Metabase administration. No mobile app as polished as Power BI's.
• Capability: More flexible for custom analytics but requires much more MSP development time (20–40 additional hours).
• Recommend only when: the MSP has strong Python/Docker skills in-house, the client has specific analytics requirements that Power BI cannot meet, or when the client refuses Microsoft licensing for policy reasons.