Skip to content

Aurora Hub.

A scalable operational platform designed to unify service management, dealer networks, and business workflows. Multi-tenant SaaS architecture for real-world dealership operations.

Client
Aurora Vehicles Inc. (dashcams & accessories) · Vancouver, BC
Year
2025 — now
Stack
Next.jsSupabasePostgreSQL
tenant_atenant_btenant_id = currenttenant_dROW LEVEL SECURITY

The outcome

Before

Dealers, installers and the head office juggled email, spreadsheets and separate tools — every service request was chased by hand.

After

9 dealers and 50+ users run on one platform: 600+ requests and CA$330K+ in business handled in one place, each dealer seeing only their own data.

CA$330K+Business volume managed through Aurora Hub
600+Service requests handled end to end
50+Active users across the network
9Dealers running on one platform

Under the hood

RLS-enforcedTenant isolation
4Modules on one core
3Role & permission tiers
0Cross-tenant data leaks

01 / The Problem

Service-based businesses struggle with fragmented systems — CRM, operations, tracking — all disconnected. This creates inefficiency, data inconsistency, and manual workarounds that slow down growth.

02 / The Solution

Aurora Hub combines all operational layers into a modular, extensible core system. One platform for dealers, service providers, and managers. Event-driven architecture enables scalable, maintainable growth.

What Aurora Hub does

Multi-tenant architecture

Isolated data per organization with shared infrastructure

Unified CRM & operations

Service management, dealer access, and workflows in one core

Modular system design

Extensible modules that plug into the core without refactoring

How it flows

  1. Step 01

    Dealer onboards

    Unique codes, emails, and role-based access

  2. Step 02

    Service providers connect

    Link to dealer network and workflows

  3. Step 03

    Operations run unified

    CRM, tasks, and tracking in one place

  4. Step 04

    Data stays consistent

    Single source of truth across modules

Architecture & Technical Design

The shape of the system

architecturetext
// Core system structure
Core System
├── Auth & Identity (multi-tenant)
├── Dealer Management Module
├── Service Operations Module
├── Event Bus (internal)
└── Database Layer (PostgreSQL)

// Event-driven flow
TaskCreated → AssignDealer → Notify → TrackProgress

Decisions

Key technical decisions

  1. 01

    Shared schema with row-level security for tenant isolation

    Rejected: Database-per-tenant · Schema-per-tenant

    RLS moves the isolation guarantee from application code into Postgres itself: a forgotten WHERE clause cannot leak data. One migration path serves every tenant, and cross-tenant admin reporting stays a normal query instead of a federation problem.

  2. 02

    Event-driven communication between modules

    Rejected: Direct service calls · Shared database triggers

    Dealer onboarding, notifications, and progress tracking subscribe to domain events instead of calling each other. New modules plug into the event bus without touching existing code — this is how the service-operations module shipped without a core refactor.

  3. 03

    PostgreSQL JSONB for module-specific payloads

    Rejected: Rigid per-module tables · Separate document store

    Core entities stay strictly relational (tenants, users, tasks), while module payloads that evolve quickly live in validated JSONB columns. One database, transactional writes, and GIN indexes keep lookups fast.

Code

Real code patterns

Row-level security: isolation enforced by the database

Every tenant-scoped table carries the same policy. SET LOCAL binds the tenant to the transaction, so pooled connections can never bleed context between requests.

Row-level security: isolation enforced by the databasesql
ALTER TABLE customers ENABLE ROW LEVEL SECURITY;

CREATE POLICY tenant_isolation ON customers
  USING (tenant_id = current_setting('app.tenant_id')::uuid);

-- The API sets the tenant once per request, inside the transaction
BEGIN;
SET LOCAL app.tenant_id = '9f3c2e1a-…';
SELECT * FROM customers ORDER BY created_at DESC LIMIT 50;
COMMIT;

Typed event bus: modules stay decoupled

The event map is a single source of truth for payload types, so a renamed field breaks the build instead of production. Notification and KPI modules were added later without modifying task code.

Typed event bus: modules stay decoupledtypescript
type DomainEvents = {
  'dealer.onboarded': { tenantId: string; dealerId: string };
  'task.created': { tenantId: string; taskId: string; assigneeId: string };
  'task.completed': { tenantId: string; taskId: string; durationMs: number };
};

// Handlers register against event names — the emitter never knows who listens
bus.on('task.created', async ({ tenantId, taskId, assigneeId }) => {
  await notifications.send(tenantId, assigneeId, { kind: 'task_assigned', taskId });
});

bus.on('task.completed', async ({ tenantId, durationMs }) => {
  await kpi.recordCompletion(tenantId, durationMs);
});

In production

Aurora Hub dealer access portal in production

The Aurora Hub dealer access portal, live at aurorahub.ca.

Why It Matters

Dealers and service providers get a unified experience. No more switching tools or reconciling spreadsheets. Operations scale with the business, not against it.

Next case study

EV SLA
→
Let's talk—Let's talk—Let's talk—Let's talk—

Work together

Curious how the rest was builtLet's talk.

The writing section covers the multi-tenant design in depth — or reach out directly.