Airbnb Engineer

# Add to CLAUDE.md
echo "Apply airbnb-engineer: Design-led development, two-sided marketplace optimization, host-guest empathy, trust-first architecture." >> CLAUDE.md

Traditional:                    Airbnb:
┌─────────────┐                 ┌─────────────────────────┐
│  Product    │                 │      Designer           │
│  Manager    │                 │  (Product + Marketing)  │
└──────┬──────┘                 └───────────┬─────────────┘
       │                                    │
┌──────┴──────┐                 ┌───────────┴───────────┐
│  Designer   │                 │      Engineer         │
└──────┬──────┘                 └───────────┬───────────┘
       │                                    │
┌──────┴──────┐                 ┌───────────┴───────────┐
│  Engineer   │                 │  Program Manager      │
└─────────────┘                 └───────────────────────┘

         ┌─────────────┐
         │ More Guests │
         └──────┬──────┘
                │
                ▼
    ┌───────────────────────┐
    │   More Bookings       │
    │   (Liquidity)         │
    └───────────┬───────────┘
                │
                ▼
    ┌───────────────────────┐
    │   Hosts Earn More     │
    └───────────┬───────────┘
                │
                ▼
    ┌───────────────────────┐
    │   More Hosts Join     │
    └───────────┬───────────┘
                │
                ▼
    ┌───────────────────────┐
    │   More Listings       │
    └───────────┬───────────┘
                │
                └──────────────► (Back to More Guests)

# Simplified representation of Airbnb's listing embedding system
# Based on: "Learning and Applying Airbnb Listing Embeddings" (KDD 2024)

class ListingEmbeddingModel:
    """
    Two-tower neural network for learning listing embeddings
    from guest engagement data (views → bookings)
    """
    
    def __init__(self):
        # Signal tower: encodes viewed listings
        self.signal_tower = nn.Sequential(
            nn.Linear(input_dim, 512),
            nn.Tanh(),
            nn.Linear(512, 256),
            nn.Tanh(),
            nn.Linear(256, 128)  # embedding dimension
        )
        
        # Label tower: encodes booked listing
        self.label_tower = nn.Sequential(
            nn.Linear(input_dim, 512),
            nn.Tanh(),
            nn.Linear(512, 256),
            nn.Tanh(),
            nn.Linear(256, 128)
        )
    
    def forward(self, signal_listings, label_listing):
        # signal_listings: sequence of viewed listings
        # Average pooling across viewed listings
        signal_embedding = self.signal_tower(
            signal_listings.mean(dim=0)
        )
        label_embedding = self.label_tower(label_listing)
        
        # Dot product similarity
        similarity = torch.dot(signal_embedding, label_embedding)
        return similarity

Similar Listings Generation:
  embedding_dim: 128
  ann_backend: ScaNN  # or FAISS
  n_candidates: 1000
  post_processing:
    - geo_distance_filter: max 50km
    - availability_check: true
    - host_deduplication: true

class SmartPricingEngine:
    """
    ML-powered pricing recommendations for hosts
    Balances host revenue with booking probability
    """
    
    def calculate_price_recommendation(
        self,
        listing: Listing,
        target_date: Date,
        market_conditions: MarketData
    ) -> PriceRecommendation:
        
        # Feature engineering
        features = {
            # Listing features
            'property_type': listing.property_type,
            'bedrooms': listing.bedrooms,
            'amenities_count': len(listing.amenities),
            'rating': listing.review_rating,
            'superhost': listing.is_superhost,
            
            # Temporal features
            'day_of_week': target_date.weekday(),
            'is_holiday': self.is_holiday(target_date),
            'days_until_date': (target_date - today).days,
            'seasonality': self.get_seasonality(target_date),
            
            # Market features
            'local_demand_index': market_conditions.demand_score,
            'competitor_avg_price': market_conditions.competitor_prices,
            'search_impression_count': market_conditions.search_volume,
            'booking_pace': market_conditions.pace_vs_last_year,
            
            # Historical performance
            'host_acceptance_rate': listing.host.acceptance_rate,
            'historical_occupancy': listing.occupancy_history,
            'price_elasticity': listing.price_sensitivity
        }
        
        # Model inference
        base_recommendation = self.pricing_model.predict(features)
        
        # Apply host preferences
        min_price = listing.host.preferences.min_price
        max_price = listing.host.preferences.max_price
        
        recommendation = self.apply_host_constraints(
            base_recommendation,
            min_price,
            max_price
        )
        
        return PriceRecommendation(
            suggested_price=recommendation,
            confidence=self.calculate_confidence(features),
            price_range=(recommendation * 0.8, recommendation * 1.2),
            explanation=self.generate_explanation(features)
        )

┌─────────────────────────────────────────────────────────────┐
│                    PRICING LAYERS                           │
├─────────────────────────────────────────────────────────────┤
│  Layer 4: Host Preferences                                  │
│           Min/max bounds, discount settings                 │
├─────────────────────────────────────────────────────────────┤
│  Layer 3: Business Rules                                    │
│           Cleaning fees, taxes, long-stay discounts         │
├─────────────────────────────────────────────────────────────┤
│  Layer 2: ML Model Output                                   │
│           Base price recommendation                         │
├─────────────────────────────────────────────────────────────┤
│  Layer 1: Market Data                                       │
│           Demand forecasting, competitor analysis           │
└─────────────────────────────────────────────────────────────┘

class TrustAndSafetyEngine:
    """
    Multi-layer fraud detection and risk assessment
    Protects both hosts and guests
    """
    
    def assess_booking_risk(self, booking: Booking) -> RiskAssessment:
        risk_signals = {
            # Account signals
            'account_age_days': (today - booking.guest.created_at).days,
            'verification_level': booking.guest.verification_level,
            'previous_bookings': booking.guest.booking_count,
            'profile_completeness': booking.guest.profile_completion_score,
            
            # Behavioral signals
            'message_sentiment': self.analyze_message_tone(
                booking.initial_message
            ),
            'booking_urgency': booking.check_in_date - booking.created_at,
            'inquiry_to_booking_time': booking.time_to_book,
            
            # Transaction signals
            'payment_method_age': booking.payment_method.age_days,
            'billing_shipping_match': booking.address_match_score,
            'device_fingerprint_risk': self.device_risk_score(
                booking.device_fingerprint
            ),
            
            # Trip signals
            'trip_value': booking.total_amount,
            'destination_risk': self.destination_risk_score(
                booking.listing.city
            ),
            'duration_risk': self.duration_risk_score(
                booking.nights
            )
        }
        
        # Ensemble model scoring
        risk_score = self.ensemble_model.predict(risk_signals)
        
        # Risk tier classification
        if risk_score > 0.9:
            tier = RiskTier.HIGH
            action = Action.DECLINE_OR_REVIEW
        elif risk_score > 0.7:
            tier = RiskTier.ELEVATED
            action = Action.ADDITIONAL_VERIFICATION
        elif risk_score > 0.4:
            tier = RiskTier.MEDIUM
            action = Action.STANDARD_MONITORING
        else:
            tier = RiskTier.LOW
            action = Action.APPROVE
        
        return RiskAssessment(
            score=risk_score,
            tier=tier,
            recommended_action=action,
            top_risk_factors=self.explain_risk(risk_signals)
        )

Verification Levels:
  level_1:  # Email + Phone
    - email_verification
    - phone_sms_verification
    
  level_2:  # Government ID
    - id_document_upload
    - ocr_extraction
    - selfie_matching
    - liveness_detection
    
  level_3:  # Enhanced
    - background_check
    - address_verification
    - social_graph_analysis

# Current state metrics
baseline_metrics = {
    'search_to_view_rate': 0.35,      # 35% click on listing
    'view_to_book_rate': 0.08,        # 8% book after viewing
    'host_acceptance_rate': 0.72,     # 72% of requests accepted
    'time_to_book_median': 4.2,       # days from search to book
    'guest_satisfaction_score': 4.7   # post-stay rating
}

# Hypothesis: Better personalization can improve both 
# guest conversion AND host acceptance

# Two-tower ranking architecture
RankingModel:
  query_tower:
    inputs:
      - guest_features: [past_bookings, search_history, preferences]
      - context_features: [device, dates, party_size]
    layers: [512, 256, 128]
    activation: Swish
    
  listing_tower:
    inputs:
      - listing_features: [property_type, amenities, location]
      - quality_features: [rating, reviews, superhost]
      - host_features: [response_rate, acceptance_rate]
    layers: [512, 256, 128]
    activation: Swish
    
  scoring:
    method: dot_product
    temperature: 0.1

# Positive examples: Listings that were viewed AND booked
positive_examples = query_booking_pairs[
    (query_booking_pairs.viewed == True) & 
    (query_booking_pairs.booked == True)
]

# Hard negatives: Viewed but not booked (more informative than random)
hard_negatives = query_booking_pairs[
    (query_booking_pairs.viewed == True) & 
    (query_booking_pairs.booked == False)
]

# Loss function: Softmax cross-entropy with in-batch negatives
def ranking_loss(query_embedding, positive_embedding, batch_embeddings):
    similarity_pos = cosine_similarity(query_embedding, positive_embedding)
    similarity_neg = cosine_similarity(query_embedding, batch_embeddings)
    
    logits = torch.cat([similarity_pos, similarity_neg]) / temperature
    labels = torch.zeros(len(logits), dtype=torch.long)  # positive is index 0
    
    return F.cross_entropy(logits, labels)

# Offline metrics
offline_metrics = {
    'ndcg@10': 0.78,           # Ranking quality
    'precision@10': 0.42,       # Relevance
    'diversity_score': 0.65     # Listing exposure variety
}

# Online A/B test
ab_test_results = {
    'treatment': {
        'booking_conversion': '+12%',
        'host_acceptance_rate': '+3%',
        'revenue_per_search': '+15%'
    },
    'guardrail_metrics': {
        'long_tail_exposure': '-2%',   # Monitor for bias
        'page_load_time': '+15ms'       # Acceptable latency
    }
}

# Decision: Ship to 100% after 2 weeks positive metrics

# Price elasticity varies by market segment
market_segments = {
    'budget_entire_home': {
        'price_sensitivity': 'high',
        'competitor_count': 250,
        'avg_booking_window': 30,  # days
        'optimal_discount_strategy': 'early_bird'
    },
    'luxury_unique_stay': {
        'price_sensitivity': 'low',
        'competitor_count': 15,
        'avg_booking_window': 90,
        'optimal_discount_strategy': 'last_minute'
    },
    'business_travel': {
        'price_sensitivity': 'medium',
        'competitor_count': 120,
        'avg_booking_window': 14,
        'optimal_discount_strategy': 'weekday_premium'
    }
}

class DemandForecaster:
    """
    Predict demand for each listing-date combination
    to inform pricing recommendations
    """
    
    def forecast_demand(
        self,
        listing: Listing,
        dates: List[Date],
        historical_data: pd.DataFrame
    ) -> DemandForecast:
        
        features = pd.DataFrame({
            'date': dates,
            'day_of_week': [d.weekday() for d in dates],
            'is_holiday': [self.is_holiday(d) for d in dates],
            'local_events': [self.get_events(d, listing.city) for d in dates],
            'search_trend': self.get_search_trends(listing.city, dates),
            'competitor_occupancy': self.scrape_competitor_data(
                listing, dates
            )
        })
        
        # LSTM for time series prediction
        demand_prediction = self.lstm_model.predict(features)
        
        # Add uncertainty intervals
        return DemandForecast(
            point_estimate=demand_prediction.mean,
            lower_bound=demand_prediction.p10,
            upper_bound=demand_prediction.p90,
            confidence=demand_prediction.uncertainty
        )

def optimize_price(
    listing: Listing,
    target_date: Date,
    demand_forecast: DemandForecast,
    constraints: PricingConstraints
) -> float:
    """
    Find optimal price that maximizes expected revenue
    """
    
    def expected_revenue(price: float) -> float:
        # Booking probability decreases as price increases
        booking_prob = logistic_function(
            base_prob=demand_forecast.point_estimate,
            price_sensitivity=listing.price_elasticity,
            price=price,
            competitor_avg=constraints.market_rate
        )
        
        # Expected revenue = price * booking_prob
        return price * booking_prob
    
    # Optimize within host constraints
    optimal_price = golden_section_search(
        f=expected_revenue,
        lower=constraints.min_price,
        upper=constraints.max_price
    )
    
    return optimal_price

# Smart Pricing Notification

Hi [Host Name],

Based on increased demand for [City] during [Event/Dates], 
we recommend updating your price to $[Price]/night.

**Why this price?**
- Similar listings are booking at $[Range]
- [Event name] is bringing [X] visitors to your area
- Your listing has [Unique features that justify premium]

**Expected impact:**
- [Y]% higher revenue potential
- [Z]% probability of booking

[Enable Smart Pricing] [Adjust Manually]

# Multi-modal risk signals
risk_signals = {
    # Digital fingerprint
    'device_risk': {
        'new_device': device.first_seen < 24_hours,
        'vpn_usage': ip.is_vpn,
        'emulator_detected': device.is_emulator,
        'device_fraud_history': device.past_fraud_count
    },
    
    # Behavioral patterns
    'behavioral_risk': {
        'rapid_booking_attempts': 5,  # bookings in 1 hour
        'messaging_anomalies': detect_copy_paste_patterns(),
        'unusual_travel_pattern': check_geographic_consistency(),
        'high_value_first_booking': booking.amount > threshold
    },
    
    # Payment risk
    'payment_risk': {
        'card_bin_country_mismatch': card.country != ip.country,
        'stolen_card_indicator': card.fraud_reports > 0,
        'billing_address_verification': avs_result,
        '3ds_authentication': three_d_secure.status
    },
    
    # Account risk
    'account_risk': {
        'account_age_hours': (now - user.created_at).hours,
        'identity_verification': user.verification_level,
        'profile_completeness': profile.completion_score,
        'connected_accounts': user.social_accounts.count
    }
}

FraudDetectionModel:
  architecture: GradientBoostedTrees + Neural Network Ensemble
  
  feature_groups:
    - name: identity_features
      importance: 0.35
      features: [verification_level, document_authenticity, selfie_match]
      
    - name: behavioral_features
      importance: 0.30
      features: [booking_velocity, message_patterns, session_behavior]
      
    - name: transaction_features
      importance: 0.25
      features: [amount, payment_method, billing_address]
      
    - name: network_features
      importance: 0.10
      features: [device_fingerprint, ip_reputation, graph_connections]
  
  training:
    positive_samples: confirmed_fraud_bookings_last_2_years
    negative_samples: random_legitimate_bookings
    ratio: 1:100  # Handle class imbalance
    
  evaluation:
    primary_metric: precision_at_recall_80  # Catch 80% fraud, minimize false positives
    target: precision > 0.95  # <5% false positive rate

def determine_action(risk_score: float, booking: Booking) -> Action:
    """
    Risk-based graduated response
    """
    
    if risk_score >= 0.95:
        return Action(
            type='DECLINE',
            reason='High fraud risk detected',
            user_message='We couldn\'t complete this booking. Please contact support.',
            internal_notes='Auto-decline: score > 0.95',
            requires_review=True
        )
    
    elif risk_score >= 0.80:
        return Action(
            type='CHALLENGE',
            challenges=[
                'additional_identity_verification',
                'phone_verification',
                'payment_3d_secure'
            ],
            timeout_hours=24
        )
    
    elif risk_score >= 0.50:
        return Action(
            type='MONITOR',
            alerts=['notify_host_of_new_guest', 'increase_support_priority'],
            post_booking_checks=['review_messaging', 'stay_outcome']
        )
    
    else:
        return Action(type='APPROVE')

# Feedback loop for model improvement
feedback_loop = {
    'confirmed_fraud': {
        'source': ['chargebacks', 'host_reports', 'guest_complaints'],
        'action': 'add_to_training_data_positive',
        'weight': 1.0
    },
    
    'false_positives': {
        'source': ['customer_support_escalations', 'legitimate_appeals'],
        'action': 'add_to_training_data_negative',
        'weight': 2.0  # Higher weight - critical to reduce
    },
    
    'model_drift_detection': {
        'metric': 'ks_statistic',
        'threshold': 0.1,
        'action': 'trigger_retraining'
    }
}

class MessagingSystem:
    """
    Facilitates host-guest communication with trust-building
    and safety guardrails
    """
    
    def __init__(self):
        self.response_time_predictor = ResponseTimePredictor()
        self.sentiment_analyzer = SentimentAnalyzer()
        self.language_detector = LanguageDetector()
        
    def enrich_conversation(self, thread: MessageThread) -> EnrichedThread:
        """Add context to help both parties communicate effectively"""
        
        return EnrichedThread(
            # Smart replies for common questions
            suggested_replies=self.generate_suggestions(thread),
            
            # Translation for international guests
            translation=self.translate_if_needed(
                thread.messages,
                target_language=thread.recipient.preferred_language
            ),
            
            # Trust signals
            trust_indicators={
                'host_response_time': self.response_time_predictor.predict(
                    thread.host
                ),
                'guest_verification_level': thread.guest.verification_badge,
                'mutual_connections': self.find_mutual_connections(
                    thread.host, thread.guest
                ),
                'previous_reviews': self.get_relevant_past_reviews(
                    thread.listing, thread.guest
                )
            },
            
            # Booking readiness score
            conversion_probability=self.predict_booking_likelihood(thread)
        )

# Pattern detection for off-platform contact sharing
off_platform_patterns = [
    r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b',  # Phone numbers
    r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b',  # Emails
    r'\b(?:facebook|fb|instagram|ig|whatsapp|wa|wechat)\b',  # Platform names
    r'(?i)(?:contact|reach|call|text).*(?:me|at|on|via)',  # Intent phrases
]

def detect_off_platform_attempt(message: str) -> DetectionResult:
    """
    Detect and handle attempts to move conversation off-platform
    """
    
    for pattern in off_platform_patterns:
        matches = re.findall(pattern, message)
        if matches:
            return DetectionResult(
                detected=True,
                severity='HIGH',
                action='BLOCK_AND_NOTIFY',
                message_to_sender='''For your safety and security, please keep 
                all communication on Airbnb until a booking is confirmed.''',
                message_to_recipient=None,  # Don't alert potential bad actor
                review_required=True
            )
    
    # NLP-based semantic detection
    intent_score = self.nlp_model.classify_intent(message)
    if intent_score.off_platform > 0.8:
        return DetectionResult(
            detected=True,
            severity='MEDIUM',
            action='WARN_AND_LOG',
            message_to_sender='''Keeping communication on Airbnb ensures you're 
            protected by our policies and support team.'''
        )
    
    return DetectionResult(detected=False)

class ResponseTimeOptimizer:
    """
    Help hosts maintain good response times
    """
    
    def send_response_reminders(self):
        """Intelligent reminder system for pending inquiries"""
        
        pending_inquiries = self.get_pending_inquiries(
            older_than=minutes(30)
        )
        
        for inquiry in pending_inquiries:
            host = inquiry.listing.host
            
            # Personalized reminder based on host patterns
            if host.typical_response_time < hours(2):
                # Fast responder - they're probably busy
                message = f"You have a new inquiry from {inquiry.guest.name}. "
                        f"Your typical response time is {host.typical_response_time} "
                        f"- respond soon to maintain your status!"
            else:
                # Slower responder - encourage improvement
                message = f"Quick responses increase your booking rate by 2x. "
                        f"{inquiry.guest.name} is waiting to hear from you."
            
            self.send_push_notification(host, message)

class ReviewAuthenticityDetector:
    """
    Detect fake, incentivized, or manipulated reviews
    """
    
    def analyze_review(self, review: Review) -> AuthenticityScore:
        signals = {
            # Content-based signals
            'text_patterns': {
                'template_language': self.detect_template_phrases(review.text),
                'sentiment_mismatch': self.check_sentiment_rating_alignment(
                    review.text, review.rating
                ),
                'review_length': len(review.text),
                'specificity_score': self.measure_specificity(review.text)
            },
            
            # Behavioral signals
            'reviewer_behavior': {
                'account_age_at_review': (
                    review.created_at - review.author.created_at
                ).days,
                'review_velocity': review.author.reviews_per_month,
                'geographic_consistency': self.check_location_consistency(
                    review.author, review.listing
                ),
                'cross_reviews': self.detect_review_exchange_patterns(
                    review.author
                )
            },
            
            # Network signals
            'relationship_signals': {
                'host_guest_communication_duration': self.get_message_history_length(
                    review.author, review.listing.host
                ),
                'booking_verification': review.booking.is_verified,
                'stay_duration': review.booking.nights
            }
        }
        
        authenticity_score = self.model.predict(signals)
        
        return AuthenticityResult(
            score=authenticity_score,
            flags=self.identify_concerns(signals),
            recommendation=self.determine_action(authenticity_score)
        )

def rank_reviews(listing: Listing) -> List[Review]:
    """
    Surface most helpful reviews first
    """
    
    def helpfulness_score(review: Review) -> float:
        factors = {
            # Recency (decay over time)
            'recency': exponential_decay(
                days_since(review.created_at),
                half_life_days=365
            ),
            
            # Detail and specificity
            'quality': min(len(review.text) / 500, 1.0) * 
                      review.specificity_score,
            
            # Helpful votes from other users
            'community_value': sigmoid(
                review.helpful_votes - review.unhelpful_votes
            ),
            
            # Reviewer credibility
            'reviewer_trust': review.author.reputation_score,
            
            # Balanced representation
            'category_coverage': review.covers_category(
                ['cleanliness', 'location', 'communication', 'accuracy']
            )
        }
        
        return weighted_sum(factors, weights={
            'recency': 0.20,
            'quality': 0.25,
            'community_value': 0.20,
            'reviewer_trust': 0.20,
            'category_coverage': 0.15
        })
    
    return sorted(listing.reviews, key=helpfulness_score, reverse=True)

def calculate_superhost_eligibility(host: Host) -> SuperhostStatus:
    """
    Evaluate host for Superhost status (quarterly evaluation)
    """
    
    requirements = {
        'completed_stays': {
            'requirement': 10,  # minimum stays in past year
            'actual': host.completed_stays_last_365_days,
            'met': host.completed_stays_last_365_days >= 10
        },
        
        'cancellation_rate': {
            'requirement': '< 1%',
            'actual': host.cancellation_rate,
            'met': host.cancellation_rate < 0.01
        },
        
        'response_rate': {
            'requirement': '>= 90%',
            'actual': host.response_rate,
            'met': host.response_rate >= 0.90
        },
        
        'rating_threshold': {
            'requirement': '>= 4.8',
            'actual': host.overall_rating,
            'met': host.overall_rating >= 4.8
        }
    }
    
    all_met = all(r['met'] for r in requirements.values())
    
    return SuperhostStatus(
        is_eligible=all_met,
        requirements=requirements,
        next_evaluation_date=next_quarter_start(),
        benefits=apply_superhost_badge() if all_met else None
    )

# Always measure impact on BOTH sides
def evaluate_feature(feature):
    guest_metrics = measure_guest_impact(feature)
    host_metrics = measure_host_impact(feature)
    marketplace_metrics = measure_liquidity_impact(feature)
    
    # Feature only ships if it improves or maintains both sides
    if (guest_metrics.impact >= 0 and 
        host_metrics.impact >= 0 and
        marketplace_metrics.liquidity >= 0):
        return DECISION.SHIP
    else:
        return DECISION.ITERATE

# Safety checks at every layer
class BookingFlow:
    def create_booking(self, request):
        # Layer 1: Input validation
        if not self.validate_request(request):
            raise ValidationError()
        
        # Layer 2: Risk assessment
        risk = self.assess_risk(request)
        if risk.score > THRESHOLD:
            return self.handle_high_risk(request, risk)
        
        # Layer 3: Host protection
        if not self.check_host_preferences(request):
            return self.request_host_approval(request)
        
        # Layer 4: Payment verification
        if not self.verify_payment(request):
            return self.request_payment_verification(request)
        
        return self.confirm_booking(request)

When evaluating risk, ask:

1. Does this feature feel "Airbnb"?
   → If it doesn't match our design ethos, don't ship

2. Would I be proud to put my name on this?
   → If not, iterate until you are

3. Does this create trust or erode it?
   → Trust is our currency; protect it above all

4. Are we optimizing for both sides equally?
   → Marketplace health requires balance

□ Host benefit identified and measured
□ Guest benefit identified and measured  
□ Cross-side network effect considered
□ Trust implications reviewed
□ Design mockups storyboarded
□ Localization impact assessed (220+ countries)

Budget Entire Home:
  → Early bird discounts
  → Competitive to hotels
  → Volume-focused

Luxury Unique Stay:
  → Premium pricing
  → Scarcity value
  → Experience-focused

Business Travel:
  → Weekday premium
  → Corporate partnerships
  → Convenience-focused

Booking Request Received
         │
    ┌────┴────┐
    │         │
    ▼         ▼
 Risk Score  Risk Score
  < 0.5      0.5 - 0.8
    │         │
    ▼         ▼
 APPROVE   ADDITIONAL
            CHECKS
               │
          ┌────┴────┐
          │         │
          ▼         ▼
       Pass      Fail
          │         │
          ▼         ▼
       APPROVE   DECLINE/
                 REVIEW