03 - Play The Event: Platform Overview for Event Management

Play The Event: A Complete Platform for Event Management

Play The Event is a full-stack event management platform designed to solve the real problems that individuals, associations, and companies face when organizing events. From birthday parties to corporate conferences, the platform provides a unified solution that replaces the patchwork of spreadsheets, messaging apps, and generic tools most organizers rely on today.

In this article, we explore the project from a high-altitude perspective: the technology stack, the architectural choices, the key features, and the numbers that define the scale of the system.

The Technology Stack

Every technical decision in Play The Event was made with a clear objective: build a system that is maintainable, scalable, and performant. The stack was chosen to maximize developer productivity while ensuring enterprise-grade reliability.

Backend: Spring Boot 3.4.5 + Java 21

The backend is built on Spring Boot 3.4.5 running on Java 21, leveraging the latest LTS features including virtual threads, pattern matching, and record classes. Spring Boot provides the foundation for dependency injection, security, data access, and RESTful API development.

BACKEND STACK

Framework:    Spring Boot 3.4.5
Language:     Java 21 (LTS)
Security:     Spring Security 6 + JWT (HttpOnly cookies)
Database:     MySQL 8.x
ORM:          Hibernate 6 / Spring Data JPA
Migrations:   Flyway
Build:        Maven
Testing:      JUnit 5 + Mockito + Testcontainers
API Docs:     SpringDoc OpenAPI 3
Validation:   Jakarta Bean Validation
Caching:      Spring Cache (Caffeine)
Logging:      SLF4J + Logback

Frontend: Angular 19

The frontend is a modern Angular 19 application using standalone components, signals for reactive state management, and lazy-loaded routes for optimal performance. The UI is designed with a mobile-first approach, ensuring a seamless experience on any device.

FRONTEND STACK

Framework:    Angular 19
Language:     TypeScript 5.6
State:        Angular Signals + RxJS
Routing:      Angular Router (lazy loading)
HTTP:         HttpClient with interceptors
i18n:         Custom multi-language system (21 languages)
UI:           Custom component library
Forms:        Reactive Forms + custom validators
Build:        Angular CLI + esbuild
Testing:      Jasmine + Karma

AI Microservice: Python FastAPI

A dedicated Python microservice built with FastAPI handles AI-powered features such as intelligent event suggestions, natural language processing for search, and automated categorization. This microservice communicates with the main backend via REST APIs.

Database: MySQL

MySQL 8.x serves as the primary data store. The schema is managed through Flyway migrations, ensuring reproducible and version-controlled database changes across all environments.

Key Features

Play The Event is not just another event tool. It is a comprehensive platform that covers the entire lifecycle of an event, from planning to post-event analysis. Visit www.playtheevent.com to see the platform in action.

Architecture Overview

The architecture of Play The Event follows three complementary patterns that work together to create a system that is both flexible and maintainable: Domain-Driven Design (DDD), Hexagonal Architecture, and CQRS.

PLAY THE EVENT - ARCHITECTURE LAYERS

1. DOMAIN LAYER (innermost)
   ├── Entities and Aggregate Roots
   ├── Value Objects
   ├── Domain Events
   ├── Repository Interfaces
   └── Domain Services

2. APPLICATION LAYER
   ├── Command Handlers (write operations)
   ├── Query Handlers (read operations)
   ├── Application Services
   ├── DTOs and Mappers
   └── Use Case orchestration

3. INFRASTRUCTURE LAYER
   ├── JPA Repository implementations
   ├── Database configuration
   ├── External service integrations
   ├── Email / notification services
   └── Flyway migrations

4. INTERFACES LAYER (outermost)
   ├── REST Controllers
   ├── Request / Response models
   ├── Exception handlers
   ├── Security filters
   └── API documentation

Each layer has a clear responsibility, and dependencies flow inward only. The domain layer has zero dependencies on frameworks or infrastructure, making it fully testable and portable.

The Numbers

To truly appreciate the scale of Play The Event, consider the following metrics that reflect months of development and refinement.

System Components

The platform is composed of several interconnected components, each serving a distinct purpose within the overall ecosystem.

PLAY THE EVENT - SYSTEM COMPONENTS

BACKEND (Spring Boot)
├── Auth Module         → JWT authentication, RBAC
├── Event Module        → Event CRUD, state machine
├── Participant Module  → RSVP, roles, check-in
├── Expense Module      → Budget tracking, splitting
├── Trip Module         → Logistics, itineraries
├── Notification Module → Email, in-app alerts
├── Document Module     → File upload, sharing
├── Survey Module       → Questionnaires, responses
└── Admin Module        → System administration

FRONTEND (Angular)
├── Auth Pages          → Login, register, password reset
├── Dashboard           → Overview, quick actions
├── Event Pages         → Create, edit, detail, list
├── Participant Views   → Management, RSVP tracking
├── Expense Views       → Budget, transactions, reports
├── Trip Views          → Itineraries, logistics
├── Public Pages        → Shared event pages
└── Settings            → Profile, preferences, language

AI SERVICE (FastAPI)
├── Event Suggestions   → Smart recommendations
├── NLP Search          → Natural language queries
└── Categorization      → Auto-tagging and grouping

What Makes It Different

Unlike existing solutions that either target enterprise clients with complex tooling or offer simplistic features for casual use, Play The Event sits at the intersection: powerful enough for professionals, simple enough for anyone.

In the Next Article

This overview provides the big picture, but the real depth lies in the architectural decisions. In the next article, we will dive deep into the Hexagonal Architecture, DDD, and CQRS patterns that form the backbone of Play The Event, examining how each layer is implemented and why these patterns were chosen over simpler alternatives.

Related deep dive: 01 - Il Problema che Ha Fatto Nascere Play the Event.

Related deep dive: 02 - Sviluppo Iterativo con OnStage: Primi Requisiti e Metodologia Agile.