EARLY ACCESS — FOUNDING BATCH

30 Hours of Architecture.
One Command.

The deterministic Next.js foundation with typed errors, hexagonal boundaries, and 5 audit gates enforced on every commit.

A deterministic Next.js foundation where every error is a typed Result, every dependency is inverted behind interfaces, and every commit passes 5 integrity gates before it exists. Not a starter kit — an engineering standard.

Lifetime license — $199 (Early Access)

No sales calls. No 30-min demos. Direct repository access upon approval.

THE ARCHITECTURAL BLUEPRINT

EXPLORER — STRICTKIT BLUEPRINT
32 FILES • 4 LAYERS
DOMAIN
APPLICATION
INFRASTRUCTURE
PRESENTATION
ARCHITECTURE.mdcore
Dockerfile
docker-compose.yml
vitest.config.mts
ci.yml

REAL STRUCTURE — NOT A MOCK. THIS IS THE REPO YOU CLONE.

A FOUNDER'S CONVICTION

Why StrictKit Exists

This project exists because throwing exceptions is a design failure.

We built this because we were tired of inheriting codebases where the first week is spent figuring out which exceptions are intentional and which are bugs. If that sentence resonates, you are in the right place.

THE ARCHITECTURAL GUARANTEES

The Three Pillars of Integrity

Result'<'T, AppError'>'

Zero-Throw Architecture

Every operation returns Result'<'T, AppError'>'. Errors are typed data with semantic codes — not stack traces you discover in production. The compiler enforces exhaustive handling. No function ever throws.

Domain → Interface → Infra

Hexagonal Sovereignty

Your business logic has zero knowledge of Supabase, Stripe, or any framework. Domain entities are pure. Use cases depend on interfaces. Infrastructure is a replaceable plugin — swap your database without touching a single line of domain code.

UserId ≠ LicenseId

Compile-Time Safety

Branded ID types prevent mixing UserId with LicenseId at compile time. UPPERCASE enum unions eliminate magic strings. Readonly entities make mutation impossible. Bugs that would surface in production are caught before the code runs.

ENFORCED ON EVERY COMMIT BY THE STRICTKIT CLI

The 5 Audit Gates

NO_ANY

Implicit `any` is a breach of contract with the compiler. If TypeScript surrenders, the build fails.

SECRET_SENTINEL

API keys, tokens, and credentials are intercepted before they reach version control. One leaked key is one career risk.

DOCKER_GATEKEEPER

Container images must be pinned to a specific digest. No `:latest` tags. Your attack surface is deterministic or it does not deploy.

CONSOLE_SILENCE

Production logs are legal evidence, not debug tools. Console statements in non-test code are stripped on sight.

DEPENDENCY_FREEZE

Lockfiles are law. Running `npm install` in CI is forbidden. Reproducible builds or the pipeline stops.

strictkit-blueprint — bash

WHAT SHIPS WHEN YOU CLONE

Technical Inventory

TECHNICAL_INVENTORY.log

[REPO] strictkit-blueprint — private, versioned, lifetime updates

[GATE] NO_ANY — implicit any blocked at pre-commit

[GATE] SECRET_SENTINEL — credentials intercepted before VCS

[GATE] DOCKER_GATEKEEPER — images pinned to digest, no :latest

[GATE] CONSOLE_SILENCE — production logs only, zero debug noise

[GATE] DEPENDENCY_FREEZE — lockfiles enforced, npm install blocked in CI

[INFRA] Supabase — Auth + Database + Row Level Security

[INFRA] Docker — Alpine images, pinned digests, compose orchestration

[INFRA] Stripe — Webhook handler, billing integration ready

[INFRA] Resend — Transactional email adapter behind interface

[DOCS] ARCHITECTURE.md — Full system specification

[DOCS] Vitest — Unit tests with use-case coverage

[DOCS] CI/CD — GitHub Actions pipeline with audit gates

[CI/CD] strictkit audit --json — Native pipeline integration. Run the same 5 gates in GitHub Actions, GitLab CI, or any CI/CD system. v0.2.0 ships with structured JSON output for automated enforcement.

THE COST OF NOT HAVING A STANDARD

Rational Pricing

30+ hours of architecture, configuration, and maintenance — replaced by a single command.

EARLY ACCESS — v0.3

$199

Core engine: Result monad, hexagonal layers, typed entities, Supabase integration, Docker pipeline, 5 CLI audit gates. Replaces 30+ hours of architectural setup, configuration, and ongoing maintenance.

LOCK FOUNDER PRICE

ONE-TIME PAYMENT • LIFETIME UPDATES • 14-DAY GUARANTEE

FULL PLATFORM — v1.0

$349

Everything in Early Access plus verified modules: Stripe billing integration, Auth flows (magic link + OAuth), Admin dashboard, UI component library. Each module audited against the same strict standard.

Early adopters lock in $199 permanently. Price increases at each verified milestone. We reward early trust with permanent pricing.

v0.3 Core ($199) → v0.5 Auth module ($249) → v0.7 Billing module ($299) → v1.0 Full platform ($349)

No sales calls. No 30-minute demos. No procurement process. Apply, pay, clone the repo. That is the entire workflow.

14-day money-back guarantee. No questions asked.

THE STRICT FILTER

This Is Not For Everyone

StrictKit is not for:

Developers who tolerate `any` when the types get hard. The CLI does not negotiate — it blocks the commit.

Teams where "just ship it" means tolerating known defects. If architectural integrity is negotiable, we are not compatible.

Engineers who treat error handling as an afterthought. If your strategy is try/catch and hope, StrictKit will feel like a straitjacket.

"Fast and dirty" builders who plan to refactor later. Later never comes. We both know that.

StrictKit is for:

Senior engineers who have rebuilt the same foundation three times and refuse to do it again.

CTOs and Tech Leads establishing engineering standards — not as bureaucracy, but as leverage.

Founders who know their codebase is either an asset or a liability. There is no middle ground.

The engineer who reads this list and thinks: "Finally." You are our customer.

ADDRESSED DIRECTLY

Common Objections

Why not configure ESLint, Husky, and Docker myself?

You can. Budget 30+ hours of configuration, debugging false positives, and ongoing maintenance. StrictKit sells you those hours for $199 — with an architectural standard that goes far beyond linting.

What happens when Next.js ships a major update?

Your license includes lifetime updates. When the stack evolves, the reference architecture is updated and you pull the changes. No extra cost, no expiration.

Can I use this for client projects?

Yes. The license covers unlimited commercial, personal, and client projects. The only restriction: you cannot resell the architecture itself as a template or kit.

Is the $199 → $349 price increase real?

Yes. Pricing reflects protocol maturity. Each verified module (Auth, Billing, UI) adds concrete, tested value. Early adopters lock in the current price permanently. The roadmap is public.

What if it does not work for my use case?

14-day guarantee. If the architecture does not save you meaningful time in your first sprint, full refund. No process, no conversation.

Is this just a boilerplate with strong opinions?

No. A boilerplate gives you files. StrictKit gives you invariants — every error is typed, every dependency is inverted, every entity is immutable. The CLI enforces these guarantees on every commit. This is a standard, not a starter.

Engineered by

HT

Héctor Topete

Senior Software Developer

8 years shipping systems where downtime triggers incident reviews. StrictKit exists because I got tired of rebuilding the same architectural foundation every time I inherited a codebase with no standards. This is not a framework — it is the baseline I enforce before writing a single line of business logic.

Every architectural decision in StrictKit comes from a production failure I refused to repeat.

© 2026 STRICTKIT • ALL SYSTEMS NOMINAL