Mark Korotin
About

I build systems that outlast the projects they were built for.

Not a developer portfolio. Not a resume. The long version of what drives the work.

Singapore · Remote (APAC, UTC+8)

The Journey
Early career

Learning how systems break

I started building software when a crash meant a restart and a bug meant a phone call. The problems I found interesting were never in the features — they were in the foundations. The data model that made three years of product decisions wrong. The architectural choice that looked clever and became a ceiling.

Marketplaces & FinTech

Where correctness is not optional

Fintech taught me something most product work doesn't: correctness has a cost, and incorrectness has a higher one. Building matching engines and ledger infrastructure for markets that don't close, you learn what it means to design for invariants. A crypto exchange engine I architected holds order-match latency under fifty milliseconds at peak — distributed, idempotent, consistency-first. Every assertion in the code is a claim about the world. You had better be right.

Developer Platforms

Abstraction as product

The most interesting work I ever did was not building features — it was building the thing that made features easier to build. DjangoCFG came out of that: an opinionated, AI-native framework that compresses weeks of SaaS scaffolding into roughly thirty seconds, without accruing the debt. A developer platform is a different kind of product. You are shipping leverage. The compounding is real. And the moment you get the abstraction wrong, you own the debt forever.

Applied AI

Where I am now

The applied-AI moment feels exactly like the early internet did: enormous surface area, enormous confusion about what actually matters. Most AI products are demos dressed as products. The hard work — the work I care about — is the infrastructure that makes them reliable, observable, and genuinely useful. That is Cmdop: a production agent runtime where every tool call runs through an eval and instrumentation loop before it touches a live system.

A platform is not a feature.It's compounding leverage.

Working Philosophy
01

Build for leverage

Every system I design should make the next system cheaper to build. If it does not compound, it is not worth building.

02

Correctness before cleverness

Clever code is the kind you regret. The best systems are boring in exactly the right places and interesting only where it counts.

03

Abstractions are products

A good abstraction hides complexity and reveals intent. A bad one hides both. Treat every interface you ship as a product decision.

04

Humans belong in the loop

Automation should expand human capacity, not replace human judgment where judgment is the point. Every agent system I build has a ceiling on autonomous action.

How I Think

From first principles

I rarely accept the framing of a problem as given. Most hard problems have an easier version hiding inside them, and the hard version exists because someone stopped asking why too early.

Systems before features

Features ship. Systems last. I try to understand what kind of system a product is before I think about what it should do. The structure of the thing determines what is easy and what is permanently hard.

Interfaces as contracts

Every API, every data model, every abstraction boundary is a contract. Contracts should be narrow, stable, and honest. If you can't explain the contract clearly, the design is wrong.

Write to think

I write before I code. If I can't explain the design in plain language, I don't understand it well enough to build it. Writing is the fastest way I know to find the holes.