AWLabs
Methodology

How we actually deliver.

This page is the operating manual. Every phase below produces specific, named artefacts; every release passes specific, named gates; every week has a specific, named cadence. Sprint length is set for each build. You get an update every Tuesday and Friday, Sydney time, with access to test the latest work.

The six phases

Discovery to handover, every engagement, every time.

We do not invent process per project. The same six phases run every time, sequenced and resourced to the engagement. What changes is depth, not structure.

01

Discovery Audit

Written within 7 days of your answers

Every build starts with a Discovery Audit: $750 plus GST, credited in full against the build. After two strategy sessions you receive a fixed price for an agreed scope.

Artefacts you receive
  • A written audit, typically fifty to seventy pages: scope, build order and dependencies
  • Risks across twelve categories, and the seventeen standards your product is assessed against
  • The legal documents you will need, identified (not drafted)
  • Fixed price Schedule of Work: what is included, the milestones, and the three payments
  • Mutual NDA executed before any commercial data changes hands
02

Architecture

scoped per build

Decide every technical question that would cost more to undo than to debate.

Artefacts you receive
  • C4-model system diagrams (context, container, component)
  • Data model and migration strategy
  • API contracts and integration sequence diagrams
  • Authentication, authorisation and audit-log design
  • Hosting and infrastructure-as-code plan (Terraform or Pulumi)
03

Build

stage by stage

Ship working software in vertical slices, behind quality gates, in stages you test and accept.

Artefacts you receive
  • Sprint length is set for each build
  • Trunk-based development with preview deploys per branch
  • An update every Tuesday and Friday, Sydney time, with access to test the latest work
  • A working build at the end of every sprint, never a "wait until launch" gap
  • You can see and test the code while we build; each part is assigned to you as it is paid for in full
04

Quality gates

every deploy

Refuse to release anything that has not passed an explicit, automated check.

Artefacts you receive
  • TypeScript strict + lint must pass, non-negotiable
  • Unit + integration tests must pass at coverage thresholds set at architecture
  • Playwright visual regression suite must be green
  • Hallmark design gate, no AI-slop layouts, no placeholder copy reaches prod
  • Human review on every release, no matter how small
  • Security scan (dependency audit + SAST) on every PR
05

Release

continuous

Get changes to your users frequently and reversibly.

Artefacts you receive
  • Staging environment that mirrors production exactly
  • Feature flags for any change that affects user-visible behaviour
  • One-click rollback to the previous deploy
  • Release notes generated from PRs, sent to your team
  • Synthetic monitoring on the critical user journey
06

Handover and operate

after the final payment

Make sure the project survives our involvement.

Artefacts you receive
  • Architecture decision records, every non-obvious choice documented
  • Runbook for every operational scenario (incident, scale, backup, restore)
  • Knowledge-transfer sessions recorded and indexed
  • Full repository, logins and accounts handed over after the final payment
  • A 30 day warranty from launch: we fix bugs and anything caused by our work at no cost
  • After that, an optional Care Plan, month to month, priced for your system
Quality gates

Eight automated checks. No deploy passes without them.

Every PR runs the full gate sequence. A failure on any one of them blocks merge. There is no manual override on gates that touch production.

G01

Type safety

Check: TypeScript strict mode, no `any`, no implicit-any escapes

Why: Catches a class of runtime bugs at edit time. Cheaper than tests for what it covers.

G02

Lint and format

Check: ESLint with project rules; Prettier on every commit

Why: Style debate is a waste of senior time. Tools decide, nobody argues.

G03

Unit + integration

Check: Vitest / Jest on logic; real-database integration tests on the data layer

Why: Mocked database tests passed and prod broke. We learnt. Integration tests hit a real DB.

G04

Playwright visual

Check: Per-route screenshot diff against a baseline approved by a human

Why: Catches the regression that "the test passes but the page is broken" can hide.

G05

Hallmark design gate

Check: Layout, typography, spacing, motion, content density, graded against a rubric

Why: The bar for "is this AI slop" should be enforced by a checklist, not by hope.

G06

Dependency audit

Check: npm audit (high/critical fail the build); SBOM generated per release

Why: Known vulnerabilities are not allowed into prod, even transitively.

G07

Static analysis

Check: Semgrep + project-specific rules; secret scanning on every commit

Why: A leaked API key in commit history is a Friday-night incident. Stop it at the gate.

G08

Human review

Check: A named engineer approves every PR. No auto-merge on any branch that touches prod.

Why: Automation accelerates engineering; it does not replace accountability.

Weekly cadence

What a week with us looks like.

Async by default; synchronous when it matters. You always know what was done yesterday, what is shipping this week and what is at risk.

Tue
Update sent, Sydney time, with access to test the latest work
Wed, Thu
Build continues · async by default
Fri
Update sent, Sydney time, with access to test the latest work
Each stage
You test and accept the stage before the next one starts
The promise

If a stage is at risk, you hear it from us in the next Tuesday or Friday update at the latest. We do not save bad news.

Autonomous tooling

Where the speed comes from.

We build with the same Claude-powered orchestration system, internally called Overseer, that runs our own infrastructure. Multi-worker dispatch, automated governance (rate limiting, anomaly detection, PII redaction), and Telegram escalation for decisions that need a human.

The honest version of what it does: it compresses the parts of software delivery that are pattern work, scaffolding, integration wiring, asset generation, test authoring, so the senior engineering hours go into judgement, architecture and review. Every gate still runs. Every release still has a named human approver.

What it does not do: replace a senior engineer's read of a tricky PR, decide an architecture trade-off, or sign off on a release. Those stay human.

Pipeline composition
Dispatch
Overseer · multi-worker Claude Code
Governance
Kill switch · rate limiter · anomaly detector · PII redactor
Build
Trunk-based · preview deploy per branch
Visual QA
Playwright · per-route screenshot diff
Design gate
Hallmark · rubric-graded layout review
Escalation
Telegram · CTO-level decisions surfaced live
Final sign-off
Named human engineer · on every release
When things go wrong

Escalation path, written down before you need it.

Tier 1
Sprint risk surfaced. Engineer-to-engineer. Logged and raised in the next update. Mitigation drafted same day.
Tier 2
Stage at risk. Andy writes you a same week summary: what slipped, why, options to recover, recommended path.
Tier 3
Material scope, cost or timeline change. Founder-to-founder. Written change order with revised cost and date before we touch the work.
Tier 4
Production incident. Roll back first, investigate second. Postmortem within 5 business days, action items tracked to closure.
Let's Build Something Extraordinary

Ready to Transform Your
Technology Operations?

Tell us what you want to build. Let's talk about what we can build together.

Book a Strategy Call admin@awlabs.com.au
Free 30-minute strategy call
No commitment required
Response within 1 business day
Mutual NDA sent before you share your idea