ls services/

What we do, in detail

Three directions: AI integration, high-load engineering and security. On most projects they overlap. An AI feature still has to handle production traffic, and a system under load still has to hold up against an attacker.

01 / ai

AI integration and LLM systems

We build LLMs into your product so that they work in production, answer from your data rather than guesswork, and stay within the token budget.

01

AI integration in products

We add LLM features where they solve a real business task. We start with the cheapest option, a prompt on a base model, and add RAG, agents or fine-tuning only when evaluation shows the goal cannot be reached without them.

  • Assistants and copilots. In the product, in admin tools or in the IDE, with context from your system and tool use.
  • Generation and summarization. Product descriptions, reports, call summaries and email drafts with quality control and a consistent tone.
  • Search and autocomplete. Semantic search, query rewriting and intent classification.
  • Classification and extraction. Ticket routing, entity extraction, parsing of emails and invoices.
02

RAG and enterprise search

We turn your documents into a question-answering system that cites its sources and keeps hallucinations under control. Chunking, retrieval, re-ranking and answer checking are each measured separately.

  • Vector storage. pgvector, Qdrant or Weaviate, chosen by load and by what your team can operate.
  • Hybrid search. BM25 combined with embeddings, with a fusion strategy tuned to your domain.
  • Re-ranking and query rewriting. Cross-encoder re-ranking, HyDE and multi-query, kept only where they improve recall.
  • Evaluation. Ragas and golden datasets; faithfulness and context precision are release criteria.
03

AI agents and orchestration

Multi-step agents that perform actions in your systems through tool use and MCP. Where a mistake is expensive, a person approves the step before it runs.

  • Orchestration. LangGraph, custom orchestration and state machines, so that every step is explicit and traceable.
  • Tool use and MCP. Function calling and Model Context Protocol with safe, scoped access to your APIs.
  • Sagas and compensation. When a step fails there is a rollback, a retry and a clear audit trail.
  • Human in the loop. Approval stages, escalation to support and an operator interface that shows what the agent did.
04

Low-code automation: Zapier, Make, n8n

When several systems need to be connected quickly, such as a CRM, messengers, document storage and forms, a low-code platform gets a process running in days. It does not replace engineering, but it is often the right first iteration before the flow is rewritten in code.

  • Platform choice. Zapier, Make or n8n, chosen by compliance needs, hosting constraints, operation volume and budget.
  • AI flows. LLM steps, RAG calls, classification and summarization inside the flow.
  • Self-hosted n8n. When data must stay inside your perimeter: deployment with authentication, audit logs and backups.
  • Low-code to code. When a flow outgrows the platform, we move it into a regular service and keep its logic and history.
05

LLMOps and AI infrastructure

The production layer around the models: gateway, caching, rate limits, observability, evaluation and A/B tests. It is usually postponed until the first large bill arrives.

  • Model gateway. Routing between Claude, GPT and Llama by task type, with fallback and a single API.
  • Caching and batching. Semantic cache, prompt cache and request batching to bring token cost down.
  • Observability and evaluation. Langfuse, OpenTelemetry traces, golden datasets and regression tests.
  • Fine-tuning and self-hosting. LoRA and supervised fine-tuning; vLLM, TGI or Ollama on your hardware when data cannot leave the network.
02 / engineering

Architecture and high-load engineering

Architecture, performance, migrations, infrastructure and SRE, for AI services and conventional products alike.

01

High-load architecture

We design systems that absorb traffic spikes and grow predictably, either from scratch or on top of existing code, without rewriting everything. Whether that means microservices or a monolith depends on your team and your domain.

  • Design from scratch. System design, stack selection and a roadmap from MVP to production.
  • Event-driven and CQRS. Outbox pattern, saga orchestration and delivery guarantees on Kafka or NATS.
  • Multi-region and failover. Active-active and active-passive schemes, with disaster recovery drills.
  • API design. gRPC and REST contracts, versioning, BFF layers and public APIs.
02

Performance audit and load testing

We take your service, its metrics and traces, and in two to four weeks deliver a report that shows where it breaks, at what request rate, and why. The report names specific bottlenecks and the order in which to fix them.

  • Service profiling. pprof, async-profiler, eBPF tools and flame graphs on the hot paths.
  • Database analysis. EXPLAIN ANALYZE, pg_stat_statements, indexing strategy and lock contention.
  • Load scenarios. k6, Gatling or JMeter with profiles that match real traffic.
  • Capacity planning. What a given cloud budget buys you, and where money is being wasted.
03

Migrations and refactoring

We split monoliths, extract services and change storage without downtime and without a rewrite from scratch. The approach is strangler fig: every step is measurable and reversible.

  • Monolith decomposition. Bounded contexts identified by domain, services extracted one at a time.
  • Online database migrations. Engine changes, sharding and schema changes under load.
  • On-premises and cloud. Moves into AWS or GCP and back out of the cloud, followed by optimization for the new environment.
  • Cloud cost reduction. Right-sizing, spot and preemptible capacity, FinOps practice.
04

Infrastructure and SRE

We build Kubernetes platforms and set up GitOps, observability and on-call processes that hold up during a real incident at night. The test of a platform is whether a new team can ship on its first day.

  • Kubernetes platform. Multi-tenant clusters and sensible defaults for product teams.
  • GitOps and infrastructure as code. Terraform, Argo CD and Flux; infrastructure changes go through review.
  • Observability. Prometheus, Grafana, OpenTelemetry, Loki and Tempo for metrics, logs and traces.
  • On-call and postmortems. SLOs, error budgets, rotations and blameless postmortems.
03 / security

Security

We review code and systems for vulnerabilities and help fix what we find. All testing is done only with the written permission of the system owner.

  • Code security audit. Manual review plus static analysis, with findings ranked by risk and a fix for each.
  • Penetration testing. Web applications, APIs and infrastructure, in black, grey or white box mode as agreed.
  • Security checks in CI. Static analysis, dependency, secret and container image scanning in the pipeline.
  • Cloud and configuration review. Access rights, network exposure, secrets storage and Kubernetes configuration.
  • Security of AI systems. Prompt injection, data leakage through LLMs, unsafe tool use and access control in RAG.

security in detail

Next step

Not sure which service you need?

Describe the project in your own words and we will help you scope it. We reply within one working day.

Discuss a project