How We Work
A practical process for building blockchain verification systems — from scoping through to production deployment
Scope
Define what needs to be provable. We identify the data, documents, or attestations to anchor on-chain and map out the verification model.
Architect
Design the system. Choose between Go CLIs, TypeScript APIs, or both. Define the on-chain data structure, Merkle tree layout, and integration points.
Build
Write the code. Blockchain transactions, SPV proof generation, API endpoints, and frontends. Ship iteratively with working software at each step.
Deploy & Verify
Push to production on Railway and Vercel. Verify that on-chain anchoring works end-to-end. Hand over binaries, documentation, and monitoring.
The Details
What each step actually involves — no buzzwords, just the engineering.
Scope
Every project starts with understanding what needs to be verified. We map out the data model, identify what gets anchored on-chain vs stored off-chain, and define the verification flow end-to-end.
- • Define the verification model (documents, skills, attestations)
- • Map integration points with existing systems
- • Identify on-chain vs off-chain data boundaries
- • Set success criteria for verification accuracy
Output
- • Data model specification
- • Verification flow diagrams
- • Integration requirements
- • Scope definition with milestones
Output
- • System architecture document
- • On-chain data structure (OP_RETURN layout)
- • Merkle tree design for file manifests
- • API contract definitions
Architect
Design the technical architecture. We decide on Go vs TypeScript for each component, define the Merkle tree structure for file manifests, and plan the blockchain transaction format.
- • Choose Go for CLIs (single binary, zero deps)
- • TypeScript/Node.js for APIs and backends
- • Design Merkle tree layout for batch verification
- • Plan blockchain transaction structure
Build
Write the code and ship working software iteratively. Blockchain transactions, SPV proof generation, verification endpoints, and user-facing interfaces — all built with production quality from day one.
- • Build Go binaries with cross-compilation
- • Implement SPV proof generation and verification
- • Create blockchain transaction broadcasting
- • Ship working increments for feedback
Output
- • Production-ready binaries and services
- • On-chain verification proofs
- • API endpoints with documentation
- • Source code and test suites
Output
- • Live production deployment
- • End-to-end verification confirmation
- • Documentation and runbooks
- • Monitoring and alerting setup
Deploy & Verify
Push to production infrastructure on Railway and Vercel. Run end-to-end verification to confirm on-chain anchoring works correctly. Hand over everything needed to operate independently.
- • Deploy to Railway (backends) and Vercel (frontends)
- • End-to-end on-chain verification testing
- • Hand over binaries, docs, and access
- • Set up monitoring and health checks