Ai In Hospitality | AI Final Year Project Report

Complete Technical Paper Content — Ai In Hospitality

1. Executive Abstract, Problem Formulation & Background

Hotel Intelligence Platform End-to-end AI/ML platform for hospitality analytics — from predictive models to conversational AI Overview A comprehensive AI/ML platform designed for hotel chains, covering the full data science lifecycle. The platform processes 119,390 bookings , 12,000 customers , and 3,000 reviews through four integrated modules — delivering actionable business insights with a production-ready architecture. Key Results Metric Value Cancellation Prediction AUC-ROC 0.9465 (XGBoost) Estimated Annual Revenue Impact EUR 13.9M+ Invoice Classification (ML) 100.0% (TF-IDF + LogReg) Invoice Classification (Rule-Based) 92.65% (79K rows/sec) Master Item Match Rate 96.08% (4-layer hybrid pipeline) Sentiment Analysis (ML) 100.0% (GradientBoosting) Customer Lifetime Value 7,993 customers scored (mean USD 1,742) CLTV Segments 4 (Low, Medium, High, VIP) Features Engineered 62 ML Models Trained & Compared 5 Languages Supported (UI) 3 (EN/TR/DE) Modules Module 1: Predictive Analytics Booking cancellation prediction, CLTV modeling, and customer segmentation. Cancellation Prediction : 5 models (Logistic Regression, Random Forest, XGBoost, LightGBM, CatBoost) with 62 engineered features. Best: XGBoost with AUC-ROC 0.9465. CLTV Modeling : BG-NBD + Gamma-Gamma probabilistic models for 7,993 customers. Mean 6-month CLTV: USD 1,742.51 (max: USD 19,169.68). RFM Segmentation : Quintile-based scoring — high-value customers (score 5,5) average USD 32,759 vs USD 804 for low-engagement. K-Means Clustering : Behavioral clustering on spending patterns with elbow/silhouette optimization. 4 CLTV segments (~2,000 customers each). SHAP Explainability : Top drivers: country_cancel_rate (1.01), deposit_cancel_rate (0.79), lead_time (0.57). Business Impact : EUR 2,787,144 per test set at optimal threshold (0.3), EUR 13.9M+ estimated annual impact. Module 2: LLM & Unstructured Data Invoice classification, master item cleanup, and sentiment analysis. Invoice Classification : 5-method comparison — Rule-based (92.65%, 79K rows/sec), TF-IDF+LogReg (100%), TF-IDF+RF (100%), LLM Zero-Shot (~89%), LLM Few-Shot (~94%). Master Item Cleanup : 4-layer hybrid pipeline: Exact (100% acc) -> Fuzzy t=82 (93.9%) -> TF-IDF embedding (93.5%) -> Fuzzy t=60 (63.8%). Overall: 89% accuracy, 96.08% match rate. Review Sentiment Analysis : Rule-based (73.8%) + GradientBoosting ML (100%). Aspect-level analysis across 5 dimensions: value (42.3%), food (34.0%), staff (33.3%), location (32.2%), cleanliness (28.6%). Module 3: Conversational AI Natural language to SQL chatbot with auto-visualization. Intent Detection : LLM + rule-based fallback classifying into 5 intents (sql_query, prediction, recommendation, summary, explanation). NL-to-SQL : Schema-aware SQL generation with safety validation (blocks DROP/DELETE/INSERT). Insight Generation : Business context-aware natural language insights from query results. Auto-Visualization : Detects optimal chart type (bar, line, pie, scatter, histogram, metric, table) and generates Plotly figures. LLM Routing : 3-layer pipeline — diskcache -> Groq API (LLaMA 3.3 70B) -> Fallback responses. Module 4: MLOps & Monitoring Experiment tracking, model registry, drift detection, and alerting. MLflow Integration : Experiment tracking with params, metrics, models, feature importance, and dataset metadata. Model Registry : Version management with stage transitions (None -> Staging -> Production -> Archived). Local joblib fallback. Data Drift Detection : PSI (Population Stability Index) + KS test with severity classification (none/warning/critical). Model Performance Monitoring : Rolling AUC/F1 tracking with degradation alerts and retraining triggers. Alert System : 7 configurable threshold-based rules with acknowledge/filter capabilities. Health Score : Unified 0-100 score aggregating data quality, model performance, and system health. Streamlit Dashboard Premium dark-themed dashboard with a vibrant color palette and multi-language support (EN/TR/DE/NO). Home — Platform Overview KPI cards, 4 module navigation, tech stack pills, and architecture diagram. Cancellation Predictor — 5 ML Models + Live Prediction Model comparison table, SHAP feature importance, interactive prediction form with risk gauge, and revenue impact analysis. Customer Intelligence — RFM, CLTV, Clustering RFM segmentation with 6 customer segments, BG-NBD + Gamma-Gamma CLTV modeling, and K-Means behavioral clustering with radar charts. Analytics Chatbot — Natural Language to SQL Ask questions in plain English, get SQL-backed answers with auto-generated visualizations and business insights. Powered by Groq LLaMA 3.3 70B on 119K+ real records. MLOps Monitor — Drift Detection and Alerting Real-time health score, PSI-based data drift analysis, model performance tracking, and threshold-based alert system with 7 configurable rules. All Dashboard Pages Page Description Home Hero section, KPI cards, module overview, architecture diagram, tech stack Cancellation Predictor Model comparison, SHAP feature importance, live prediction form, business impact Customer Intelligence RFM segmentation, CLTV prediction, K-Means clustering with radar charts Invoice Classifier Rule-based vs LLM comparison, accuracy/latency trade-off, live demo Item Cleanup 4-layer pipeline visualization, fuzzy matching demo Review Analyzer Sentiment distribution, aspect radar chart, hotel filters Analytics Chatbot Split layout (chat + visualization), Groq LLM integration MLOps Monitor Health score, PSI drift charts, performance tracking, alert dashboard Kaggle Notebooks Interactive, runnable versions of each module — with full outputs and visualizations: # Notebook Highlights 01 Cancellation Prediction EDA, 62 features, 5 models, SHAP, EUR 13.9M+ business impact 02 Customer Analytics RFM segmentation, BG-NBD + Gamma-Gamma CLTV, K-Means clustering 03 NLP & LLM Pipeline Invoice classification (5 methods), item cleanup, sentiment analysis 04 Platform Overview Full architecture, module results summary, tech stack Quick Start Local Setup # Clone the repository git clone https://github.com/mmehmetisik/hotel-intelligence-platform.git cd hotel-intelligence-platform # Create virtual environment python -m venv venv source venv/bin/activate # Windows: venv\Scripts\activate # Install dependencies pip install --pre -r requirements.txt # Generate synthetic data python data/synthetic/generate_all.py # Initialize chatbot database (creates SQLite from CSV files) python -c " from src.module_3_conversational.database.init_db import initialize_database; initialize_database() " # Run the Streamlit app streamlit run app/main.py Docker docker-compose up --build # App: http://localhost:8501 # MLflow: http://localhost:5000 Environment Variables Create a .env file in the project root: GROQ_API_KEY = your_groq_api_key_here MLFLOW_TRACKING_URI = http://localhost:5000 Project Structure hotel-intelligence-platform/ ├── src/ │ ├── module_1_predictive/ # ML models │ │ ├── cancellation/ # EDA, features, training, evaluation │ │ ├── cltv/ # BG-NBD, Gamma-Gamma, RFM │ │ └── clustering/ # K-Means, feature engineering │ ├── module_2_llm/ # LLM pipelines │ │ ├── invoice_classification/ # Rule-based, LLM, comparison │ │ ├── master_item_cleanup/ # Fuzzy match, hybrid pipeline │ │ └── review_analysis/ # Sentiment, aspect analysis │ ├── module_3_conversational/ # Analytics chatbot │ │ ├── llm/ # Groq client, cache, router │ │ ├── database/ # Schema, SQLite init │ │ └── agents/ # Intent, SQL, insight, chart │ └── module_4_mlops/ # MLOps │ ├── tracking/ # MLflow setup, logger, registry │ ├── monitoring/ # Data drift, model drift, alerts │ └── pipeline/ # Training pipeline ├── app/ # Streamlit dashboard │ ├── main.py # Home page │ ├── theme.py # Premium CSS theme │ ├── i18n.py # EN/TR/DE translations │ ├── components.py # Reusable UI components │ └── pages/ # 7 module pages ├── data/ │ ├── raw/ # Hotel bookings (119K records) │ └── synthetic/ # Generated datasets (6 CSVs) ├── notebooks/ # 4 Kaggle-ready notebooks ├── models/ # Trained models + metadata ├── tests/ # 188+ tests ├── .github/workflows/ci.yml # CI/CD pipeline ├── Dockerfile # Container config ├── docker-compose.yml # Multi-service setup └── requirements.txt # Dependencies Tech Stack Category Technologies ML/DL Scikit-learn, XGBoost, LightGBM, CatBoost, SHAP Statistical BG-NBD, Gamma-Gamma (btyd/lifetimes), SciPy LLM Groq API (LLaMA 3.3 70B), diskcache NLP RapidFuzz, TF-IDF, NLTK Visualization Plotly, Matplotlib, Seaborn Web App Streamlit (multi-page, custom CSS) MLOps MLflow, GitHub Actions CI/CD Database SQLite, SQLAlchemy Infrastructure Docker, Docker Compose Testing pytest (188+ tests), pytest-cov Testing # Run all tests python -m pytest tests/ -v # Run specific module tests python -m pytest tests/test_conversational.py -v # Module 3 python -m pytest tests/test_mlops.py -v # Module 4 # With coverage python -m pytest tests/ --cov=src --cov-report=term-missing Test Coverage: Data quality: 35 tests Cancellation model: 12 tests CLTV pipeline: 8 tests Invoice classifier: 10 tests Conversational AI: 68 tests MLOps: 55 tests Architecture ┌─────────────────────────────────────────────────────────────┐ │ HOTEL INTELLIGENCE PLATFORM │ ├──────────────┬──────────────┬──────────────┬────────────────┤ │ Module 1 │ Module 2 │ Module 3 │ Module 4 │ │ Predictive │ LLM & │ Conversa- │ MLOps & │ │ Analytics │ Unstructured│ tional AI │ Monitoring │ │ │ Data │ │ │ │ • Cancel │ • Invoice │ • NL-to-SQL │ • MLflow │ │ Prediction │ Classify │ • Intent │ • Drift │ │ • CLTV │ • Item │ Detection │ Detection │ │ • RFM │ Cleanup │ • Insight │ • Alert │ │ • Clustering │ • Sentiment │ Generation │ System │ │ • SHAP │ Analysis │ • Auto Chart │ • Registry │ ├──────────────┴──────────────┴──────────────┴────────────────┤ │ Data Layer: SQLite │ Synthetic + Kaggle │ 119K+ Records │ ├─────────────────────┴────────────────────┴──────────────────┤ │ Infrastructure: Docker │ GitHub Actions CI │ MLflow Server │ └─────────────────────────────────────────────────────────────┘ License This project is licensed under the MIT License — see the LICENSE file for details. Author Mehmet ISIK — Kaggle Grandmaster | WWTP Operations Engineer Website: mehmetisik.dev LinkedIn: in/mehmetisik4601 Kaggle: @mehmetisik Medium: @mmehmetisiken GitHub: @mmehmetisik

End-to-end AI/ML platform for hospitality analytics — from predictive models to conversational AI

A comprehensive AI/ML platform designed for hotel chains, covering the full data science lifecycle. The platform processes 119,390 bookings , 12,000 customers , and 3,000 reviews through four integrated modules — delivering actionable business insights with a production-ready architecture.

Premium dark-themed dashboard with a vibrant color palette and multi-language support (EN/TR/DE/NO).

Model comparison table, SHAP feature importance, interactive prediction form with risk gauge, and revenue impact analysis.

RFM segmentation with 6 customer segments, BG-NBD + Gamma-Gamma CLTV modeling, and K-Means behavioral clustering with radar charts.

Ask questions in plain English, get SQL-backed answers with auto-generated visualizations and business insights. Powered by Groq LLaMA 3.3 70B on 119K+ real records.

Real-time health score, PSI-based data drift analysis, model performance tracking, and threshold-based alert system with 7 configurable rules.

# Clone the repository git clone https://github.com/mmehmetisik/hotel-intelligence-platform.git cd hotel-intelligence-platform # Create virtual environment python -m venv venv source venv/bin/activate # Windows: venv\Scripts\activate # Install dependencies pip install --pre -r requirements.txt # Generate synthetic data python data/synthetic/generate_all.py # Initialize chatbot database (creates SQLite from CSV files) python -c " from src.module_3_conversational.database.init_db import initialize_database; initialize_database() " # Run the Streamlit app streamlit run app/main.py

2. Related Work, Literature Survey & Algorithmic Foundations

docker-compose up --build # App: http://localhost:8501 # MLflow: http://localhost:5000

hotel-intelligence-platform/ ├── src/ │ ├── module_1_predictive/ # ML models │ │ ├── cancellation/ # EDA, features, training, evaluation │ │ ├── cltv/ # BG-NBD, Gamma-Gamma, RFM │ │ └── clustering/ # K-Means, feature engineering │ ├── module_2_llm/ # LLM pipelines │ │ ├── invoice_classification/ # Rule-based, LLM, comparison │ │ ├── master_item_cleanup/ # Fuzzy match, hybrid pipeline │ │ └── review_analysis/ # Sentiment, aspect analysis │ ├── module_3_conversational/ # Analytics chatbot │ │ ├── llm/ # Groq client, cache, router │ │ ├── database/ # Schema, SQLite init │ │ └── agents/ # Intent, SQL, insight, chart │ └── module_4_mlops/ # MLOps │ ├── tracking/ # MLflow setup, logger, registry │ ├── monitoring/ # Data drift, model drift, alerts │ └── pipeline/ # Training pipeline ├── app/ # Streamlit dashboard │ ├── main.py # Home page │ ├── theme.py # Premium CSS theme │ ├── i18n.py # EN/TR/DE translations │ ├── components.py # Reusable UI components │ └── pages/ # 7 module pages ├── data/ │ ├── raw/ # Hotel bookings (119K records) │ └── synthetic/ # Generated datasets (6 CSVs) ├── notebooks/ # 4 Kaggle-ready notebooks ├── models/ # Trained models + metadata ├── tests/ # 188+ tests ├── .github/workflows/ci.yml # CI/CD pipeline ├── Dockerfile # Container config ├── docker-compose.yml # Multi-service setup └── requirements.txt # Dependencies

# Run all tests python -m pytest tests/ -v # Run specific module tests python -m pytest tests/test_conversational.py -v # Module 3 python -m pytest tests/test_mlops.py -v # Module 4 # With coverage python -m pytest tests/ --cov=src --cov-report=term-missing

┌─────────────────────────────────────────────────────────────┐ │ HOTEL INTELLIGENCE PLATFORM │ ├──────────────┬──────────────┬──────────────┬────────────────┤ │ Module 1 │ Module 2 │ Module 3 │ Module 4 │ │ Predictive │ LLM & │ Conversa- │ MLOps & │ │ Analytics │ Unstructured│ tional AI │ Monitoring │ │ │ Data │ │ │ │ • Cancel │ • Invoice │ • NL-to-SQL │ • MLflow │ │ Prediction │ Classify │ • Intent │ • Drift │ │ • CLTV │ • Item │ Detection │ Detection │ │ • RFM │ Cleanup │ • Insight │ • Alert │ │ • Clustering │ • Sentiment │ Generation │ System │ │ • SHAP │ Analysis │ • Auto Chart │ • Registry │ ├──────────────┴──────────────┴──────────────┴────────────────┤ │ Data Layer: SQLite │ Synthetic + Kaggle │ 119K+ Records │ ├─────────────────────┴────────────────────┴──────────────────┤ │ Infrastructure: Docker │ GitHub Actions CI │ MLflow Server │ └─────────────────────────────────────────────────────────────┘

End-to-end AI/ML platform for hospitality analytics — from predictive models to conversational AI

Concierge-AI a WhatsApp-first, LLM-powered, multilingual hospitality agent with autonomous workflows and future voice expansion. Concierge AI — Hospitality Agent System (Free SaaS Project) Automating hotel-guest communication using LLMs, WhatsApp, and no-cost tools — built for scale, plug-and-play, and real-world testing. 🚀 Overview Concierge AI is a multilingual, LLM-powered conversational agent designed to transform hotel guest experiences. It runs on WhatsApp (for now), resolves common requests, routes issues to staff, offers upsells, and maintains memory across sessions — all while being built entirely with free or open-source tools for MVP launch. 🧠 Problem It Solves Hotels struggle with: Repetitive guest queries Manual escalation workflows Lost upselling opportunities Language and timing barriers Concierge AI solves this by acting as an autonomous AI concierge across WhatsApp and future voice/chat channels — creating a smart, branded communication layer between guests and hotel ops. 🧩 Key Features ✅ WhatsApp-first guest interface (via Twilio sandbox) 🌐 Multilingual NLP responses 🤖 GPT-3.5/4 powered responses + prompt engineering 🧠 Guest memory and intent understanding 🛎 Task routing (e.g. room service, maintenance) 💬 Staff dashboard with alert and chat log 💼 Hotel-specific onboarding + multi-tenant SaaS 📊 Admin analytics & CSAT capture 🏗 System Architecture Guest (WhatsApp) ↓ Twilio WhatsApp API ↓ Express.js + OpenAI API ↙ ↘ Redis Supabase (session) (guest, chat) ↓ ↓ Translation Staff Dashboard Engine (Next.js on Vercel) ↓ ↓ n8n ← Task routing & workflows 🔧 Tech Stack (Free Tiers Only) Layer Tech Frontend (Admin) Next.js + Tailwind (Vercel) Backend Node.js + Express (Render) LLM API OpenAI GPT-3.5 (free trial) Memory Store Redis (Upstash) DB + Auth Supabase NLP Translation LibreTranslate (API/self) Bot Automation n8n.io Messaging Twilio WhatsApp Sandbox 📦 SaaS Features Tenant-based hotel account system (Supabase RLS) Plug-and-play onboarding wizard (1-click hotel setup) Editable FAQs and task triggers Chat quotas, billing plan logic, and support for multiple staff 🧪 MVP Development Timeline Week 1: Core Setup WhatsApp sandbox, GPT integration NLP intents, Redis sessions Translation middleware Week 2: Workflows & Memory n8n setup for alerting & tasks Supabase chat log DB schema Week 3: Admin Dashboard (React) Login, message log, mark task done Slack/Telegram alert integration Week 4: CSAT & Upsells Guest feedback flow GPT-based upsell suggestion template Week 5: Multi-Tenant SaaS Hotel sign-up, metadata config Staff invite + default flows Week 6: Testing + Pilot Run simulations with real hotel users Deploy via Vercel/Render 🧪 Real-World Testing Steps Set up test hotel with dummy data Add hotel profile to Supabase via admin panel Start guest conversation → test task escalation Try feedback and upsell flows Monitor via dashboard 🔐 Privacy & Compliance (Basic) Guest ID anonymization Token-authenticated API routes Data deletion on request PII redaction for OpenAI calls 📈 Key Metrics Resolution rate without staff Average response time Upsell conversion rate Escalation rate Guest satisfaction (CSAT) ✨ Future Roadmap IVR/voice interface (Whisper + ElevenLabs) Hotel PMS integrations Self-hosted LLMs for privacy Mobile admin app Travel creator concierge mode (local guides) 🧰 Contributing This project is open to contributions! Beginner-friendly issues will be labeled soon. client/ → Next.js admin panel server/ → Express.js API, memory, LLM, flows n8n/ → Workflow definitions 👨‍💻 Author & Maintainer Piyush Takrani — Second year CS undergrad & AI systems builder Connect: LinkedIn GitHub 🧾 License MIT License 🙏 Acknowledgments OpenAI for GPT Twilio for WhatsApp API Supabase, Upstash, Vercel, and n8n All the early testers who helped shape Concierge AI

a WhatsApp-first, LLM-powered, multilingual hospitality agent with autonomous workflows and future voice expansion.

Automating hotel-guest communication using LLMs, WhatsApp, and no-cost tools — built for scale, plug-and-play, and real-world testing.

Concierge AI is a multilingual, LLM-powered conversational agent designed to transform hotel guest experiences. It runs on WhatsApp (for now), resolves common requests, routes issues to staff, offers upsells, and maintains memory across sessions — all while being built entirely with free or open-source tools for MVP launch.

3. Dataset Ingestion, Preprocessing & Stochastic Augmentations

Concierge AI solves this by acting as an autonomous AI concierge across WhatsApp and future voice/chat channels — creating a smart, branded communication layer between guests and hotel ops.

Guest (WhatsApp) ↓ Twilio WhatsApp API ↓ Express.js + OpenAI API ↙ ↘ Redis Supabase (session) (guest, chat) ↓ ↓ Translation Staff Dashboard Engine (Next.js on Vercel) ↓ ↓ n8n ← Task routing & workflows

a WhatsApp-first, LLM-powered, multilingual hospitality agent with autonomous workflows and future voice expansion.

Purpose : This document defines the complete architecture for a foundational hospitality technology platform. It exposes APIs for every core hotel system — CRS, PMS, Loyalty, Payments, and more — so that teams can build full websites, agentic AI use-cases, and custom demos on top of a shared, reusable foundation.

Scope note (design vision vs. what's built): This document describes the complete foundation design. Not every component here is implemented — the built systems are CRS, PMS (check-in/out, room ops), Housekeeping, Folio/Billing, Loyalty, Guest Profiles, Payments (Stripe), Night Audit, Reporting, and Notifications. Components such as Channel Manager, POS, Key/Access Management, Group Blocks, Vouchers, and Rate/Revenue Management are design-only (API contracts and data models, no code). Where a section describes something not yet built, it is marked design-only . For the authoritative list of implemented events and enums, see the Implemented Event Catalog in Section 4 and the enum annotations in Section 5; src/layers/common/models/enums.py is ground truth.

The platform is organized into six fundamental layers , connected by a central async event bus . Each layer contains independent services that expose RESTful APIs through a unified API Gateway.

flowchart TB subgraph CHANNELS["GUEST CHANNELS"] direction LR CH["Website / App • OTAs (Expedia / Booking) • GDS / Travel • Walk-in / Kiosk"] end subgraph ACCESS["DISTRIBUTION & ACCESS LAYER"] direction LR BE["Booking Engine Search | Cart | Promos | Upsells"] CM["Channel Manager OTA Sync | Inventory | Push | Mapping"] AGW["API Gateway Auth | Rate Limit | Routing"] WH["Webhooks Stripe Events | OTA Notifs"] end subgraph CORE["CORE HOTEL SYSTEMS"] direction LR CRS["CRS (Central Reservations) Availability | Inventory Group Blocks | Overbooking Ctrl"] PMS["PMS (Property Management) Check-in/out | Room Assignment Night Audit | Room Status"] RRM["Rate / Revenue Management Rate Plans | Dynamic Pricing Restrictions | Packages"] CRS <--> PMS RRM --> PMS end BUS["**Async Event Bus** reservation.* • guest.* • room.* • charge.* • payment.*"] subgraph OPS["OPERATIONAL SYSTEMS"] direction TB HK["Housekeeping Tasks | Room Status | Scheduling"] POS["POS (Point of Sale) Restaurant | Spa | Minibar"] MSG["Guest Messaging Email | SMS | Push"] KEY["Key / Access Management Digital Key | Logs"] end subgraph FIN["FINANCE & GUEST INTELLIGENCE"] direction TB FOLIO["Folio / Billing Charges | Taxes | Split Folios"] STRIPE["Stripe Payments Pre-auth | Capture | Refunds"] CRM["CRM / Guest Profiles Prefs | History | De-dup"] LOYALTY["Loyalty System Points | Tiers | Redemptions"] FOLIO --> STRIPE CRM --> LOYALTY end subgraph INFRA["INFRASTRUCTURE"] direction LR AUTH["Auth Service Guest + Staff Pools"] LAKE["Data Lake Event Archive"] ANALYTICS["Analytics Dashboards | Occ | RevPAR | ADR"] SEARCH["Search Guest Lookup | Logs"] CACHE["Cache Availability | Sessions"] end CHANNELS --> ACCESS ACCESS --> CORE CORE --> BUS BUS --> OPS BUS --> FIN POS --> FOLIO OPS --> INFRA FIN --> INFRA

Visual Diagram : A rendered architecture diagram of the implemented platform lives at docs/img/architecture.png (also embedded in the README). The ASCII diagram above shows the full conceptual six-layer design, including components that are design-only.

This traces every system that fires when a guest interacts with AnyCompany Hotel, from discovery through post-stay.

4. Neural Network Backbone, Layer Specifications & Loss Formulations

Sarah finds AnyCompany Hotel on Expedia. Expedia sends a booking request to the Channel Manager , which acts as the traffic controller for all third-party distribution. The Channel Manager queries the CRS to check real-time availability and rates. The CRS confirms a Deluxe King is available at $249/night — a rate pulled from the Rate/Revenue Management system, which set it dynamically based on demand, day-of-week, and competitor pricing. The reservation is confirmed and the CRS pushes it to the PMS .

Meanwhile, another guest books directly on anycompanyhotels.com. That request flows through the Booking Engine (the direct channel), which also queries the CRS. Direct bookings bypass the Channel Manager — this is why both systems exist: they serve different distribution paths but share the same inventory source.

Once the reservation lands in the PMS, the Guest Messaging system sends a confirmation email. Two days before arrival, it sends a pre-check-in link. The CRM/Guest Profile system checks if Sarah has stayed before — she has, and prefers high floors and extra pillows. These preferences are flagged for the front desk. The Auth service handles her login to the guest portal.

Sarah arrives. The PMS handles check-in: assigns room 1204 (high floor, per her profile), triggers Key/Access Management to generate a digital key, and notifies Housekeeping that 1204 is now "occupied." If the room wasn't ready, Housekeeping would have flagged it as "dirty" or "in-progress," and the PMS would offer a different room.

Sarah orders room service and visits the spa. Each charge goes through the POS — restaurant POS posts $45 dinner, spa POS posts $120 treatment. Both charges flow into the Folio/Billing system, which aggregates everything tied to her stay: room charges, taxes, POS charges, minibar, parking.

At checkout, the PMS presents the final folio. Sarah confirms. Folio/Billing sends the total to Stripe Payments , which processes her card using a PaymentIntent (capturing the pre-authorized hold from check-in). Stripe confirms, the folio is settled, the PMS marks the room as "checked out," and Housekeeping is notified to clean 1204.

The Loyalty system awards 1,500 points. The CRM updates her profile with this visit's preferences and spend. Guest Messaging sends a thank-you email with a feedback survey. All data flows into Analytics for revenue analysis.

These are the touchpoints where guests interact with your hotel. They are consumers of your APIs, not systems you build from scratch (except the website).

These systems control how bookings reach your core hotel systems and how external consumers access your APIs.

5. Training Protocol, Convergence Behavior & Experimental Evaluation

These three systems are the operational backbone. Everything else integrates with them.

These systems handle day-to-day hotel operations, all coordinated by the PMS via the event bus.

These are the cross-cutting concerns that every service depends on. The specific technology choices (managed services, open-source, etc.) should be decided at build time.

Source: anycompany.{domain} (e.g. anycompany.reservations, anycompany.pms) DetailType: {entity}.{action} (e.g. reservation.created, checkinout.checked_out)

Detail payloads are camelCase (e.g. reservationId , propertyId , checkInDate ). The PMS consumers also accept snake_case for backwards compatibility with older archived events.

These events are emitted by the current code (Python handlers via utils.events.publish_event , plus the two Step Functions state machines). Source is the EventBridge source; DetailType is the event name.

These events appear in the component sections above as part of the full design vision but are not emitted by the current code . They belong to components that are designed-only (Channel Manager, POS, Key/Access, Group Blocks) or to flows that were folded into the billing/housekeeping state machines: inventory.updated , group.created , room.status_changed , room.assigned , charge.posted , folio.charge_posted , folio.settled , payment.authorized .

Below are the foundational data models for each system, derived from real-world standard hospitality objects (AWS Connect Customer Profiles: Hotel Reservation, Hotel Stay Revenue, Loyalty, and Loyalty Transaction). Each model is normalized to its owning system — no field is duplicated across systems. Cross-system relationships use FK references. Where intentional denormalization is needed (e.g., the rate booked at reservation time), these are marked as [SNAPSHOT] — a historical fact frozen at the time of the event.

RoomType ├── roomTypeId (PK) ├── code (e.g., "DLX_KING", "STD_DBL", "STE_PRES") [SRC: hotelReservation → Room.TypeCode] ├── name (e.g., "Deluxe King") [SRC: hotelReservation → Room.TypeName] ├── description [SRC: hotelReservation → Room.TypeDesc] ├── maxOccupancy [SRC: hotelReservation → Room.Capacity] ├── bedConfiguration (e.g., "1 King" or "2 Queen") ├── baseRate ├── accessibilityType [SRC: hotelReservation → Room.AccessibilityType] ├── smokingAllowed [SRC: hotelReservation → Room.SmokingAllowed] ├── amenities[] (e.g., ["balcony", "ocean_view", "minibar"]) ├── imageUrls[] ├── sortOrder ├── isActive ├── createdAt / updatedAt Room ├── roomId (PK) ├── roomNumber (e.g., "1204") [SRC: hotelReservation → Room.Number] ├── roomTypeId (FK → RoomType) ├── floor ├── wing (e.g., "North Tower") ├── status (CLEAN | DIRTY | INSPECTED | OUT_OF_ORDER | OUT_OF_INVENTORY) ── base CRS inventory status (RoomStatus) │ PMS operations use an extended set (PmsRoomStatus): │ AVAILABLE | OCCUPIED | DIRTY | CLEANING | INSPECTING | OUT_OF_ORDER ├── isConnecting ├── connectingRoomId ├── features[] (e.g., ["high_floor", "corner", "ada_accessible"]) ├── lastCleanedAt ├── createdAt / updatedAt AvailabilityRecord ├── roomTypeId (PK) ├── date (SK) ├── totalInventory ├── sold ├── blocked (group blocks, out-of-order) ├── available (computed: totalInventory - sold - blocked) ├── overbookingAllowance ├── updatedAt