Skip to content

Platform

Every problem solved once becomes a building block.

TGL builds reusable capabilities rather than one-off projects. A capability enters the library only after it has run in a real production deployment — so the library is a record of what has actually worked, not a catalogue of intentions.

These are not templates. They are composable components. Two businesses using the same invoicing capability get invoicing shaped to how each of them actually bills.

The library

36 capabilities across 6 domains.

Live

Identity & Access

Who someone is, and what they are allowed to reach.

  • Authentication
  • Identity provider
  • Roles & permissions
  • Tenant isolation
  • Session governance
  • Audit trail

Customer & Commerce

The record of the relationship and the money attached to it.

  • Customer management
  • Quoting
  • Invoicing
  • Payment processing
  • Subscriptions
  • Document generation

Operations

The work a business actually performs day to day.

  • Inventory
  • Scheduling
  • Fulfillment
  • Order processing
  • Warehouse & receiving
  • Workforce management

Communications

Reaching people reliably, with a record of what was sent.

  • Transactional email
  • Notifications
  • Templated messaging
  • Delivery logging
  • Preference management
  • Device provisioning

Data & Reporting

Turning operational records into answers.

  • Dashboards
  • Analytics
  • Reporting
  • Scheduled digests
  • Data export
  • Document management

Platform

The layer underneath everything else.

  • Data storage
  • Backups
  • Administrative systems
  • Workflow automation
  • Integration APIs
  • Monitoring & alerting

Where it comes from

The library is a byproduct of operating real businesses.

Each platform TGL built surfaced requirements. The ones that turned out to be universal became library entries; the ones that were genuinely industry-specific stayed with the product.

Lithos

B2B Operations Platform

Nearly every capability here generalized. Inventory, invoicing, document generation, carrier integration, role-scoped portals, and transactional email became the first entries in the TGL Capability Library — and the multi-tenant isolation model Lithos needed is now the pattern every TGL platform uses.

Iris

Health & Wellness Engine

Iris forced a rigorous approach to sensitive data: field-level encryption, decrypt-only-at-the-point-of-need, and access controls proven by testing what a given role can actually retrieve. That discipline now underpins the TGL data and security model.

Brutus

Restaurant & Commerce Engine

Commerce, payment handling, real-time operational state, and scheduling generalized directly into the Capability Library. Brutus also produced TGL's deployment discipline: these systems are busiest at night, which is why TGL builds against a running system and restarts only in a maintenance window.

MT Roots

Wealth Architecture Platform

Graph-shaped data modeling, document custody, and multi-surface delivery — one data layer serving a web app, an API, and a native desktop client from the same source of truth.

Mail Command Center

Managed Email & Device Infrastructure

Running mail rather than renting it taught TGL where the sharp edges of business communications infrastructure are — sender authentication, reputation, and the operational monitoring that catches a delivery problem before a customer reports it.

TGL Identity

Identity & Access Infrastructure

Identity is the dependency everything else sits on. Building it centrally is what makes tenant isolation enforceable rather than aspirational — every platform asks the same authority who someone is and what they may reach.

Client Portal

Customer Operations

The portal is the customer-facing half of the TGL operating model — and its tenancy, entitlement, and governed-notification patterns feed straight back into the Capability Library.

Where this is goingIn Development

The library is what makes SETH possible.

A conversational system that designs business infrastructure needs validated parts to build from. SETH's intended first move on any requirement is to check whether the library already solves it — generating something new only when nothing fits, and sending that back for human review before it becomes permanent.