Schedulo

Overview#

Schedulo is a comprehensive multi-tenant booking and resource management platform designed for service-based businesses. Built with Laravel 12 and modern web technologies, this SaaS solution provides complete tenant isolation, flexible subscription plans, and an intuitive booking interface. Perfect for salons, spas, cabin rentals, and other businesses that need to manage bookings, resources, and customer relationships at scale.

Note: This project is currently in active development. A live demo version is not yet available, but the codebase demonstrates full-stack Laravel development with modern best practices.

Key Features#

🏢 Multi-Tenant Architecture#

Complete tenant isolation:

• Dedicated data - Each tenant has isolated database records
• Custom URLs - Unique booking URLs per tenant (e.g., yoursite.com/salon-rosa)
• Tenant-specific branding - Customizable appearance per business
• Secure isolation - No data leakage between tenants
• Scalable design - Architecture supports unlimited tenants

📦 Resource Management#

Flexible resource system:

• Create and manage bookable resources
• Support for multiple resource types (rooms, equipment, staff)
• Resource availability scheduling
• Capacity management
• Resource-specific pricing
• Custom attributes per resource type

📅 Booking System#

Intuitive booking interface:

• Real-time availability - Instant feedback on booking slots
• Conflict prevention - Automatic detection of double bookings
• Flexible duration - Support for various booking lengths
• Customer information - Capture essential booking details
• Booking management - View, edit, and cancel bookings
• Status tracking - Pending, confirmed, completed, cancelled

💳 Subscription Plans#

Feature-based access control:

• Multiple pricing tiers - Flexible plan options
• Feature gating - Control access based on subscription
• Resource limits - Limit bookings/resources per plan
• Upgrade/downgrade - Easy plan switching
• Trial periods - Optional trial functionality
• Plan comparison - Clear feature differentiation

🔐 User Authentication#

Secure authentication system:

• Laravel Breeze - Lightweight authentication scaffolding
• Role-based permissions - Admin, staff, customer roles
• Secure registration - Email verification support
• Password reset - Secure password recovery
• Session management - Secure session handling
• CSRF protection - All forms protected

📱 Responsive Design#

Mobile-first approach:

• Tailwind CSS - Utility-first styling
• Responsive layouts - Works on all devices
• Touch-optimized - Mobile-friendly interactions
• Fast loading - Optimized assets with Vite
• Modern UI - Clean, professional design

⚡ Real-time Validation#

Client-side validation:

• Alpine.js - Lightweight JavaScript framework
• Instant feedback - Validate as users type
• Error messages - Clear, helpful validation messages
• Form enhancement - Progressive enhancement approach
• Server-side backup - Double validation for security

Technical Implementation#

Backend Architecture#

Laravel 12:

• Modern PHP 8.3 features
• Eloquent ORM for database operations
• Service layer for business logic
• Repository pattern for data access
• Event-driven architecture

Database:

• MySQL 8.0 for relational data
• Optimized indexes for performance
• Foreign key constraints for integrity
• Soft deletes for data retention
• Migration-based schema management

Authentication:

• Laravel Breeze for scaffolding
• Bcrypt password hashing
• Session-based authentication
• Remember me functionality
• Password reset via email

Frontend Stack#

Vite:

• Next-generation build tool
• Hot module replacement (HMR)
• Optimized production builds
• Asset bundling and minification

Tailwind CSS:

• Utility-first CSS framework
• Custom design system
• Responsive breakpoints
• Dark mode support (planned)
• PurgeCSS for minimal bundle size

Alpine.js:

• Lightweight JavaScript framework
• Declarative syntax
• Reactive data binding
• Component-based architecture
• Minimal overhead

Blade Templates:

• Laravel's templating engine
• Component-based views
• Template inheritance
• XSS protection built-in
• Efficient rendering

Database Schema#

Tenants:

{
  id: bigint;
  name: string;
  slug: string (unique);
  plan_id: bigint;
  settings: json;
  created_at: timestamp;
  updated_at: timestamp;
}

Resources:

{
  id: bigint;
  tenant_id: bigint;
  name: string;
  type: string;
  capacity: integer;
  price: decimal;
  available: boolean;
  created_at: timestamp;
  updated_at: timestamp;
}

Bookings:

{
  id: bigint;
  tenant_id: bigint;
  resource_id: bigint;
  customer_name: string;
  customer_email: string;
  start_time: datetime;
  end_time: datetime;
  status: enum;
  created_at: timestamp;
  updated_at: timestamp;
}

Plans:

{
  id: bigint;
  name: string;
  price: decimal;
  features: json;
  max_resources: integer;
  max_bookings: integer;
  created_at: timestamp;
  updated_at: timestamp;
}

Service Layer#

Business logic encapsulation:

• TenantService - Tenant management and isolation
• BookingService - Booking creation and validation
• ResourceService - Resource availability and management
• SubscriptionService - Plan management and feature gating
• NotificationService - Email and SMS notifications (planned)

Security Measures#

Comprehensive security implementation:

• CSRF protection on all forms
• SQL injection prevention via Eloquent ORM
• XSS protection in Blade templates
• Password hashing with bcrypt
• Environment-based configuration
• Input validation and sanitization
• Rate limiting on API endpoints
• Secure session management

Project Structure#

schedulo/
├── app/
│   ├── Http/Controllers/    # Request handling
│   ├── Models/              # Eloquent models
│   ├── Services/            # Business logic
│   └── Providers/           # Service providers
├── database/
│   ├── migrations/          # Schema definitions
│   └── seeders/             # Test data
├── resources/
│   ├── views/               # Blade templates
│   ├── js/                  # JavaScript files
│   └── css/                 # Stylesheets
├── routes/
│   ├── web.php              # Web routes
│   └── api.php              # API routes
├── public/                  # Public assets
└── tests/                   # Test suite

Development Workflow#

Setup Process#

1. Clone repository and install dependencies
2. Configure environment variables
3. Run database migrations
4. Seed initial data (plans, demo tenants)
5. Build frontend assets
6. Start development server

Code Quality#

PSR-12 Standards:

• Consistent code formatting
• Laravel Pint for automatic formatting
• Strict type declarations
• Comprehensive docblocks

Testing:

• Pest testing framework
• Feature tests for user flows
• Unit tests for business logic
• Database testing with factories
• Test coverage reporting

Cache Management#

Efficient caching strategy:

• Configuration caching
• Route caching
• View caching
• Query result caching
• Clear cache commands for development

User Experience Flow#

Tenant Registration#

1. Business signs up with details
2. Selects subscription plan
3. Creates custom booking URL
4. Sets up initial resources
5. Configures business settings

Resource Setup#

1. Admin adds resources (rooms, staff, equipment)
2. Sets availability schedules
3. Configures pricing
4. Defines capacity limits
5. Activates resources

Booking Process#

1. Customer visits tenant's booking URL
2. Browses available resources
3. Selects date and time
4. Provides contact information
5. Confirms booking
6. Receives confirmation (planned)

Admin Management#

1. View all bookings in calendar
2. Manage resources and availability
3. Handle customer requests
4. Generate reports (planned)
5. Manage subscription

Challenges & Solutions#

Challenge: Multi-Tenant Data Isolation#

Solution: Implemented global scopes in Eloquent models to automatically filter queries by tenant_id. Middleware ensures tenant context is set on every request, preventing data leakage.

Challenge: Real-time Availability#

Solution: Created efficient database queries with proper indexing. Booking conflicts are checked at both client and server level to prevent double bookings.

Challenge: Flexible Resource System#

Solution: Designed polymorphic resource system that supports multiple types (rooms, staff, equipment) with shared and type-specific attributes using JSON columns.

Challenge: Subscription Feature Gating#

Solution: Implemented middleware and service layer checks that verify plan features before allowing actions. Clear upgrade prompts guide users to higher tiers.

Challenge: Scalable Architecture#

Solution: Used Laravel's service container for dependency injection, repository pattern for data access, and event-driven architecture for extensibility.

Results#

• ✅ Complete multi-tenant architecture
• ✅ Flexible resource management system
• ✅ Real-time booking with conflict prevention
• ✅ Subscription-based feature gating
• ✅ Secure authentication and authorization
• ✅ Responsive mobile-first design
• ✅ Modern development workflow
• ✅ Comprehensive testing suite
• ✅ PSR-12 compliant codebase
• ✅ Production-ready architecture

Future Enhancements#

Planned Features#

• 📅 Advanced calendar view with drag-and-drop
• 📧 Email notifications for bookings
• 📱 SMS reminders via Twilio
• 💳 Payment integration (Stripe/Vipps)
• 👤 Customer portal for self-service
• 📊 Analytics dashboard with insights
• 📱 Mobile app (iOS/Android)
• 🔗 API for third-party integrations
• 🌐 Multi-language support
• 🎨 Custom branding per tenant

Lessons Learned#

This project provided valuable experience with:

• Multi-tenant architecture patterns
• Laravel 12 modern features
• Service-oriented architecture
• Database design for SaaS applications
• Subscription and billing logic
• Real-time availability systems
• Security best practices for multi-tenant apps
• Modern PHP 8.3 features
• Vite for asset bundling
• Alpine.js for reactive interfaces
• Testing strategies for complex applications
• Code quality and PSR standards
• Scalable application architecture

Schedulo demonstrates how Laravel can be used to build sophisticated SaaS platforms with multi-tenancy, subscription management, and complex business logic while maintaining clean, testable, and maintainable code.

Built with ❤️ by Marcus