How we work
From a first call to a system your team owns.
Five phases, a fixed price where the scope is fixed, and a handover date written into the contract on day one. This page is the whole process — including the parts that constrain us.
The method
Five phases, each with something you can hold.
Every phase ends in an artefact — a document, a deployed slice, a drill result — not a status update. If a phase cannot name its output, it is not a phase.
Technical qualification call
45–60 minutesOne call with the engineer who would lead the work, not a salesperson. We ask what breaks today, who gets paged, what has already been tried, and what the constraint really is — budget, regulation, an existing team, or a date. If the honest answer is that a product already on the market solves it, we say so on the call.
Output
A written point of view on the problem, a rough shape for the work, and a yes or a no on fit.
Discovery and architecture
2–3 weeksWe read the code and the data before drawing anything. Access to a read replica, the existing repositories, the incident history and two or three of the people who operate the system daily. The output is an architecture with the alternatives we rejected and why, a risk register, and the parts we consider genuinely uncertain.
Output
Architecture document, decision records, sequenced delivery plan, and a fixed price for the first build phase.
Thin slice to production
4–8 weeksOne real path — a single document type, one customer segment, one workflow — taken end to end into production behind a flag, with CI, infrastructure as code, telemetry and an eval suite in place from the first week. Real users, small blast radius. This is where the estimates for everything else get corrected by contact with reality.
Output
A deployed slice serving live traffic, a pipeline anyone on the team can ship through, and dashboards with named owners.
Harden and widen
6–12 weeksCoverage expands along the plan while the operational work runs in parallel: load and failure testing, SLOs with error budgets, cost controls, access reviews, and the second and third failure modes that only appear under real volume. The client’s own engineers commit to the repository from this phase onward, with review from our side.
Output
Full scope in production, SLOs agreed and monitored, load and chaos test results, and a cost model per unit of work.
Handover and steady state
2–4 weeks, then optional supportRunbook walkthroughs, a live incident drill run by the client team while we watch, credential and ownership transfer, and an honest list of the shortcuts taken and what they will cost later. After that the team either owns it outright or keeps us on a defined support window — never a dependency created by withheld knowledge.
Output
Runbooks, drill results, an accurate technical-debt register, transferred infrastructure ownership, and an optional support agreement.
Engagement models
Four shapes, priced the way the risk sits.
Fixed scope gets a fixed price, because the estimation risk should be ours. Open-ended work gets a monthly rate reviewed every six weeks, because pretending otherwise just moves the argument to a change order.
Discovery sprint
Shape
Two to three weeks, one or two engineers, ending in an architecture, a risk register and a costed delivery plan. Everything produced is yours whether or not the build follows.
Best for
A board has approved a direction and nobody can yet say what it costs, how long it takes, or what could go wrong.
Commercials
Fixed fee for a fixed scope and date. Credited against the first build phase if you choose to continue, and refundable in full if we conclude you should not build the thing at all.
Embedded pod
Shape
A small cross-functional team — typically applied AI or product engineering, plus platform — working inside your repositories, your sprint cadence and your review process, with one of our engineers accountable for delivery.
Best for
You have a team and a roadmap, and a capability gap that hiring will not close inside two quarters.
Commercials
Monthly rate per pod against an agreed scope and cadence, reviewed every six weeks, cancellable with 30 days’ notice. No minimum term beyond the first two months.
Build and operate
Shape
We build the system, run it in production against agreed SLOs for an initial period, then hand it to your team with runbooks, drills and a transition plan. On-call is ours until the transfer date, then shared, then yours.
Best for
The system has to exist before the team that will eventually own it does — a new product line, or a platform built ahead of hiring.
Commercials
Fixed-price build phases, then a monthly operate fee tied to the SLOs we agreed. The handover date is in the contract from day one, not negotiated later.
Fractional platform team
Shape
A standing allocation of senior time across infrastructure, deployment, security and reliability for a company that needs those functions but not yet at full-time headcount. Includes an on-call rota and a quarterly platform review.
Best for
A product team shipping faster than its infrastructure can safely carry, with no platform hire on the near horizon.
Commercials
Retainer for a defined number of engineer-days per month with a named response window. Unused days roll forward one month; the rota and its limits are written down, not implied.
Security posture
Practice, not a certificate.
What follows is how the work is actually done — where code lives, who holds a credential, what happens to your data, and, in the last entry, exactly where we stand on certification.
- Where code lives
- By default we work inside your version control, your CI and your cloud account, so the audit trail is yours from the first commit. Where we host a repository ourselves, it is private, branch-protected, requires review and signed commits to merge, and is transferred to you at handover. We do not keep private copies of client repositories after an engagement closes.
- Credentials and secrets
- Secrets are never values in a file, a ticket or a chat message. They live in AWS Secrets Manager, Vault or your chosen manager, injected at runtime with short-lived credentials wherever the platform supports it. Every engineer uses hardware-backed multi-factor authentication and full-disk encryption. If a credential is ever exposed, we say so, rotate it, and write the incident down.
- Client data
- Our strong preference is to never hold your production data. We build against anonymised or synthetic fixtures and debug inside your environment. Where real data is unavoidable — a migration, a parser bug on a live document — it is scoped to the minimum records, held in a named environment inside your account, given a deletion date in writing, and deleted on that date.
- Access and least privilege
- Named individual accounts only, scoped to what the task requires, with no shared logins and no long-lived root or admin keys. Production access is granted per person with an expiry, and revoked within one business day of someone leaving the engagement. We keep a joiners-movers-leavers list per client and reconcile it at each phase boundary.
- Subprocessors and model providers
- We name every third party that could touch client data before it is used — cloud region, model provider, vector store, error tracker — and we configure providers for zero retention and no training on client content where that option exists. If an option does not exist for a provider you need, we tell you the exposure in plain terms rather than routing around the question.
- Intellectual property and honest compliance
- You own the code, the prompts, the eval sets, the infrastructure definitions and the documentation on payment, assigned in the contract. We reuse only our own generic scaffolding, never your domain logic. On certification we are direct: Digiaeon does not hold ISO 27001 or a SOC 2 report today. We operate inside your controls, complete your security questionnaires truthfully, and will not imply an attestation we have not earned.
Working stack
What we reach for, and what we don’t.
Boring by default and current where it matters. Anything here has been run in production by someone on this team — we do not learn a technology on a client’s budget.
Languages and runtimes
- TypeScript
- Python 3.12+
- Go
- Rust where latency or memory demands it
- Node.js LTS
- PostgreSQL PL/pgSQL
Applied AI and retrieval
- Anthropic Claude and OpenAI APIs
- Open-weight models served on vLLM
- Amazon Bedrock and Vertex AI for regulated hosting
- pgvector, Qdrant and OpenSearch hybrid retrieval
- Cross-encoder rerankers
- Model Context Protocol tool servers
- LangGraph and Temporal for durable agent loops
- Ragas and custom eval harnesses in CI
Data and platform
- PostgreSQL
- ClickHouse
- Apache Iceberg on S3
- Kafka and Redpanda
- dbt
- Dagster and Airflow
- DuckDB for local analysis
- Debezium change data capture
Product and interface
- Next.js App Router with React Server Components
- React and TanStack Query
- Tailwind CSS with design tokens
- React Native and Expo
- Playwright and Vitest
- Zod schemas as the contract between layers
Cloud and delivery
- AWS as the default, GCP and Azure where the client already lives there
- Terraform and OpenTofu
- ECS Fargate and EKS
- AWS Lambda and Step Functions
- GitHub Actions and Argo CD
- Docker with reproducible multi-stage builds
Observability and security tooling
- OpenTelemetry instrumentation end to end
- Grafana, Prometheus and Loki
- Amazon CloudWatch and X-Ray
- Sentry
- AWS Secrets Manager and HashiCorp Vault
- Semgrep, Trivy and Dependabot in the pipeline
- Sigstore signing and SLSA build provenance
Questions
The awkward ones, answered.
Pricing, ownership, key-person risk and the work we turn down. If something here is still unclear, it is a better first call than a requirements document.
Next step
Bring us the problem you keep deferring.
A 45-minute working session. We'll tell you what we'd build, what we'd not build, and roughly what it costs. No deck.