Start a conversation
How we build

Precise architecture.
Endurance over expedience.

This is the detailed version. If you want the short one, the homepage has it.

Disciplines
5
Accessibility floor
WCAG 2.2 AA
Security target
OWASP ASVS L2 (internal)
Design system
Constitution v2.1
01The disciplines
  • 01

    Products

    Software KernelX owns, evolves and is still responsible for after the launch.

    Produces

    • A product with a roadmap, not a delivery
    • Versioning, migrations and upgrade paths
    • Documentation written for the next engineer
  • 02

    Platforms

    Multi-sided systems where several kinds of user meet the same data and must not corrupt it.

    Produces

    • Role and permission models enforced server-side
    • Transactional flows that survive a retried callback
    • An admin surface the operator can actually run
  • 03

    Systems

    Operational software for a real process that currently lives in spreadsheets, inboxes and memory.

    Produces

    • A single source of truth for the process
    • Workflow, audit trail and reporting in one model
    • Migration from whatever the process is today
  • 04

    Infrastructure

    The layer underneath: delivery, storage, identity, jobs, and the machinery that has to be correct.

    Produces

    • Idempotency and crash-safety as design requirements
    • Deployment models that include self-hosting
    • Observability and audit logging from day one
  • 05

    Automation

    Removing manual work where the rules are knowable — and refusing to automate where they are not.

    Produces

    • Deterministic pipelines before probabilistic ones
    • Data handling classified before it is processed
    • A human in the loop wherever a mistake is expensive
02What we refuse

A standard is only real if it costs you something to keep.

  • 01

    We do not weaken a control to make a demo work

    No disabled auth middleware, no skipped validation, no TLS verification turned off for convenience. A shortcut taken quietly becomes the architecture.

  • 02

    We do not collect data because it might be useful later

    Collection is justified before it happens, classified before it is stored, and given a retention period before anyone queries it.

  • 03

    We do not add a dependency without a reason

    Every package is weight, attack surface and a maintenance obligation. If a few dozen lines do the job, we write the few dozen lines.

  • 04

    We do not overengineer to look advanced

    Distributed architecture without a distributed problem is a cost with no benefit. The goal is the simplest architecture that is genuinely strong enough.

How the software is engineered matters more than how it looks.

Eight commitments. Each one carries the practice that makes it checkable by someone who did not write it.

  1. 01

    Privacy

    Collect less, expose less, store less, share less.

    Data is classified before it is stored, retention is decided before collection, and confidential data never reaches a log line or a third-party model.

  2. 02

    Security

    Security is architectural, not a feature added late.

    Authorization is enforced on the server, always. The client is treated as hostile input. No control is ever weakened to make a demo work.

  3. 03

    Reliability

    A system that fails quietly has already failed.

    Operations that can be retried are made idempotent. Failure states are designed. Restores are tested, not assumed.

  4. 04

    Maintainability

    The next engineer is the real user.

    Every dependency justifies its existence. Architecture is chosen for the problem's actual risk and lifespan, not for how advanced it sounds.

  5. 05

    Performance

    Speed is measured, not asserted.

    Budgets are set before the build and enforced by measurement. Animation stays on the compositor. Weight that cannot justify itself is removed.

  6. 06

    Usability

    Clarity outranks cleverness, every time.

    Hierarchy is carried by typography and space. Errors say what happened, what it means, and what to do next. Nothing manipulates the user.

  7. 07

    Accessibility

    No user is excluded to achieve another goal.

    WCAG 2.2 AA is the floor, not the target. Every surface is driven by keyboard before it ships. Focus is never removed.

  8. 08

    Longevity

    It should still make sense in five years.

    Endurance over expedience. Vendor lock-in is a design decision, made deliberately or not at all. Documentation ships with the system.

Every system gets the same spine.

Not a product architecture — the shape KernelX builds to, whatever the product turns out to be.

  1. L4InterfaceWhat the user touchesTreated as untrusted input. Convenient, never authoritative.
  2. Trust boundary
    L3ApplicationRules, workflow, state transitionsAuthorization is enforced here. Always server-side, no exceptions.
  3. L2DataThe record of what is trueClassified before it is stored. Retention decided before collection.
  4. L1AuditWho did what, and whenAppend-only. Never carries the confidential data it describes.
  5. L0OperationsBackups, restores, observabilityA restore that has not been tested is not a backup.

Data classification

K0Public
Publishable without review.
K1Internal
Ordinary operational data.
K2Confidential
Never in a log line.
K3Restricted
Never leaves the system.

Data is classified before it is collected, not after an incident.

Decisions on the record

  • Sessions are signed with jose and held in an httpOnly cookie — no external session store, so the deployment has one fewer moving part to operate and one fewer place for identity data to sit.

    KAMS

  • Postgres is both the database and the delivery queue. No broker, no Redis — which makes delivery state transitions transactional, and that is precisely where duplicate sends are born in broker-based systems.

    KernelX Relay

  • The parser is deterministic and client-side. Your schema never leaves the browser, which is the only version of this tool a KernelX engineer would be willing to paste a production DDL into.

    SQL → ER