Engineering In production

The bina Build System

bina operates a software estate with the breadth of a company many times its size: a curriculum engine that harmonizes the national curricula of four countries into one standards graph, a live lesson-capture pipeline and a safeguarding camera pilot, scheduling across four time zones, family and teacher products, a developing fleet of student copilots, and its own production infrastructure across two European data centers.

Agents support each stage of delivery, and a scope carries its records along the chain without a person having to reconstruct the context at every step. People hold the decisions that need judgment: what gets built, whether a stage’s output is accepted, and any deviation from what was agreed. That is where the scale comes from, and why a small in-house team runs all of it: bina engineered the process that produces the software before it engineered the software.

What the meta-system runs

A family of services across several languages, in one repository, under one delivery process.

Curriculum engine One standards graph harmonized from the national curricula of four countries: the UK, the US, Canada and Australia. Its own composition pipeline and navigator sit on top.

Standards are composed under a written rule set, with every placement decision logged and reviewed. Coverage against source frameworks can be inspected, and teacher review feeds back into the next generation.

Lesson capture Scheduled sessions recorded, encrypted, indexed and served back, including small-group breakouts.

Sessions are matched to the timetable automatically, recorded, encrypted at rest and retrieved through time-bound links. Breakout groups are captured and attributed to the class they belong to.

SafeguardingBuilding now A camera-presence pilot runs on bina’s own hardware; a wider two-channel supervision design is built but remains gated.

The wider design combines text analysis with local camera-presence checks. A face count is a signal, not proof of identity or wellbeing. Escalation decisions are made by deterministic code, opt-out removes a child before any processing at all, and emotional-state inference is excluded by design.

Scheduling and rostering Enrollment and live roster resolution publishing personal calendars for all teachers and students across four time zones.

Enrollments carry their dates and history, so rosters remain accurate at any point in time. Every placement move shows its future roster first. A person approves it; calendars and classes update on their own.

Teacher workspace The daily operating surface for the teaching team, from agenda through attendance and materials.

Agenda, live class view, attendance and materials on one surface, replacing the spreadsheets teachers used to keep alongside the system.

Family productsBuilding now Enrollment intake, portal, and self-service sign-up for clubs and elective disciplines.

One tokenized link per family carries time zone and level, so sign-up needs no account. Minimum-enrollment rules form classes automatically and publish them straight to calendars.

Fleet of student copilotsBuilding now A signed, centrally managed application on student machines, with staged rollout control and per-device visibility into what is installed and running.

Binaries are cryptographically signed, keys are bound per device, and releases reach a controlled percentage of the fleet with per-device status reported back.

Data platform The student system of record and a permissioned API serving every other system above.

Every operationally meaningful change is a dated registry entry, so history stays queryable. A permissioned API exposes each resource with an explicit split for personal data.

Production infrastructure Production services across two data centers on a private network, with database failover and a documented recovery path.

Two data centers in active-active with automatic database failover, a private network separating staff access from the data layer, and full metrics, logs and alerting across every node.

Three generations of engineering with AI

The practice is still evolving. These approaches put different amounts of structure around AI-assisted work. bina’s investment is in the third: the unit of engineering here is no longer the code, it is the process that produces the code. Designing that process is a capability bina continues to build.

	Vibe-coding	Spec-based	bina: the engineered process
Unit of work	A prompt.	A written spec.	A scope that enters a defined protocol. Objectives, success criteria and per-feature acceptance criteria travel with it through every stage, and any deviation is written back to the scope and re-approved before the chain moves on.
Record of intent	Prompt history, unless deliberately retained.	The spec document, maintained by hand.	Scope, architecture decisions and requirements, versioned in the repository beside the code they govern.
Process	Prompt to diff.	Spec, then implementation, with the intervening process defined by the team.	Five stages with a defined input, a committed output and an explicit handoff at every boundary. The protocol is the artifact.
Definition of done	It runs.	A human reads the spec and judges it satisfied.	Every gate green and every acceptance criterion demonstrated against a test.
Enforcement	Reviewer attention on the day.	Code review, with additional checks where the team connects them to the spec.	One gate contract that all modules implement identically across five languages. A red gate blocks the commit.
Traceability	Depends on how the session and its decisions are recorded.	Spec to code, by convention.	Acceptance criterion → requirement → commit → test → release note, followable in both directions.
The trade	Fast to explore; review and maintenance still need a process.	Intent is captured; verification needs to be connected to it.	The cost is upfront, and it is deliberate. A one-line change still travels the whole protocol, and bina accepts that in exchange for an estate this size staying reviewable, solid and reliable.

The agentic delivery loop

Each of the five stages has an agent role, and a scope carries its records along the chain without a person having to reconstruct the context at every step. Every stage consumes the previous one’s committed artifact and produces its own. Architecture is held by a standing family of architect agents that carries accumulated practice from one scope to the next. People hold the decisions that need judgment, and the gates stop the chain on their own. Production closes the circuit: what a live system reports becomes the input to the next scope, so the process improves from its own output.

Quality gatesHover or tap any gate on the rail to see what it catches.

Quality gates. edit: diagnostics while the change is written. commit: the touched module’s format and static analysis. push: its full suite and build. integrate: change-detected modules behind one required check. deploy: smoke verification of the deployed environment. production: continuous assertions that open an owned incident when they trip.

Discovery and architecture commit their artifacts before any code is written, so implementation begins against a fixed target. Checkpoints tighten as a change moves closer to students, and every deployed system is instrumented so that incidents, telemetry, usage and stakeholder feedback are collected as evidence. That evidence re-enters the loop as specified work, which is what makes the process self-correcting.

What the process produces

Quality is enforced at four levels, each removing a different class of defect before the next begins: requirement collection, architecture, gating and review, and the implementation agent itself.

Ambiguity is spent at intake

Objectives, success criteria and per-feature acceptance criteria are settled with the stakeholder before design opens. Implementation begins against a fixed target, and the most expensive category of rework (building the wrong thing correctly) is addressed at the cheapest possible moment.

A standing family of architect agents

Architecture is produced by specialist architect agents that persist across scopes and accumulate house practice: the patterns that held, the decisions already taken, the shape of every service they have designed. They are where the estate’s complexity is held, so all services stay designed against one baseline and a lesson learned in one becomes a convention the others inherit.

Design goes deeper than manual practice sustains

The architecture stage is AI-driven, which makes exhaustiveness affordable: alternatives weighed and written down, edge cases enumerated, interfaces pinned before a line of code exists. Detail at design time is the cheapest defect removal available, and this is where bina spends it.

Multi-stage gating and review

Automated checks run while the change is written, again before it merges, and again against the deployed system, with a structured review at every stage handoff. A red gate blocks the commit, and every handoff leaves a record.

The implementation agent compounds

One agent implements across the whole estate, carrying an accumulating body of house practice: conventions, known pitfalls, and every correction from every prior scope. A correction can become a convention or regression test that helps prevent the same defect elsewhere.

Estate-wide context on every change

Work on any single service carries the whole system’s context: the data contracts it must honor, the conventions it must match, the decisions already taken elsewhere. Local changes can be reviewed against their wider consequences.

What compounds

Expertise ships as executable playbooks

Repeatable specialist work is written as a runnable procedure: ordered phases, rules with stable identifiers, and a defined output contract. It executes from a cold session with zero prior context, which puts the expertise in the repository.

One typed contract, three surfaces

A domain operation is declared once. The user interface, the JSON API with its OpenAPI schema, and the tool an agent calls all derive from that declaration and execute the same validated handler. That shared handler reduces opportunities for drift between surfaces.

Throughput tracks model capability

The loop is model-agnostic. Improvements in model quality can be evaluated through the same gates, without loosening the definition of done.

Built on A single monorepo of services across five languages, on bina-operated infrastructure. Frontier language models drive the stages; the loop around them is assembled from standard engineering primitives: versioned decision records, a hook-driven gate harness, change-detected integration behind one required check, branch-per-environment delivery, and typed API contracts. bina designed and built the framework in-house.

Where this goes next

The same contract extends to deeper static analysis and to model-based conformance testing, so the properties a system must hold are checked mechanically against its specification. Every gain here compounds across all services at once, because they all answer to one interface.