Production-grade microservices platform for real-time social event discovery, ticketing, and live streaming.

Location-based social platform combining event management, live streaming, AI-powered recommendations, and dual-provider payments — built on async Python (Quart) with a Rust-based ASGI server, deployed to GKE.

Cloud-native microservices platform built on Quart (async Python) served by Granian (Rust ASGI server with uvloop). All services share a common MicroService base class that initializes SurrealDB connection pools (via purreal), Redis, JWT, RabbitMQ, Prometheus metrics, and a KPI aggregator. Deployed to Google Kubernetes Engine (us-central1) via Cloud Build.

• Geospatial Discovery: SurrealDB geo::distance queries with indexed coordinates, radius-based event search with pagination
• Graph Social Layer: SurrealDB relation tables (friends, blocks, attends, guestlists) with multi-degree traversal (fn::exists_in_degree up to 5 hops) for private event access control
• AI Recommendations: GET /events/<id>/similar — SurrealDB native HNSW vector indexes (768-dim ViT embeddings) for visual similarity search, cosine + KNN scoring, Redis-cached (5min TTL)
• Async Media Pipeline: RabbitMQ (via FastStream) for image compression (Pillow, 2048px max, JPEG Q90), video transcoding (FFmpeg, H.264 CRF 21, 1080p, 5M bitrate), thumbnail extraction, and BlurHash generation
• Dual-Provider Payments: Stripe (international) + Paystack (Africa) with webhook-driven ticket creation, tier capacity tracking, and host notification
• Live Streaming: GetStream.io Video + Chat SDKs with backstage → go-live flow, geofenced attendee role management (1km radius), and per-event chat channels
• Real-time KPIs: Prometheus counters across all services + SurrealDB aggregate queries (DAU/WAU/MAU, retention cohorts, churn, ARPU, conversion), served at GET /auth/kpis for Grafana Infinity

              ┌──────────────────────────────────────────────────┐
              │         GCP Load Balancer (API Gateway)           │
              └────────────────────┬─────────────────────────────┘
                                   │
         ┌─────────┬───────────┬───┴───┬───────────┬─────────────┐
         │         │           │       │           │             │
    ┌────▼───┐ ┌───▼───┐ ┌────▼──┐ ┌──▼───┐ ┌────▼────┐ ┌─────▼────┐
    │  Auth  │ │ Users │ │Events │ │Posts │ │Payments │ │Livestream│
    │  :5510 │ │ :5510 │ │ :5510 │ │:5510 │ │  :5510  │ │  :5510   │
    └────┬───┘ └───┬───┘ └───┬───┘ └──┬───┘ └────┬────┘ └─────┬────┘
         │         │         │        │           │            │
         └─────────┴─────┬───┴────┬───┴───────────┘            │
                         │        │                            │
                    ┌────▼───┐ ┌──▼────┐               ┌──────▼──────┐
                    │ Media  │ │ R18E  │               │ GetStream   │
                    │ :5510  │ │ :5510 │               │ Video+Chat  │
                    └────┬───┘ └───┬───┘               └─────────────┘
                         │        │
    ┌────────────────────┴────────┴──────────────────────┐
    │              Infrastructure Layer                    │
    │  SurrealDB │ Redis │ RabbitMQ │ GCS │ Secret Mgr   │
    └─────────────────────────────────────────────────────┘

7 services deployed to production (auth, events, posts, users, media, payments, livestream). AI recommendations are served by the Events service via GET /events/<id>/similar. R18E exists as a standalone service but is not separately deployed.

• Runtime: Granian (Rust ASGI, uvloop, multi-threaded, dynamic workers via $(nproc))
• Auth flows: Email/password (Argon2 hashing in SurrealDB), Google SSO (google-auth), Apple SSO (JWT verification)
• JWT: Shared secret distributed via Redis; auth service generates, others read
• Credential storage: AES-CBC envelope encryption — data encrypted with random DEK, DEK encrypted with KEK from Google Secret Manager
• Rate limiting: Redis + atomic Lua script, 3-window (per-minute/hour/day), by IP (SHA-256 of IP+User-Agent) or JWT user ID
• KPI endpoint: GET /auth/kpis — public, serves Prometheus + SurrealDB aggregate metrics for Grafana
• GDPR: Scheduled account deletion via K8s CronJob (daily at 02:00 UTC)

• Social graph: SurrealDB friends relation table with status enum (pending | accepted | blocked | removed | rejected)
• Graph traversal: fn::find_relationships up to 5 degrees of separation; fn::exists_in_degree for private event access
• Blocking: Separate blocks relation table
• Notifications: Novu integration (modular registry pattern) — friend request notifications on relationship creation

• Geospatial: location.coordinates stored as SurrealDB Point type; fn::fetch_events_by_location uses geo::distance filtering + pagination
• Discovery feeds: fn::fetch_public_events, fn::fetch_trending_events (score = attendees×3 + posts×2), fn::fetch_private_events_for_user (graph-gated)
• AI Similar Events: GET /events/<id>/similar — calls fn::fetch_similar_events (HNSW KNN on ViT-768 media embeddings, deduplicated, future-only, preview cards), Redis-cached 5min, replaces standalone R18E service
• Ticketing: Multi-tier tickets (ticket_tiers table, capacity tracking, sold_count auto-incremented via SurrealDB CREATE event), unique ticket numbers (TKT-XXXX-XXXX)
• Guestlists: guestlists relation table for event invitations with invited-by tracking
• WebSocket: Real-time event updates (events service only)

• Data model: posts is a SurrealDB relation table (users → media) with content, event association, and visibility flag
• Comments: comments relation table (users → posts)
• Media: File uploads validated then published to RabbitMQ for async processing by the media service
• Content reporting: Generic _report_resource for posts and comments, stored in reports table with status tracking

• Pipeline: RabbitMQ consumer (FastStream) → fetch from GCS temp → compress → extract metadata → upload final → update DB
• Image processing: Pillow + pillow-heif (HEIC/HEIF support), max 2048px, JPEG Q90, EXIF orientation correction, BlurHash generation for instant placeholders
• Video processing: FFmpeg async wrapper, H.264 CRF 21, 1080p max (1920×1080), 5Mbps bitrate cap, 12M buffer, 128k AAC audio, 44.1kHz sample rate; MOV→MP4 conversion
• Thumbnails: Auto-extracted at ~10% of video duration, uploaded as WebP alongside video
• Storage: Google Cloud Storage via obstore (Rust-based), with signed URL generation
• Serialization: ormsgpack (MessagePack) for RabbitMQ message encoding
• Workers: Granian with 1 worker (I/O-bound on FFmpeg), explicit gc.collect() after each processed file

• Providers: Stripe (international markets) + Paystack (African markets)
• Flows: Payment intent → webhook verification → ticket creation → tier sold count increment → host notification (Novu) → buyer email
• Webhook security: Stripe signature verification, Paystack webhook validation
• Split payments: Paystack subaccount support for marketplace host payouts
• PCI: Level 1 compliant via Stripe tokenization

• Provider: GetStream.io (migrated from Cloudflare Stream)
• Video SDK: getstream Python SDK (sync, wrapped with asyncio.to_thread for non-blocking Quart)
• Chat SDK: stream-chat async SDK — one livestream channel per event, created alongside the video call
• Flow: Create call (backstage) → go-live (broadcast) → end-live (back to backstage) → end call (permanent)
• Geofencing: 1km radius check on POST /scenes/<event_id>/attendee-location, auto-promotes/demotes attendee ↔ viewer based on GPS
• Tokens: Unified Stream token covers both Video and Chat SDKs

• Status: Superseded by GET /events/<id>/similar in the Events service for now. R18E has its own Dockerfile and test suite but is not deployed separately.
• Events service handles recommendations: fn::fetch_similar_events runs the full HNSW pipeline in SurrealQL (average ViT-768 embeddings → KNN top-100, EF=40 → cosine reranking → dedup → future-event filter → preview cards)
• Future: R18E may be deployed for advanced use cases (content moderation, user preference learning) — PyTorch deps are commented out in requirements.txt

SurrealDB schema (init/schema.surql) — 619 lines defining the full data model:

Event discovery (fetch_public_events, fetch_trending_events, fetch_events_by_location, fetch_private_events_for_user), event detail (fetch_event, fetch_event_preview), ticketing (fetch_user_tickets), social graph (create_relationship, get_friends, find_relationships, exists_in_degree), guestlists (fetch_event_guestlist), posts (fetch_post), AI similarity (fetch_similar_events) — all computed server-side in SurrealQL.

• Cloud Provider: Google Cloud Platform
• Compute: GKE cluster (backstage-cluster, us-central1)
• Registry: Artifact Registry (us-central1-docker.pkg.dev/.../scenes-backstage/)
• Build: Cloud Build (E2_HIGHCPU_8 machine), parallel image builds for all 7 services, then rolling restart
• Containers: Docker multi-stage builds (test → prod), non-root user, port 5510
• CronJob: scheduled-deletion-cleanup — runs daily at 02:00 UTC for GDPR account deletion (512Mi–1Gi memory, 250m–500m CPU)

Primary deploy (production): gcloud builds submit . → Cloud Build (cloudbuild.yaml)

Full GitHub Actions pipeline (9 stages, ci-test-deploy.yaml):

Code Quality ──→ Unit Tests (matrix: 7 services) ──→ Integration Tests ──┐
                                                                          ├──→ Build Images ──→ Deploy Staging ──→ Smoke Tests + k6 ──→ Deploy Production (Blue-Green) ──→ Rollback (on failure)
                                                     Contract Tests ──────┘

Benchmarked on production GKE Autopilot (us-central1), 250m–500m vCPU per pod, Granian Rust ASGI with uvloop.

Aggregate cluster capacity: ~2,500+ req/s across 7 service pods (read-heavy workload). Horizontally scalable — GKE Autopilot provisions additional pods on demand.

Media processing is decoupled via RabbitMQ — upload returns immediately, compression runs async. Single media worker prevents resource contention on I/O-bound FFmpeg operations.

Three sliding windows evaluated atomically per request. Keys derived from SHA-256(IP:User-Agent) or JWT user ID.

GKE Autopilot auto-scales pods based on CPU/memory pressure. No manual node provisioning required — infrastructure cost scales linearly with traffic.

~200 test functions across 37 test files, covering all 8 services:

Test infrastructure: docker-compose.test.yml with SurrealDB (in-memory), Redis 7, RabbitMQ 3 — all with health checks.

Load testing: Locust framework (tests/load_testing/locustfile.py).

• Linting: flake8 (syntax/logic errors), black (formatting)
• Type checking: mypy (configured via pyproject.toml, non-blocking in CI)
• Input sanitization: bleach for HTML, content-type enforcement, size limits

Built-in funding-grade metrics system — no external analytics dependencies:

Incremented at event success points across services:

DAU/WAU/MAU (via last_active field), D1/D7/D30 retention cohorts, churn rate, signup growth (WoW/MoM), GMV, ARPU, ticket conversion rate, stickiness (DAU/MAU), plus time-windowed counts (24h/7d/30d signups, events, tickets, posts).

GET /auth/kpis returns a flat JSON structure parseable by Grafana Infinity datasource with JSONata. POST /auth/kpis/refresh forces immediate recalculation. Setup guide: docs/GRAFANA_KPI_SETUP.md.

• Documentation: Postman Workspace
• Authentication: JWT Bearer tokens
• Rate Limiting: 60/min, 1000/hr, 10000/day (configurable per-endpoint)
• Response Format: JSON via api_response() / api_error() helpers with consistent status codes

• Events service only — real-time event updates via Quart WebSocket routes

• Python 3.13
• Docker & Docker Compose
• Google Cloud SDK (for production)

# Clone repository
git clone https://github.com/PartyScene/backstage.git
cd backstage

# Copy environment config
cp .env.example .env
# Fill in: SURREAL_URI, REDIS_URI, RABBITMQ_URI, GCS_BUCKET_NAME, etc.

# Start infrastructure + services
docker network create cloudbuild
docker-compose up -d

# Run tests (per service)
docker-compose -f docker-compose.test.yml up -d rabbitmq surrealdb redis
docker-compose -f docker-compose.test.yml run --rm microservices.auth

# Access
# SurrealDB: http://localhost:8000
# RabbitMQ Management: http://localhost:15672

# Connect to GKE cluster
gcloud container clusters get-credentials backstage-cluster \
  --zone us-central1 --project partyscene-441317

# Build and deploy all services (Cloud Build)
gcloud builds submit .

# Check status
kubectl get pods
kubectl logs -l app=auth --tail=100

• Installation Guide
• Quick Start Testing
• CI/CD Implementation Guide
• Cloud Build Guide
• Windows Testing Guide
• Grafana KPI Setup
• API Documentation

• ✅ User registration and authentication (email/password, Google SSO, Apple SSO)
• ✅ Event creation with geospatial discovery and trending algorithm
• ✅ Multi-tier ticketing with Stripe + Paystack payments
• ✅ Media pipeline (image/video compression, thumbnails, BlurHash)
• ✅ Live streaming with GetStream.io (Video + Chat)
• ✅ Social features (friends, blocks, posts, comments, guestlists)
• ✅ Notification system (Novu — OTP, welcome, friend requests, event reminders, ticket purchases)
• ✅ KPI tracking system with Grafana integration
• ✅ Mobile apps (iOS & Android) released

• 🔄 Expand AI recommendations (R18E content moderation, user preference learning)
• 🔄 Push notifications via Novu mobile channels
• 🔄 Event analytics dashboard for organizers
• 🔄 Enhanced content discovery feeds
• Target: 5,000 MAU, $5K MRR

• 📅 Premium organizer subscriptions ($29/month)
• 📅 Business accounts for venues ($99/month)
• 📅 Promotional features and sponsored listings
• 📅 Advanced analytics and reporting
• Target: 25,000 MAU, $25K MRR

• 📅 API integrations for third-party platforms
• 📅 Advanced streaming (multi-camera, RTMP ingest)
• 📅 Enterprise security and compliance tooling
• 📅 ML-powered content moderation (r18e expansion)
• Target: 100K+ MAU, $100K+ MRR

1. Transaction Fees: 3-5% on paid event tickets (Stripe + Paystack, dual-market coverage)
2. Premium Subscriptions:
   • Organizer Pro: $29/month (enhanced analytics, promotion)
   • Business: $99/month (multi-venue management, API access)
3. Promotional Features:
   • Featured event listings: $50-200
   • Targeted advertising: CPM-based
4. Data Services: Anonymized event trend reports for businesses

• CAC (Customer Acquisition Cost): $8-12
• LTV (Lifetime Value): $45-60 per user
• LTV:CAC Ratio: 4.5:1 (target)
• Break-even: Projected 18-24 months

Key Advantage: Only platform combining HNSW vector recommendations, geospatial event discovery, integrated livestreaming with geofenced roles, and dual-market payments (Stripe + Paystack) in a single social events ecosystem.

• Launch: October 17, 2025 (iOS & Android)
• Waitlist: 50+ users (pre-launch, minimal marketing)
• Social: 89 Instagram followers (organic growth)
• Product Hunt: Projected top 10-15 for launch day

Seed Round: Seeking $1-2M to accelerate product development and market entry

• Product Development (40%): R18E deployment, enhanced features, UX improvements
• Marketing & Growth (35%): User acquisition, partnerships, Africa market expansion
• Infrastructure (15%): Scaling, monitoring, security hardening
• Team Expansion (10%): Frontend developers, product manager

• Month 6: 10K users, 1K events created, R18E recommendations live
• Month 12: 50K users, $50K MRR
• Month 18: 150K users, $200K MRR, break-even trajectory

• Performance-first: Rust-based ASGI server (Granian), Rust JSON (orjson), Rust HTTP (rusty-req), Rust storage (obstore) — zero-overhead Python where it matters
• Database as application layer: 17 SurrealDB stored functions replace thousands of lines of application ORM code — graph traversal, trending scores, geo queries, vector similarity, and ticket management all computed server-side
• Security in depth: Envelope encryption for PII, Argon2 at the database level, atomic Lua-based rate limiting, webhook signature verification, GDPR deletion automation
• Observable from day one: Prometheus counters wired at every business event, SurrealDB aggregate KPIs, Grafana-ready endpoint — investor metrics without third-party analytics

• Backend Engineering: Python microservices, async architecture, Rust toolchain integration
• Cloud Infrastructure: GCP, Kubernetes, Docker, Cloud Build production pipelines
• Databases: SurrealDB (graph, vector, geo), Redis, connection pooling
• DevOps: 9-stage CI/CD, blue-green deploys, automated rollback
• Payments: Dual-provider integration (Stripe + Paystack), webhook-driven architecture

Repository: GitHub - PartyScene/backstage API Docs: Postman Workspace Status: Production, actively deployed on GKE License: Proprietary software. All rights reserved.