Contract architect · backend · ERP · data

Backend systems that survive their third year

I design and build backends in Go for domains that are genuinely complicated — accounting, inventory, logistics, multi-tenant platforms. Decisions get written down before code, so the system can be handed to someone else without archaeology.

  • Go · PostgreSQL · gRPC · Kafka
  • Modular monolith over premature microservices
  • C4 model and ADRs, not tribal knowledge

Tell me what you are building

A few sentences are enough: the domain, what exists today, and what hurts. You get a written reply with an approach, not a sales call.

  • 9+ years building production systems, since 2015
  • Multi-tenant ERP in production, not a side project
  • Registered business · OGRNIP 324190000021130
  • Verifiable CV and work history ↗

What I do

Four kinds of work I take on

All four share one thing: they need someone who can hold the whole system in their head and write the decisions down. If your problem is adding screens to an app that already works, you want a team, not me.

01

Backend and API development

Services in Go with a clean domain layer, explicit invariants and predictable behaviour under load.

  • DDD aggregates, status state machines, typed errors
  • gRPC and GraphQL contracts with breaking-change checks
  • Reversible database migrations that roll back cleanly
  • Dependency injection through constructors, no global state
02

ERP and accounting domains

Document flow, finance, inventory, procurement, pricing — modelled as one coherent system rather than a pile of CRUD screens.

  • Single document engine with a status state machine
  • Document lineage: what was created on the basis of what
  • Warehouse core with addressable storage
  • Multi-tenancy with data-level isolation and sharding
03

Integration and event-driven design

Systems that exchange data without losing it, and without silence when something breaks.

  • Transactional outbox, so events survive a crash mid-commit
  • Idempotent consumers keyed on a stable identifier
  • Exchange journal and alerts instead of guessing
  • CQRS read models projected from the event stream
04

Databases, SQL and data platform

Nine of my years are in data before they were in backend. Query plans and schema, not "add more RAM".

  • PostgreSQL and MS SQL Server schema design
  • Query and index work driven by execution plans
  • Data warehouse on ClickHouse, ETL on Apache Airflow
  • Migrations between engines, including MS SQL to PostgreSQL

Case studies

Three systems, three different problems

These are systems I designed and built, not projects I consulted on from a distance. One client is under NDA, so that one is described by its engineering rather than its name — I would rather say so plainly than invent a logo wall.

ERP · multi-tenant platform

Modular ERP platform

Multi-tenant ERP as a modular monolith: domain modules in one codebase, gRPC inside, a GraphQL gateway outside, PostgreSQL as the source of truth, Kafka for events and Elasticsearch for search.

10+domain modules in production

Architecture recorded in a C4 model and a body of ADRs; module boundaries enforced by CI, not by convention.

Logistics · microservices

Logistics operations platform

Eight scalable microservices behind a central API gateway, replacing a process that had been partly manual. Go on the backend, Nuxt 3 operator panel, MS SQL Server, centralised logging through Vector into Elasticsearch.

16 h → 9 mincore process turnaround

The number is the whole point: same work, same people, two orders of magnitude less waiting.

Retail · allocation engine

Retail allocation engine

Decides how much of each article goes to each store, what returns to the warehouse and what moves between stores — with a readable explanation for every decision. Client under NDA; the domain is a retail chain.

3 pipelinesforward, reverse, redistribution

Sales velocity on a smoothed EMA, demand with seasonality and safety stock, every run snapshotted against a job id so results stay reproducible.

100+reversible database migrations in one platform
5databases joined into one fault-tolerant integration
C4 + ADRarchitecture written down, not remembered
2015working in production systems since

Earlier work, for context

Before contracting I spent years inside larger organisations: a cancer research centre (grant and financial flows, laboratory data, regulated pharmaceutical accounting — all calculations at the database level), a tier-one bank (trading system integration, MxML to FIXML transformation), and a gaming holding (data warehouse across MS SQL, PostgreSQL and ClickHouse; migrating ETL from SSIS to Apache Airflow). Delivered as part of contractor teams and directly.

Engagement

Start small, on purpose

You are hiring someone you have not met, in another country, for work that is hard to evaluate from outside. So the first step is deliberately small and produces something you keep either way.

start here

Architecture discovery

Two to three weeks, fixed price. The output is a document set, not a proposal.

from $2,0002–3 weeks, fixed

  • C4 model of the system as it is and as it should be
  • ADRs on the decisions that actually matter, alternatives included
  • Data model and migration path
  • Risk register and a build estimate
  • Everything is yours even if you build with someone else
Discuss discovery →

Delivery sprints

Scope agreed per sprint, demoed at the end of each one.

from $4,500per two-week sprint

  • Working software at the end of every sprint, not a status report
  • Your repository from day one, with CI gates
  • Documentation written along the way, not at the end
  • Or $65/hour on time and materials, if scope is genuinely open
Discuss a sprint →

Fractional architect

You have a team. You do not have someone who owns the shape of the system.

from $2,400per month, part-time

  • Architecture reviews and design decisions in writing
  • Code review on the parts that decide the future
  • CI gates that keep boundaries from eroding
  • Available for your team's questions, in writing
Discuss retainer →

Contract and paymentUSD / EUR

The contracting party is Didenko Maksim Sergeevich, a sole proprietor registered in Russia (OGRNIP 324190000021130, TIN 245735477632). Invoices are issued in USD or EUR and settled by bank transfer to an account outside Russia; exact banking details are agreed before signing. I am happy to sign an NDA before we discuss anything specific.

Prices on this page are starting points, not an offer. Final scope, cost and schedule are fixed in the contract.

Working with me

The honest constraints

Every one of these will surface in week two anyway. Better you know them before you pay.

"You are one person. What happens if you disappear?"

The repository is yours from day one, not on delivery. The C4 model, the ADRs and the migrations are written as the work happens. Handing the project to another Go engineer is a few days of reading, not an excavation — that is the entire reason the decisions are written down.

"How much can you actually take on?"

One substantial project at a time, plus a retainer. I do not subcontract architecture, and I will tell you when a piece of work needs a team rather than pretending otherwise. If your deadline needs five engineers, I am the wrong call.

"Time zones?"

I work at UTC+7. That gives four to six overlapping hours with Central Europe every day, and early mornings only with the US East Coast. For the US West Coast, daily synchronous work is not realistic — asynchronous, with written decisions, is.

"What about English?"

I work in English in writing and on calls. Architecture decisions, trade-offs and scope I put in writing regardless of language — that is how I work anyway, and it happens to remove the ambiguity that accents introduce.

Questions

Before you write

Not covered here? Ask directly — a straight question gets a straight answer.

Why a modular monolith and not microservices?

A modular monolith gives clean domain boundaries without the operational cost of a distributed system. I split a service out when a domain has its own load profile, its own ownership and its own release cycle — not before. Most teams pay the distributed-systems tax years before they get any benefit from it.

Who owns the code?

You do. Work is committed to your repository from the first day, infrastructure is provisioned in your accounts, and rights transfer under the contract. There is no platform licence and no dependency on me continuing.

Can you join an existing project?

Yes, and that is often the better first step. I start with an architecture review, record the findings as ADRs, and set up the CI gates that stop the system degrading further. Sometimes the outcome is "this is fine, here are three things to fix" — you get that answer too.

Do you take fixed-price whole projects?

For discovery, yes — that is why it is fixed. For a full build, only after discovery, because a fixed price on an unexamined problem is either padded or a future argument. Sprints with agreed scope are usually the honest middle.

What does the first two weeks look like?

A call to understand the domain and constraints, read-only access to the existing system if there is one, then written work: the system map, the risk register, the decisions that need making. You see drafts as they appear, not a reveal at the end.

Contact

Describe the problem — you get an approach, not a pitch

I reply within one business day. If the work is not a good fit for me, I will say so directly and, where I can, point you somewhere better.

Email[email protected]
Time zoneUTC+7
Response1 business day
CVWork history ↗ Write an email →