Start a Conversation →
How We Build

Every project follows the same rigorous framework.

Six phases. Defined deliverables. Quality gates at every checkpoint. You see working software throughout, not a reveal at the end. Here's exactly how it works.

Factor
Traditional Agency
Clairvos
Time to working software
3-6 months
2-8 weeks
Team size
4-8 people
1 architect
Budget to overhead
40-60%
~0%
Architecture quality
Variable
Consistent
Documentation
Sparse, at end
Built during process
Post-launch support
$10-25K/mo typical
$2-12K/mo tiered

Industry data: Artezio, ScienceSoft, Keyhole Software, SPDLoad, Clutch.co (2025-2026)

Phase 0

Discovery + Architecture

1-2 weeks

80% of quality is determined here. We analyze your domain, write Architecture Decision Records for every significant choice, and produce a dependency-ordered build plan. Bad decisions made here cascade through every line of code. We don't rush this phase.

Deliverables
Intake analysis with resequenced priorities
10-25 Architecture Decision Records (ADRs)
Definitive build plan with weekly checkpoints
Engineering standards handbook
Risk register with mitigations
✓
Quality gate: Client reviews and approves the build plan. Both parties agree on scope, sequence, and checkpoints.
architecture-decision-records/
ADR-001Durable Objects for tenant isolation
ADR-002SQLite over D1 for per-church storage
ADR-003RPC methods over legacy fetch
ADR-004Clerk for auth, RBAC via DB roles
ADR-005Monorepo with workspace packages
ADR-006FTS5 for full-text search
ADR-007Health Score: 6-dimension algorithm
ADR-008Override-per-instance recurring events
Phase 1

Foundation + Standards

2-5 days

Complete database schema defined upfront, not discovered module by module. Engineering standards enforced per file. Every module built after this point follows the same pattern.

Deliverables
Working monorepo, zero type errors
Complete database migrations
API gateway with auth + rate limiting
Type system + shared utilities
✓
Quality gate: npm run typecheck passes. Gateway returns health check. Auth works end-to-end.
schema/migrations/001-core.sql
-- Members table (core entity) CREATE TABLE members ( id TEXT PRIMARY KEY, first_name TEXT NOT NULL, last_name TEXT NOT NULL, email TEXT, phone TEXT, status TEXT NOT NULL DEFAULT 'active', role TEXT NOT NULL DEFAULT 'member', joined_at TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL, CHECK(status IN ('active','inactive','archived')) ); -- 16 migrations, 69 tables total -- All defined before first module
Phase 2

Accelerated Build

1-4 weeks

Modules built in dependency order. Same playbook every time: schema, types, validation, backend, routes, UI, tests. You see clickable, working software at every weekly checkpoint. Not wireframes. Real software.

Per module
Backend methods with validation
API routes with RBAC permission checks
Admin + member UI pages
Seed data + tests
✓
Quality gate: Type-check passes. Tests pass. UI renders with seed data. Client clicks through the module at the weekly checkpoint.
build-plan / module-sequence
WK 1Members, Households, Custom Fields
WK 2Events, Attendance, Teams
WK 3Scheduling, Posts, Messages
WK 4Health Score, Care, Notifications
WK 5CSV Import, Volunteer Mgmt
WK 6Member App, Giving, Financial
WK 7Communications, Groups, Prayer
WK 8Worship, Check-in, Children
Phase 3

Hardening

3-7 days

The difference between a demo and a product. Malformed inputs, RBAC boundary audits, tenant isolation verification, cascade safety checks. Every edge case discovered gets a test. Runs twice for complex projects.

Deliverables
Hardening audit report
Updated test suite for edge cases
Performance benchmarks
Security review summary
✓
Quality gate: Zero P0 findings remaining. All P1 findings fixed or ticketed. Edge case tests passing.
hardening-audit / checklist
// Per-session hardening checklist // (runs with every build session) □ Input boundary testing - empty strings, max length, unicode - negative numbers, zero, MAX_INT - SQL injection attempts □ RBAC verification - member cannot access admin routes - tenant A cannot see tenant B data □ Cascade safety - archive parent, check children - delete team lead, check schedule □ Error response quality - no stack traces in production - consistent error envelope □ Observability spot-check - logs flow to Axiom - errors reach Sentry
Phase 4

Deploy + Observability

2-5 days

Production infrastructure, CI/CD, structured logging, error tracking, health monitoring, rate limiting. Your platform goes live with full observability from day one.

Deliverables
Production deployment runbook
Infrastructure diagram
Monitoring dashboard
Incident response playbook
✓
Quality gate: Smoke tests pass in production. Structured logs visible. Error tracking captures test errors. Health check returns 200.
infrastructure / production
# Production architecture Workers: api-gateway → auth, routing, RBAC church-database → Durable Object (SQLite) admin-app → Next.js (SSR) member-app → Next.js (SSR) Storage: D1 → platform database R2 → file storage + backups KV → cache + rate limiting Observability: Axiom → structured logging Sentry → error tracking
Phase 5

Handoff + Ongoing

1-2 weeks + retainer

Your developer walks through the codebase with the architect who built it. Not a docs dump. A real tour, then a pair session where they add a feature. Tiered retainers keep the platform healthy after launch.

Deliverables
Handoff completion report
Architecture walkthrough (recorded)
Pair session: developer ships a feature
Ongoing support retainer
✓
Quality gate: Your developer adds a new endpoint, route, and UI page by following the engineering handbook without the architect's help.
support / retainer-tiers
AdvisoryArchitecture guidance, code review, quarterly review
ActiveAdvisory + bug triage, security patches, minor features
ManagedActive + major features, infra management, on-call

Tell us about your project.

We'll walk you through how the method applies to your specific platform. No commitment, just a conversation about what's possible.

Start a Conversation →