What we do.

Local models for the data you can't send anywhere. Frontier models for the work where the smartest reasoning pays off. Routed sensibly, behind your firewall, on hardware you already trust — including Power and Linux on Power.

We design agentic workflows that actually deliver code: scaffolding, refactoring, test generation, RPG and COBOL comprehension, modernisation toolchains. The goal is engineering throughput, not demoware.

• ▸Local + frontier model routing with data-residency rules
• ▸Agentic development setups for in-house engineering teams
• ▸RPG, COBOL, Java, and Python codebases — read, explain, refactor
• ▸Evaluation, guardrails, and observability from day one

An API strategy that takes IBM i and Power workloads seriously — not as legacy to be hidden, but as systems of record to be exposed safely. Architecture, gateway, governance, and the integration plumbing in between.

We've worked across the IBM integration stack — API Connect, DataPower, MQ — plus REST, SOAP, and the messaging patterns that hold large enterprises together.

• ▸API architecture and product strategy
• ▸Gateway and policy design (rate limiting, auth, observability)
• ▸IBM i / Db2 for i exposure via REST and SOAP
• ▸Integration with API Connect, DataPower, MQ, and message brokers

Twenty-year-old RPG isn't bad code — it's the code that's been running the business while everyone argued about microservices. The right answer is almost never a full rewrite.

We help teams make legacy systems observable, testable, and progressively replaceable. You get an honest map of the estate and a sequence of moves that compound, not a year-long rip-and-replace project with a vendor lock-in at the end.

• ▸Estate assessment and dependency mapping
• ▸Strangler-fig migrations on your timeline
• ▸Db2 for i, Oracle, and midrange database modernisation
• ▸Knowledge capture before the original engineers retire

Java still runs the back end of most enterprises we work with. We deliver production-grade Java engineering for greenfield systems, brownfield extensions, and the tricky integrations between them — Spring Boot, Spring Cloud, Jakarta EE, WebSphere Liberty, Quarkus, and the JVM tuning that decides whether a service survives Monday morning.

From service design through to performance work — heap analysis, GC behaviour, classloader untangling — we build Java that other engineers can read, deploy, and own after we're gone.

• ▸Spring Boot / Spring Cloud microservices and modular monoliths
• ▸Jakarta EE on WebSphere Liberty, Open Liberty, and Quarkus
• ▸JVM performance tuning, profiling, and memory analysis
• ▸Test strategy: JUnit, Testcontainers, contract tests, mutation testing
• ▸Build and CI pipelines with Maven, Gradle, and reproducible artefacts

Solution architecture for systems that have to integrate with reality: existing IBM estates, regulated environments, multi-vendor stacks, and teams who'll still be running the thing five years from now. We design for the constraints you actually have, not the green-field one nobody works in.

Deliverables are concrete — context and container diagrams, sequence and data-flow models, NFR budgets, ADRs, and migration sequences that map to sprints. We stay close to delivery so the architecture and the running system stay in sync.

• ▸Target operating models and reference architectures
• ▸C4 modelling, ADRs, and decision records that survive turnover
• ▸Cloud, hybrid, and on-prem trade-off analysis (incl. Power and OpenShift)
• ▸Integration patterns: event-driven, API-led, messaging, batch
• ▸Non-functional requirements: security, resilience, observability, cost