How it works
Custom software used to mean six-figure quotes and six-month timelines. AI-accelerated development changed that — so we sell software the way you buy anything else online: fixed scope, fixed price, delivered ready to use.
And we build it in the open: you watch the team of AI agents work live, the engine refuses to release until every quality gate passes, and you receive full documentation shaped on the international standards.
Operation Manual
New here? Understand the terminologies, how the systems work, the ordering workflow, payments, procurement papers, and the warranty — all in plain language.
Two ways to order
Pick a blueprint, or describe your own
Pick from the catalog
209 researched blueprints for every level of government and for businesses, each with its standard features, popular additions, tech stack, timeline and a fixed tier price. Customize it: custom features priced per item, your office identity, extra Philippine languages, design references.
Browse the catalogDescribe your own software
Type the specs, details and description. Our analyst model drafts the product page — features, popular additions, tech stack, assumptions — and the store prices it with the same fixed tier rules. Refine until it is right, then configure it exactly like a blueprint.
Describe your softwareFrom order to handover
1 · Choose a blueprint
Every one of our 209 software profiles is researched from how Philippine government offices actually work — barangay to national. You see the full standard feature list, the tech stack we build on, the delivery timeline, and the fixed price before you commit to anything.
2 · Configure your build
Add custom features in plain language — a new report, an SMS reminder, an integration. Each one is priced by complexity (₱3,000 simple / ₱9,000 moderate / ₱18,000 complex) and added to your total live. Upload screenshots or sketches so we match the look you want.
3 · Sign the Build Agreement
Your configuration becomes a Build Agreement: the exact, itemized scope of what will be delivered. Nothing is charged until you've read it and agreed. What's listed is what you get — and anything not listed can be added later as a quoted change.
4 · We verify your order, then build
Pay by GCash or bank deposit and upload your proof — or, for government offices, enter your Purchase Order (print the full procurement pack straight from your Build Agreement: quotation, RFQ, abstract, PO and more, RA 12009-ready). We verify every order personally with a quick call. Then our build engine turns your Build Agreement into a working application, and you get a private link to explore it: click every screen, add data, try every feature. Not what you wanted? Tell us within 7 days for changes — or take the money-back guarantee. Government offices pay only after Inspection & Acceptance.
5 · We finalize, test & deploy — setup is free
Nothing ships on hope. Every flow in your Build Agreement is tested end-to-end before official delivery. Then we deploy to production hosting, configure your domain, connect your integrations, and load your branding. You don't touch a terminal.
6 · Handover — you own everything
You receive every credential and setup detail: hosting account, domain, database, admin logins, API keys, and the source code. Subscriptions (hosting, email, SMS, AI APIs) transfer to your name so you pay providers directly — no middleman markup, no lock-in.
7 · 6-month warranty
For 6 months after delivery, any defect — a bug, a broken flow, something that doesn't match the Build Agreement — is fixed free. New features beyond the agreement are quoted separately.
The build team
A team of AI agents, each with a role — working in parallel
Once your payment is verified (or your Purchase Order is received), your order is queued on our build engine and run by a team of agents inside a private VS Code workspace of its own. The engine — not the agents — owns the budget, the phases, the gates and the recording.
Planner
Claude Fable 5.1
Reads the Build Agreement, writes the plan, the requirements (REQ ids with acceptance criteria), the architecture and the design, and splits the work into phases — one per feature.
Orchestrator
Claude Fable 5.1 (the same session)
The planner continues as the orchestrator: it drives the build in the project's own VS Code, briefs the helpers, reviews what comes back, keeps the documents current and decides when a phase is done. This is the screen you watch.
Implementers
Claude Opus 5.5
Build the features in parallel — database, server logic, screens, unit tests — each in its own lane, reporting back to the orchestrator.
Testers
Claude Sonnet 5.5
Design the test cases and user journeys from the requirements, write the system-integration tests and the usability review, and hand defects back to the implementers.
Models named are the build engine's defaults at the time of writing; the role structure is what stays constant.
Watch live
You watch the real build — not a progress bar
Your order page has a private "Watch your build live" link. It opens a filmed view of the orchestrator's VS Code: the file tree, files opening, code being typed, tests running in the terminal. Beside it, a text lane per helper shows what each implementer and tester is doing right now, and a phase strip at the top shows where the build is — plan, requirements, architecture, one phase per feature, tests, UI/UX, documentation, release.
- ✓Live means about 8–15 seconds behind the agents' screen.
- ✓Recorded from the first second: open the link later and play from the start, or seek to any phase.
- ✓After the build: a final video with chapters per phase and role, plus the full event recording.
- ✓After every phase the orchestrator writes a plain-language summary you also see on your order page.
- ✓Watching is view-only. If the build needs a decision from us, our engineers step in; you see it in the recording.
What you see on the watch page
- Phase strip
- Every phase of the build with its state — done, running, waiting.
- The orchestrator's VS Code
- Filmed live: editor tabs, the file tree, typed code, terminal output of the gates.
- Helper lanes
- One lane per implementer and tester with their running commentary and the files they changed.
- Agent badges
- Which role and model is working, on every turn and every chapter.
- Recording controls
- Live, from the start, or any phase; later the final video.
Quality gates
The engine refuses to release until every gate passes
The agents write the code and the tests; the engine runs the gates itself, in the build workspace, and reads the measured results. A failing gate goes back to the team to fix and is run again. Only a build with every gate green is packaged as a release — with the test report, the traceability matrix and the UI screenshots inside it.
- 1
Type check
The whole project compiles with strict TypeScript.
- 2
Lint
Code-quality rules pass with no errors.
- 3
Build
A production build succeeds — the same build that runs when you use the system.
- 4
Unit tests · 100 % coverage
Business logic, API routes and server actions are covered to 100 % measured line coverage; a single uncovered line fails the gate.
- 5
System-integration tests
The built app is started and every route is exercised end to end against a real database.
- 6
UI/UX tests
The engine's own browser runs the testers' user journeys on mobile, tablet and desktop, audits every page for WCAG 2.2 AA accessibility with axe, takes screenshots, measures load times, and the tester writes a usability review against Nielsen's ten heuristics.
- 7
Documents + traceability
Every required document and section exists for the phase, and every requirement traces to at least one test case that ran and passed.
Full documentation, by standard and by reader
A documentation set your next developer, auditor or operator can actually use
Every build ships a complete documentation set whose documents follow the structure of the international standards for software documentation. We are not certified against these standards and do not claim to be — we use their document shapes and required sections so the result is complete, consistent and familiar to anyone who has worked with them.
| Document | Shaped on | For | Contains |
|---|---|---|---|
| REQUIREMENTS.md | ISO/IEC/IEEE 29148 | Management · Developers · Testers | The software requirements specification: purpose, scope, stakeholders, every requirement with an id and acceptance criteria. |
| ARCHITECTURE.md | ISO/IEC/IEEE 42010 | Developers · Operations | Architecture description with viewpoints (context, containers, components), decisions and quality concerns. |
| DESIGN.md + DECISIONS.md | IEEE 1016 | Developers | Software design description per viewpoint — data model, interfaces, flows — plus the architecture decision log. |
| test/TEST-PLAN.md, TEST-CASES.md, TEST-REPORT.md | ISO/IEC/IEEE 29119-3 | Testers & QA · Management | Test plan, test design and cases, procedures, the test log, incidents and the completion report with results. |
| USER-GUIDE.md | ISO/IEC/IEEE 26514 | End users | Task-oriented user documentation per role and screen, also seeded into the system's own Help module. |
| OPERATIONS.md | runbook | Operations | Deploy, configuration, start / stop / health, backup and restore, logs, incident playbooks, upgrades. |
| test/TRACEABILITY.md | written by the engine | Everyone | The matrix from every requirement to its test cases and the run in which they passed — generated by the engine, not written by hand. |
Organised by reader
Tabs for management, end users, developers, testers & QA and operations — each sees the documents meant for them, with a search across the set.
Download or print
Every document as Markdown or PDF, the whole set as a ZIP or one PDF with a linked table of contents, and a print view for each.
Traceability
The engine generates the matrix: requirement → test cases → the test run that passed. Nothing is in the release that is not traced.
Why this matters
What you gain from a build you can watch, verify and read
Transparency
You watch the real build, not a status bar. Every file opened, every test run, every decision is on the recording — with a plain-language summary after each phase.
Verifiability
The gates are enforced by the engine from measured results — coverage numbers, test logs, axe reports, screenshots — and the test report ships with the release. You can check every claim.
Standards-based handover
The documents follow the structure of the international software-documentation standards, so a new developer, a COA auditor or an operations team knows where to look on day one.
No black box
Requirements trace to tests, tests trace to code, code is yours. Nothing depends on remembering what was agreed — it is written down and linked.
An audit trail
The recording, the final video with chapters, the documents and the test results are kept with your order and can be downloaded any time.
Faster, at a fixed price
Implementers work in parallel and the gates catch defects as they appear, so builds finish in hours to days rather than weeks — and because the price is fixed by tier, rework is our cost, not yours.
Guided tour
See the flows, step by step
1. Catalog
Start from one of 209 proven blueprints
Every blueprint lists its standard features, popular additions, tech stack, timeline and a fixed price — barangay to national agency, plus businesses. Filter by category or tier, open one, and customize it: custom features priced per item, your office identity, extra Philippine languages, design references.
- ✓Fixed price per tier — ₱30,000 / ₱90,000 / ₱199,000
- ✓Full scope shown before you commit
- ✓Custom features from ₱3,000 to ₱18,000 each