Saraan Asim
Saraan Asim
Stage
0→1
Product
Operating system for coaching businesses
Dates
Jul 2026 to now
My part
Designed the architecture, built the coaching companion, led the team
Stack
Next.js, NestJS, PostgreSQL, pgvector, Redis, S3, AWS, Stripe, GoHighLevel
Live
kynosapp.com

Kynos OS

A governed six-layer operating system for coaching frameworks, content, a coaching companion, growth and analytics. Phase 1A is a 14-week controlled pilot and investor demo release.

Kynos home page with the headline 'Understand yourself. Put that understanding into practice.' on a blue background.
Fig. 1. Kynos's public home page.

0→1

The product

Kynos OS is a governed operating system for coaching businesses, in six layers: the source of truth, the client experience, a coaching companion, growth, content and intelligence. It has three front ends, a client app, an admin console and a partner portal. Phase 1A ships as a 14-week controlled pilot and an investor demo release.

What I built and led

The architecture. The six layers, how they map onto services and modules, and the AWS setup in the client’s own accounts. The full distributed architecture is in place from Phase 1A, so later phases add features without reshaping the system.

The coaching companion. The companion service on PostgreSQL with pgvector.

The team. I lead the team that builds the rest, with code review on its work. The hardest constraint is governance across all six layers.

How it works

It is a pnpm monorepo with three Next.js front ends and three NestJS runtimes: the core API, the coaching companion and a worker. The core API is a modular monolith holding four of the six layers. PostgreSQL with pgvector, Redis and S3 sit underneath, Stripe handles billing and GoHighLevel runs the growth workflows.

Three threads run through every layer. Every object and event carries an organisation id from day one. Every output binds to a governance policy version. And every layer writes standard events to a core event log, which the intelligence layer reads to trigger interventions and score content.

4 decisions

Decisions

  1. Three separate services

    Four of the six layers live inside the core API, because they share one database and bind to the same policy versions, and splitting them would only add network calls. The coaching companion is its own service because it scales differently and its language model can be swapped. The worker is its own runtime, so background jobs never block API requests.

  2. Modules talk through contracts

    Each module is a vertical slice with its own Postgres schema, and modules communicate only through shared contracts, ports and events. No module imports another's internals. A module can later move into its own service without changing its callers.

  3. Every output bound to a policy version

    Governance owns the versioned source of truth. Every companion response and every content output records the policy version it was produced under, so any answer can be traced back to the rules that applied.

  4. The core is the system of record

    PostgreSQL is authoritative for identity, entitlements, framework state, approvals and events. GoHighLevel runs funnel and pipeline workflows only, and language and voice providers sit behind adapters, so no outside tool owns the data.

Feature level

From the project record

Architecture

Frontend oneNext.jsFrontend twoNext.jsFrontend threeNext.jsCore APINestJSCoaching companionNestJS · pgvectorWorkerNestJSPostgreSQLpgvectorRedisS3 · AWSclient-ownedStripebillingGoHighLevelFrontend oneNext.jsFrontend twoNext.jsFrontend threeNext.jsCore APINestJSCoaching companionNestJS · pgvectorWorkerNestJSPostgreSQLpgvectorRedisS3 · AWSclient-ownedStripebillingGoHighLevel
Fig. 2. Three frontends over three NestJS services in one pnpm monorepo, on the client's own AWS accounts.

Result

Outcome

The Phase 1A pilot is running. Phase 1A is a 14-week controlled pilot and investor demo release, built on the full distributed architecture with only the Phase 1A features turned on inside it.

Looking back

What I’d change

I would define the governance rules before building. Governance runs through all six layers, since every companion answer and content output binds to a policy version. Writing those rules down first would have given each layer a fixed target from the start.