Technologies

The default language for ForkTex backends, standardised on 3.14 across the ecosystem.

Every web and mobile surface, in strict mode, with API types generated rather than written.

Fiscal-device integration, where the vendor relay is a .NET service.

Used for JVM-based delivery where a client stack required it.

Entrypoints and operational scripts, kept thin enough to read at a glance.

Schema and query work, written through an ORM rather than assembled as strings.

The unit of deployment everywhere — the same image runs locally and in production.

Build and server runtime for every TypeScript surface.

Mobile targets reached from one codebase, alongside a web build.

The provisioning target for managed servers, pinned to an LTS release.

The API framework behind every ForkTex service, async from the route down to the driver.

The component model shared by every web and mobile client.

App Router, server rendering by default, for public sites and operator consoles alike.

One codebase reaching iOS, Android, and web without three separate builds.

Native mobile clients sharing types and API layer with the web.

Long-run maintenance and feature work on an existing operator frontend.

Maintained and extended on an inherited Node backend.

JVM service framework, used where a client stack was already committed to it.

Validation and serialisation at every boundary — the wire shape is a declared type.

The test runner in every Python repository, async mode on by default.

Formatting and linting, identical locally and in CI, as one gate atom.

The data-access layer everywhere, async, with no hand-assembled SQL strings.

Schema migrations, applied on startup so an environment cannot drift behind the code.

Client state, paired with generated API bindings rather than hand-written fetches.

Typed data fetching generated from the API schema — see the codegen practice.

Styling for every web surface, themed through CSS custom properties.

Template rendering for documents and transactional email.

Form state and validation without re-rendering a page on every keystroke.

HTML to PDF for issued documents — invoices, reports, certificates.

Runtime schema validation on the client, matched to the server contract.

Browser automation for data acquisition and full-stack verification.

The default database, and often the queue and the scheduler too.

S3-compatible object storage, self-hosted, for documents and uploads.

Caching and task brokering where a round trip needs to disappear.

Self-hosted vector search behind retrieval pipelines — no managed dependency.

Operated and tuned on an inherited production system.

Document storage, reached through the substrate facade where a case calls for it.

Durable workflows in PostgreSQL — no broker, no scheduler process, no control plane.

Redis-backed async task queue for background work.

Declarative cloud infrastructure on client estates already standardised on it.

Provisioning and release automation for managed servers.

Slot routing that makes a blue-green cutover a proxy change, not a restart.

Edge termination and static serving, generated rather than hand-configured.

Our own deployment platform: a manifest becomes a running, TLS-terminated system.

Delivered into client AWS estates, managed as code rather than by console.

Functions, AI Search, Service Bus and storage on client-mandated Azure estates.

DNS and edge protection, and the challenge path for automatic certificates.

European compute underneath ForkTex Cloud, with data staying in the EU.

Existing APIs projected as agent-callable tools, without a second implementation.

GPT models, used interchangeably with other providers behind one capability layer.

Grounded answers over a document set, where retrieval quality is the real bottleneck.

Embedding-based retrieval, self-hosted, with reranking over raw similarity.

Claude models behind reasoning, extraction and structured-output workloads.

Structured records pulled from PDFs, images and spreadsheets under a declared schema.

One schema generates every client. No hand-written wire model is allowed to drift.

A new version proves itself healthy before traffic moves, and rollback is a route change.

Tests run against real PostgreSQL and Redis, because a mock encodes what we believe.

Generated artefacts are regenerated and byte-diffed in CI, so a hand edit fails loudly.

Pagination that stays constant-time at page 500 instead of reading and discarding rows.

The shared Python library every service composes: four primitives and eight facades.

Structured data to canonical model to block tree to PDF. A document is a view, never a source.

Acquire public data, and be able to prove afterwards exactly what was acquired.

Tables, columns and relations declared at runtime rather than at deploy time.

Documentation as typed JSON, rendered to markdown, retrievable within a token budget.

The service blueprint: async FastAPI, real-infrastructure tests, generated clients.

The web blueprint: Next.js App Router, generated API bindings, one quality gate.

The mobile blueprint: Expo and React Native reaching iOS, Android and web at once.

One command decides whether a change is done, and CI runs exactly that command.

Checkable atoms gathered into levels, so delivery maturity is measured rather than claimed.

An error carries a code, not a status — the transport decides what a code means.

camelCase on the wire, snake_case in Python, with no hand-written translation layer.

One module decides how a moment becomes text: always UTC, always the same shape.

Time-ordered identifiers, never truncated — a slice is a collision, not a shortening.