Flagship owned product

QZee

How QZee evolved from a booking product into a shared operating system for customers, venues and events.

2023 to present · owned product · product strategy, design and engineering · QZee Ltd

Product
Booking marketplace and owner operating system
Leadership
Cameron Calder: product strategy, research, interaction design and product system. Joel Parfitt: architecture, integrations and platform delivery.
Delivery
Six maintained repositories across web, native, API and shared system
Status
Live product with implemented and exploratory extensions clearly separated
QZee One portal mapping web, native apps, email, marketing and brand around a shared semantic core
Live QZee One system portal · captured 14 July 2026QZee One makes the platform visible as a governed system: shared contracts at the centre, channel-specific implementations around them, and evidence beside every claim.

Traction source: public June 2025 milestone. Repository figures are a delivery-scale snapshot, not evidence of customer value or commercial outcome.

The difficult part started after booking worked

A useful booking flow solved one moment. A dependable product had to connect every moment around it.

QZee began with a recognisable two-sided problem. Customers needed a clear way to find a service, trust that a time was genuinely available and finish a booking. Owners needed to describe what they sold, control when it could be booked and see the confirmed result in an operational diary. Solving either side alone would have produced another disconnected calendar or directory.

The scope expanded because real service businesses do not operate as a tidy list of appointments. A service can depend on a venue, staff member, add-on, group size, consultation answer, payment rule or closure. Availability can be entered manually or generated from recurring rules. A successful charge can still be followed by a failed booking write. Events introduce capacity, ticket quantities and different discovery behaviour, while owners still need the result to land in the same customer, transaction and notification model.

The product therefore became a connected operating system. The customer web app owns discovery and conversion. The owner product owns configuration and day-to-day control. Separate Customer and Business GraphQL boundaries protect the intent of each audience while sharing domain rules underneath. Jobs and integrations handle reminders, cleanup, migrations, imports, payment recovery and calendar coordination. Marketing, support and pricing explain the same capabilities before a user enters either application.

That growth created a second problem: consistency. The design-system repository records an internal audit finding of more than 4,000 hard-coded colour values, while its foundation documents identify two different live brand limes. QZee One was built in response, not as a cosmetic refresh. It turns product language, tokens, components, channel coverage and evidence into an inspectable operating layer for the whole company.

  1. 2023

    The service layer comes first

    The API establishes the shared booking domain, customer and business access boundaries, integrations and asynchronous work that later products can reuse.

  2. 2024

    Customer and owner products connect

    Discovery, availability and checkout meet catalogue setup, customer records, transactions and calendar operations across two focused web applications.

  3. 2025

    Operations deepen and events expand the model

    Generated scheduling, holds, payment recovery, events, waitlists and richer owner controls turn isolated booking screens into a broader operating workflow.

  4. 2026

    QZee One makes the product system executable

    Shared semantic contracts, platform adapters, evidence records, a public portal and release gates expose both coverage and unfinished work across channels.

Every surface, with its maturity stated

The map distinguishes what people can use now from what is built, demonstrated or still being explored.

Capability status definitions

  • LiveAvailable in a public or deployed product.
  • ImplementedBuilt, but release or approval is not evidenced.
  • DemonstrationA labelled example using simulated data.
  • ExploratoryResearch, specification or prototype only.
Live

Customer marketplace

The public booking experience joins business discovery to a stateful checkout and post-booking relationship.

  • Venues, services, staff and add-ons
  • Availability, slot holds and requested times
  • Forms, terms, coupons, payment and confirmation
  • Cancellation, refunds, reviews and calendar actions

Repositoryqzee-slots-web-app

Live

Owner operating system

The business application connects configuration, daily operations, customer context and money in one model.

  • Dashboard, calendar, closures and booking requests
  • Services, venues, staff, add-ons and categories
  • Customers, notes, transactions and refunds
  • Coupons, forms, notifications and onboarding

Repositoryqzee-slots-owners-app

Live

Events and waitlists

Event discovery and ticketing extend the shared identity, venue, capacity, payment and communication foundations.

  • Public event discovery
  • Capacity and ticket selection
  • Owner event controls
  • Waitlist and notification paths

Repositoryqzee-slots-web-app + qzee-slots-owners-app

Implemented

Business native application

A native business interface is implemented around the shared owner core, but public store release is not evidenced.

  • Shared typed domain and data layer
  • Native navigation and interaction patterns
  • Business operations on mobile
  • Release work awaiting store and approval dependencies

Repositoryqzee-mono-mobile

Live

Platform services

The API holds the shared domain, security boundaries, integrations and recovery work behind customer and business products.

  • Customer and Business GraphQL schemas
  • Stripe Connect, Mailgun, R2 and Firebase adapters
  • Google Calendar and Places integrations
  • SQS and Lambda-style jobs, cleanup and migrations

Repositoryqzee-api

Live

Marketing, support and acquisition

The public site carries product positioning, pricing, guidance, support, legal content and event acquisition into the applications.

  • Customer and business propositions
  • Pricing and product guidance
  • Support and legal surfaces
  • Event acquisition routes

Repositoryqzee-web

Live

QZee One product system

A public, repository-backed system governs semantic contracts and records how each channel implements them.

  • Tokens and web and native UI packages
  • Email and marketing primitives
  • CLI, registry, documentation and evidence
  • Fourteen automated quality gates

Repositorydesign-system

Exploratory

Standalone customer app prototype

A mock-backed Expo prototype tests a possible native customer experience. It has no evidenced release or active remote.

  • Native discovery concepts
  • Booking interaction experiments
  • Proposed reuse of the existing API
  • No claim of live customer availability

Repositorycustomer-app

Exploratory

QZee Together

Research and specification explore a broader consumer proposition. This is not a repository-backed or released product.

  • Problem-space research
  • Experience and service concepts
  • Specification work
  • No live-product claim

Three journeys, one underlying product model

Customer, owner and event interfaces stay focused on different jobs while exchanging the same operational truth.

From intent to a dependable booking

  1. DiscoverFind a business, service, staff member or suitable event.
  2. ConfigureChoose venue, add-ons, party size and a valid time.
  3. QualifyComplete conditional forms, terms and identity requirements.
  4. CommitPlace a hold, apply a coupon and pay or choose pay at venue.
  5. ContinueReceive confirmation, calendar details and post-booking controls.

From business rules to daily operations

  1. ModelSet services, venues, staff, add-ons, forms and payment rules.
  2. ScheduleEnter slots manually or generate them from recurring availability.
  3. OperateReview requests, bookings, closures, customers and notes.
  4. ReconcileTrack transactions, refunds, coupons and Stripe Connect state.
  5. ImproveUse operational context without splitting it across separate tools.

The owner calendar is the operational destination, not a disconnected copy of customer availability.

From publishing capacity to admitting a customer

  1. PublishDefine the event, venue, dates, capacity and ticket choices.
  2. FindExpose a dedicated event discovery route to customers.
  3. ReserveSelect quantities against current capacity and create a hold.
  4. PayComplete payment inside the existing identity and transaction model.
  5. ManageReturn attendees, waitlists and notifications to owner operations.

The connected product in use

Current public captures and a direct Owners application capture show how acquisition, booking, events and operations express the same platform at different moments.

QZee public website presenting the connected customer and business booking platform
Live public product · captured 14 July 2026The acquisition layer explains one proposition across customer booking, business operations, payments and events.
QZee customer booking product showing service discovery and availability
Live customer product · captured 14 July 2026This public state proves service discovery and the route into booking. Availability, forms, terms and payment are supported separately by repository evidence.
QZee events product showing public event search, category filters and an empty result state
Live events product · captured 14 July 2026This dated empty state proves the public event search, filters and host route. It does not show live event inventory or a completed ticket purchase.
QZee Owners services workspace showing catalogue controls, add-ons, categories and broader owner navigation
Actual QZee Owners interface · captured 14 July 2026A direct capture from the Owners application shows the empty Services workspace, category and add-on controls, auto-scheduling status, and broader owner navigation.

Six maintained repositories, with clear boundaries

Repository boundaries follow audience and runtime responsibilities. Shared domain contracts connect them without turning the system into one undifferentiated application.

Maintained product-system repository

design-system

Live

Owns QZee One semantic contracts, tokens, channel packages, registry, documentation, evidence and automated gates.

  • TypeScript
  • React
  • React Native
  • CLI
  • Static portal

Public portal and generated health evidence available.

Explore QZee One (opens in a new tab)

Maintained platform repository

qzee-api

Live

Owns shared booking, event, identity and payment domains behind separate Customer and Business GraphQL APIs, plus integrations and jobs.

  • TypeScript
  • GraphQL
  • MongoDB
  • Firebase
  • Stripe
  • SQS

Production service layer used by customer and owner products.

Maintained customer repository

qzee-slots-web-app

Live

Owns public discovery, booking, requested times, event ticketing, waitlists and post-booking customer actions.

  • React
  • Vite
  • Apollo
  • Firebase
  • Stripe

Public booking and event routes available.

Open customer bookings (opens in a new tab)

Maintained business repository

qzee-slots-owners-app

Live

Owns catalogue setup, scheduling, calendar operations, customers, transactions, events, waitlists and onboarding for businesses.

  • React
  • Vite
  • Apollo
  • Firebase
  • Chakra UI

Dated public owner walkthrough and repository-backed workflows.

Maintained cross-platform repository

qzee-mono-mobile

Implemented

Holds the business native application and a typed, UI-agnostic owner core shared with web while keeping renderers platform-specific.

  • TypeScript
  • React
  • React Native
  • Expo
  • Workspace packages

Implementation is evidenced. Store publication is not claimed.

Maintained public-web repository

qzee-web

Live

Owns marketing, support, pricing, guides, legal content and acquisition paths that route people into the product.

  • Next.js
  • React
  • TypeScript
  • QZee One packages

Public website available.

Visit QZee (opens in a new tab)

Adjacent prototype

customer-app

Exploratory

Tests a standalone native customer direction with mock-backed screens and a proposed connection to the existing API.

  • Expo
  • React Native
  • Mock data

No active remote or public release is evidenced.

Adjacent research track

QZee Together research

Exploratory

Documents a possible future consumer direction without presenting research artefacts as implemented product scope.

Specification and research only. No Git repository is claimed.

The decisions that let the system grow without hiding its cost

Each choice protects a specific boundary. Each also creates work that the team has to own.
  1. Model the offer before the diary

    Decision
    Separate services from add-ons inside one catalogue, organise both through categories and an explicit uncategorised state, and let owners connect add-ons to the services where they make sense.
    Why
    Customers need to understand what a business sells before they choose a time. Owners need one model that can express a simple appointment, a richer package or an optional product without rebuilding the booking flow.
    Consequence
    Catalogue structure now feeds both the owner setup experience and the customer offer, keeping the commercial model upstream of scheduling.
    Tradeoff
    Custom ordering is currently local because the API does not yet persist an order field. The interface must not imply that ordering survives every session.
  2. Replace ambiguous setup with state-derived guidance

    Decision
    Derive Setup Guide completion and next-action priority from real business, venue, service and slot records, with the sequence adapting to the owner's scheduling mode.
    Why
    A generic dashboard could show activity without explaining what prevented a business from becoming bookable. The product needed to turn missing configuration into specific, ordered work.
    Consequence
    Owners receive a canonical route from minimum setup to a shareable live offer, and completed work is recognised from product state rather than a disposable checklist.
    Tradeoff
    Guidance logic has to evolve with every underlying capability or it can become confidently out of date.
  3. Make the calendar an operational control surface

    Decision
    Use one timezone-aware calendar core across day, week, month and agenda views, then support optimistic drag, resize and gesture creation behind collision checks and protected destructive actions.
    Why
    Owners do not only inspect availability. They resolve clashes, move work, create capacity and protect confirmed bookings while context changes around them.
    Consequence
    The diary supports fast direct manipulation while the product still refetches authoritative state when an optimistic action conflicts.
    Tradeoff
    Responsive navigation, timezones and recovery from rejected gestures add interaction and test complexity to a surface used under time pressure.
  4. Gate onboarding by task readiness

    Decision
    Branch onboarding by business intent, derive access from real setup state and direct unfinished businesses to the next useful task instead of presenting one linear tour.
    Why
    A venue, service business and schedule-driven operator can require different minimum records before the same protected workspace becomes useful.
    Consequence
    The wizard and access guard turn onboarding into product-state progression, so completed work unlocks the relevant operating surface and missing work remains actionable.
    Tradeoff
    Readiness rules span routes and domain records, so they must evolve with the product or they can block valid work and misdirect returning owners.
  5. Separate customer and business API boundaries

    Decision
    Expose distinct Customer and Business GraphQL schemas over shared domain use cases and adapters.
    Why
    Customers and operators have different permissions, language and task shapes. One public schema would make those differences easy to blur.
    Consequence
    Each application receives an API designed around its intent while booking, identity, availability and payment logic remain shared underneath.
    Tradeoff
    Boundary maintenance and schema coordination require more deliberate work than one broad API surface.
  6. Treat availability as a lifecycle

    Decision
    Support both manual slots and generated availability, then use temporary holds and materialise selected generated availability as a persisted slot.
    Why
    Some businesses curate exact sessions while others depend on repeatable schedules. Both still need protection against competing checkout attempts.
    Consequence
    Owners can choose the scheduling model that fits their operation, and customers receive bookable state rather than a decorative calendar.
    Tradeoff
    Generation, expiry, conversion and cleanup add state transitions that must be observable and recoverable.
  7. Design payment failure after the happy path

    Decision
    Model deposits, coupons, refunds, Stripe Connect webhooks, post-charge recovery and fraud reversal as explicit platform work.
    Why
    A payment provider can confirm money before another system action completes. Treating checkout as one request would leave customers and owners with conflicting truth.
    Consequence
    Recovery jobs and reconciliation paths can repair partial states instead of relying on manual database intervention.
    Tradeoff
    Financial state remains one of the most complex parts of the product and demands ongoing operational evidence.
  8. Share the owner core, not every interface

    Decision
    Place typed domain, data and use-case logic in a UI-agnostic core while web and native products keep platform-specific presentation.
    Why
    Business rules should not diverge, but a calendar, navigation model or interaction that works on desktop should not be forced onto a phone.
    Consequence
    Web and native can reuse contracts and behaviour without pretending that their interfaces are interchangeable.
    Tradeoff
    Two renderers still require design, implementation and testing rather than being generated from one screen tree.
  9. Formalise contracts and adapters over a universal runtime

    Decision
    Evolve QZee One around shared semantic intent, then implement it through independent web, native, email and marketing adapters.
    Why
    A universal component runtime would reduce visible duplication but also flatten accessibility, interaction and technical constraints that genuinely differ by channel.
    Consequence
    Channels can express one product language through the right primitives, with one-way dependencies protecting the core.
    Tradeoff
    Parity has to be measured and maintained because implementation is intentionally distributed.
  10. Keep one system repository

    Decision
    Version QZee One contracts, packages, registry, documentation and gates together rather than creating an independent repository for every channel.
    Why
    The evidence, terminology and compatibility story need one reviewable change history to stay coherent.
    Consequence
    A contract change can update implementation status and release evidence in the same pull request.
    Tradeoff
    Repository governance must prevent channel concerns from leaking back into the semantic core.
  11. Publish gaps as product information

    Decision
    Record required-channel parity, evidence coverage and named gaps in generated health output instead of presenting the system as complete.
    Why
    A design system that only displays finished examples cannot guide sequencing or support trustworthy release decisions.
    Consequence
    Teams can see where a contract exists, where a channel implements it and where evidence is still missing.
    Tradeoff
    The public health view exposes unfinished work, which is more useful but less cosmetically perfect.

The system is valuable because it can say what is missing

QZee One converts product consistency from an aspiration into contracts, adapters, evidence and release gates.

QZee One begins with semantic intent: what a colour means, what a control promises, how a status is communicated and which channels are required to support it. Web, native, email and marketing packages implement those contracts with their own accessible primitives. A registry links assets to owners and maturity. A CLI and fourteen automated quality gates in the release pipeline test the rules. The portal lets contributors inspect the same system without reading package source first.

The proposed architecture decision formalises an emerging contract-and-adapter model rather than a universal runtime that attempts to render one component everywhere. Shared pixels would hide meaningful differences in semantics, interaction, layout and platform capability. The emerging model accepts implementation work in exchange for clearer responsibilities and better interfaces in each channel.

One operating model, without pretending every surface is finished

QZee now has a coherent route from customer intent to owner operations, with the platform and evidence needed to extend it deliberately.

The result is larger than a booking website. Customers can move through services, events, availability, requirements and payment. Owners can shape the offer, run the diary, understand customers and reconcile money. The API carries shared rules and recovery work between them. QZee One gives every channel a common language while making divergence visible.

The public June 2025 milestone provides a dated signal of use: 1,134 users, 77.74% quarterly growth and £15,453.36 in processed payment volume. It does not establish revenue, retention or long-term product-market fit. Repository scale shows sustained delivery, but it is context rather than outcome. The native business application remains implemented rather than claimed as publicly released. The standalone customer prototype and QZee Together remain exploratory.

The next chapter is therefore clear enough to test: close the highest-value parity and evidence gaps, complete release dependencies for implemented channels, deepen operational reliability and let customer evidence determine which exploratory ideas deserve production investment. The architecture is designed to support that growth without disguising uncertainty as progress.

Need one product across every channel?

Join customer journeys, operations, payments and infrastructure through one product build.

Discuss a project