Skip to content

Services

Software engineering, contracted four ways

Each service below states what it includes, what you receive at the end, the technologies involved and the contract shape. Nothing here promises an outcome we could not evidence.

Scalable web and desktop systems

Custom Enterprise Software

Business systems built to a written specification: domain modelling, architecture, implementation, automated tests, deployment pipeline and handover of the complete source code.

  • Domain modelling and a written functional specification before a line of code
  • Web applications, internal operations platforms and back-office systems
  • Relational data modelling, migrations and reporting views
  • Role-based access control, audit trails and data-retention rules
  • Automated test suite and a reproducible CI/CD pipeline
  • Documentation written for the engineer who inherits the system

What you receive

  • Functional and technical specification
  • Source code in your repository, under your licence
  • Automated test suite with coverage report
  • CI/CD pipeline and infrastructure-as-code
  • Runbook, architecture notes and handover session

Typical technologies

  • PHP 8.3
  • React
  • TypeScript
  • MySQL
  • PostgreSQL
  • Docker
Typical duration
8–24 weeks depending on scope
Engagement
Fixed-scope delivery or milestone-based contract

Cloud transition, security and performance audits

IT & Architecture Consultancy

Independent technical assessment: architecture review, cloud transition planning, performance and security audits, delivered as a written report with prioritised, costed recommendations.

  • Architecture and code review against stated quality attributes
  • Cloud transition assessment — what to move, what to rebuild, what to retire
  • Performance profiling with reproducible benchmarks, not impressions
  • Security review modelled on the OWASP ASVS and CIS benchmarks
  • Build, release and environment-management assessment
  • Technology selection with the trade-offs written down

What you receive

  • Written assessment report with severity-ranked findings
  • Prioritised remediation plan with effort estimates
  • Reference architecture diagrams
  • Follow-up review after remediation

Typical technologies

  • AWS
  • Microsoft Azure
  • Kubernetes
  • Terraform
  • Observability tooling
Typical duration
2–6 weeks
Engagement
Fixed-fee audit or advisory retainer

Staff augmentation for European businesses

Dedicated Development Teams

Named engineers working inside your process, your repository and your sprint cadence, contracted monthly from an EU-registered company with a 30-day notice period.

  • Named engineers, introduced and interviewed before the contract begins
  • Your repository, your board, your definition of done
  • Overlapping working hours across the Central European timezone
  • Monthly rolling contract with a 30-day notice period
  • Written weekly summary of what shipped and what is blocked
  • EU-based contracting entity for procurement and VAT purposes

What you receive

  • CVs and a technical interview with each engineer
  • Signed framework agreement and per-month statement of work
  • Weekly written progress reports
  • Documented handover if the team composition changes

Typical technologies

  • React
  • PHP
  • Node.js
  • Python
  • Go
  • CI/CD
Typical duration
Monthly rolling, 3-month minimum recommended
Engagement
Time and materials, invoiced monthly

Third-party systems, connected properly

API & System Integration

Designed, versioned and documented APIs, plus integrations between ERP, CRM, payment, logistics and identity systems — with retries, idempotency and reconciliation handled rather than hoped for.

  • REST and GraphQL API design, versioning and OpenAPI documentation
  • ERP, CRM, payment, logistics and identity-provider integrations
  • Idempotent message handling, retries with backoff and dead-letter queues
  • Reconciliation reports so a mismatch is found by us, not by your auditor
  • OAuth 2.1 / OpenID Connect and service-to-service authentication
  • Staged replacement of legacy interfaces using a strangler-fig migration

What you receive

  • OpenAPI specification and generated client documentation
  • Integration test suite runnable against partner sandboxes
  • Monitoring, alerting and a documented failure playbook
  • Migration plan for any interface being replaced

Typical technologies

  • REST
  • GraphQL
  • OpenAPI
  • RabbitMQ
  • OAuth 2.1
  • Webhooks
Typical duration
4–12 weeks per integration programme
Engagement
Fixed-scope delivery or advisory retainer

About the durations on this page

They are typical ranges for the shape of work described, based on how these engagements are normally staffed — not a commitment. The date we can actually commit to appears in the written quote, after discovery, and it is the only date we will hold ourselves to.

How we work

Four phases, each ending in something you can hold

Every phase produces an artefact — a specification, an architecture record, a deployable build, a runbook. Progress you can only hear about in a status meeting is not progress.

  1. 011–2 weeks

    Technical discovery

    A paid, time-boxed discovery: we read the existing code and data model, interview the people who run the process today, and write down the constraints. It ends with a specification, not a proposal deck.

  2. 021–2 weeks

    Architecture and scope

    Architecture decisions are recorded with the alternatives we rejected and why. Scope is split into milestones that each end in something demonstrable, so progress is observable rather than reported.

  3. 03Bulk of the engagement

    Iterative delivery

    Two-week iterations against your repository and your board. Every iteration ends with a deployable build, automated tests, and a written summary of what changed and what is still open.

  4. 041–2 weeks, then optional retainer

    Handover and support

    You receive the source code, the infrastructure definitions, the runbook and a recorded walkthrough. Continued support is a separate, optional agreement — never a dependency we engineer in.