Flagship owned product
QZee
How QZee evolved from a booking product into a shared operating system for customers, venues and events.
- 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

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
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.
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.
2024
Customer and owner products connect
Discovery, availability and checkout meet catalogue setup, customer records, transactions and calendar operations across two focused web applications.
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.
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
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.
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
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
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
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
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
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
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
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
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
From intent to a dependable booking
- DiscoverFind a business, service, staff member or suitable event.
- ConfigureChoose venue, add-ons, party size and a valid time.
- QualifyComplete conditional forms, terms and identity requirements.
- CommitPlace a hold, apply a coupon and pay or choose pay at venue.
- ContinueReceive confirmation, calendar details and post-booking controls.
From business rules to daily operations
- ModelSet services, venues, staff, add-ons, forms and payment rules.
- ScheduleEnter slots manually or generate them from recurring availability.
- OperateReview requests, bookings, closures, customers and notes.
- ReconcileTrack transactions, refunds, coupons and Stripe Connect state.
- 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
- PublishDefine the event, venue, dates, capacity and ticket choices.
- FindExpose a dedicated event discovery route to customers.
- ReserveSelect quantities against current capacity and create a hold.
- PayComplete payment inside the existing identity and transaction model.
- 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.




Six maintained repositories, with clear boundaries
Maintained product-system repository
design-system
LiveOwns 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
LiveOwns 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
LiveOwns 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
LiveOwns 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
ImplementedHolds 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
LiveOwns marketing, support, pricing, guides, legal content and acquisition paths that route people into the product.
Adjacent prototype
customer-app
ExploratoryTests 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
ExploratoryDocuments 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
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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 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
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