AI business evolution

From chaos to system From routine to automation

Finances become transparent, decisions more precise, processes faster, and resources are freed up.

I solve business problems by putting AI where it actually helps.

This page is the work plan itself: six steps, in the order they happen

Step01

From chaos to system

What hurt the business

The whole IT setup is scattered across different services. Data is smeared across ten Google Sheets, Telegram DMs and people’s heads. When key people leave, access and context leave with them.

In that kind of mess everything else becomes pointless. Order first, then the rest: automating chaos only gives you faster chaos.

Scattered spreadsheets, chats and «someone knows» turn into one system with roles, permissions and a single source of truth.

Internal system · In production
Management finance loop
Every number the company has lives in one system
The pain
The numbers lived in ten spreadsheets, private chats and the heads of three people. When key people left, both access and context left with them.
Now
One source: cash flow, budget, payment requests, reconciliation and reference books in a single application with roles and permissions.
Timeline
one month
Replaced
ten spreadsheets and a chat thread
Coverage
cash flow, budget, requests, reconciliation
The same system pays off across 3 more steps
Open the case
Internal system · In production
Data platform
One source of truth instead of everyone’s own report
The pain
Every department exported marketplace data its own way, so meetings started with an argument about whose spreadsheet was right. Last year’s history did not exist at all.
Now
The platform collects data on a schedule and takes it through layers up to ready-made data marts. From there everyone (people, applications and agents) takes the numbers from the same marts.
Collection
Coverage
Replaced
manual exports in every department
The same system pays off across 2 more steps
Open the case
Internal system · In production
IT infrastructure inventory
Services, access and owners in one place
The pain
The inventory lived in a legacy panel and scattered notes: who is connected to what, what runs where, who owns it. When a person left, access and context left with them.
Now
One panel: a service tree, the «who has access to what» matrix, keys and portals, tasks, problems, changes and an audit log. Login under your own account, sections visible by role.
Sections
Timeline
Replaced
a legacy panel of 35 tabs
Open the case
Internal system · In production
Map of the legacy warehouse
What sits in the legacy database is now known
The pain
The legacy warehouse arrived as a black box: several databases, hundreds of tables and views, an OLAP cube, no description at all. Every question started with excavation.
Now
A reusable client, a CLI for queries and a data map rebuilt by one command: databases, tables, views, columns, with a map of the cube beside it. Plus a check that the data can be trusted.
Map coverage
Updating
the map is rebuilt by one command
Data check
cube freshness and cube-against-SQL reconciliation
Open the case

Step02

Transparent finances

What hurt the business

Nobody knows today’s real account balances or net profit for sure. Payment requests get approved in chats, and the risk of a cash gap never goes away.

The first thing a system gives you is visibility of money. Cash flow, budget, payment requests with an approval route, reconciliation: not in ten files held by three people, but on one screen that adds up.

Internal system · In production
Management finance loop
Money becomes visible: balance, profit, cash gap
The pain
Nobody knew today’s real account balance or net profit for sure. Payment requests were approved in chats, and the risk of a cash gap never went away.
Now
Cash flow, budget and reconciliation on one screen, payment requests travel an approval route, and the numbers on that screen add up.
Market alternative
Verified against
the bank statement
The same system pays off across 3 more steps
Open the case
Internal system · In production
Data platform
Marketplace payouts and fees reconcile to the kopeck
The pain
Fees, logistics, storage and penalties are only visible in the marketplace’s own reports. There was nothing to check them against, so margin was taken on faith.
Now
A dedicated data mart compares our weekly totals with the totals the marketplace itself calculated. An empty result means everything matches; a row with a difference shows exactly where it does not.
Verified against
Reconciliation
runs itself, every week
The same system pays off across 2 more steps
Open the case
Own product · In production
Marketplace payout documents
You can see what will arrive and what goes to tax
The pain
The marketplace hands financial documents over as a pile of files. To work out the year’s income and the tax on it, a seller opens them one by one and adds them up.
Now
The service fetches a year of documents itself, parses PDFs and spreadsheets, lays amounts out by month and calculates the tax: 4 % from individuals, 6 % from companies.
Tax
Regime limit
2.4M ₽ a year, the remainder in plain sight
Fetching documents
pulled from the account by the service
hubmarket.ru
Open the case
Open source · In production
Ads and SEO from chat
The ad budget changes by the rules, not by guesswork
The pain
Budgets and bids live in an account where an edit applies at once. A mistake costs a weekly budget burned over the days that are left, and a strategy’s training reset halfway.
Now
An open MCP server: 125 tools across Direct, Metrika and Webmaster. A writing call previews what would be sent, the change percentage is capped per project, and the weekend rule brings its own warning.
Tools
A writing call
The weekend rule
GitHub
Open the case

Step03

Precise decisions

What hurt the business

Margins are estimated roughly or after the fact. Hidden marketplace fees and penalties quietly burn through net profit.

When data reconciles down to a single unit, decisions stop being a clash of opinions.

Margin per marketplace account and per SKU is not a feeling but a number you can trust, because it is reconciled with the source.

Internal system · In production
Data platform
The number is verified against the source down to a single unit
The pain
Data went through four processing layers and nobody compared the result with what the marketplace shows. Decisions rested on a number with nothing to check it against.
Now
Orders, cancellations and stock reconcile with the marketplace down to a single unit, money down to the kopeck, and the check can be repeated any day with one command.
Verified against
Data marts
sales, stock, presence, P&L, reconciliation
The same system pays off across 2 more steps
Open the case
Internal system · In production
Advertising management agents
Bids move on data: the DRR plan is ≤ 10 %
The pain
Bids were moved on yesterday’s report and on a hunch. But «yesterday» does not show what actually happened, and a market-wide drop is easily mistaken for your own mistake.
Now
A decision is assembled in order: market regime, product health, the fair target DRR for this item, and only then the bid itself. Metrics come from a matured window; the DRR plan is ≤ 10 %.
DRR
Decision order
market regime → product health → target DRR → bid
Metrics window
The same system pays off on one more step
Open the case
Own product · In production
Marketplace stores in Claude
An answer about the store in words, without a dashboard
The pain
To understand what is happening in a store, a seller walks three marketplace accounts and merges reports in a spreadsheet. A dashboard answers only what was built into it.
Now
The seller asks in plain words: «what is running out», «is the advertising paying off», «how much will land on my account». Claude goes into the marketplace API with their key.
Coverage
Marketplace keys
Tabular report
downloaded for you and read as rows
measured in August 2026: 945 of 962 operations callable through the API catalogue
The same system pays off on one more step
mcp.hubmarket.ru
Open the case
Open source · In production
Marketplace knowledge base for agents
The agent answers by the marketplaces’ rules, not from memory
The pain
When an AI agent designs logic against a marketplace’s rules, it leans on memory. Tariffs and limits change, memory does not, and errors surface in money, not at review.
Now
A knowledge base of three marketplaces sits next to the project as ordinary markdown files: one per API method plus the seller help. The agent reads the source, not a retelling.
The base
The build
Updating
one command, the git diff as the change report
GitHub
Open the case
Internal system · Pilot
Marts on top of the data lake
Margin per product and, separately, what does not land on it
The pain
Product economics were counted off the marketplace report. Cost price sits on logistics rows too, and there are far more of those, so it came out an order of magnitude high.
Now
Two marts: one holds what honestly lands on a product, the other storage, intake, penalties and withholdings that do not spread across items. On screen they are a separate block, not profit that is absent.
The operation-type filter
What the dashboard answers from
The period ceiling
15 % of the source’s non-empty tables serve data older than a week, and the catalogue does not tell them from the live ones
Open the case

Step04

From routine to automation

What hurt the business

Managers spend hours copying product cards, assembling labels and PDFs by hand. Human error and typos in SKUs cost penalties and returns.

Only what is ordered can be automated; that is why this step comes second, not first.

Repetitive manual operations (cards, labels, documents, file conversion) go to the system entirely: what was done by hand every day starts happening by itself.

Internal system · In production
Product portal
Catalogue, labels and PDFs: one button
The pain
Every label was assembled by hand, in five steps through the external PLM. A typo in an SKU turned into a penalty and a return.
Now
The product catalogue, label printing, PDF generation and image conversion live in one portal. Five manual steps collapsed into a single «Print label» button.
Label printing
one button instead of five steps
Coverage
catalogue, labels, PDFs, conversion
Replaced
an external PLM system
The same system pays off across 2 more steps
Open the case
Internal system · In production
Advertising management agents
The operator’s daily cycle runs itself
The pain
The morning started with a manual round of the accounts: spend, DRR, campaigns spending without orders, bids in a spreadsheet. It ate half a day.
Now
Calibration, the scanner and bid proposals run overnight; in the morning one command gives the operator the whole summary. The agents themselves never write into the account: a human confirms first.
Overnight cycle
calibration, scanner, bid proposals
Operator commands
Write into the account
The same system pays off on one more step
Open the case
Own product · In production
Marketplace stores in Claude
Routine checks close with a question in chat
The pain
The daily checks (what is running out, what is blocked, what arrived in payouts) mean walking three accounts by hand. Nobody does that every day, and problems surface late.
Now
A check turns into a question in chat: Claude calls the marketplace methods it needs and answers to the point. A writing call does not go out first time: a preview first, the send on a second call.
Daily check
a question in chat instead of a round of accounts
A writing call
A read-only key
The same system pays off on one more step
mcp.hubmarket.ru
Open the case
Internal system · In production
Warehouse stock sync
Warehouse stock reaches the store on its own
The pain
Warehouse stock and the online store’s catalogue lived apart: a buyer saw availability the warehouse no longer had, and fixing it meant doing it by hand, item by item.
Now
A run takes fresh warehouse stock and brings the store catalogue in line with it. The state is recalculated in full, so discrepancies never accumulate, and only the items that changed are written.
Catalogue
~22,000 products
The run
a full recalculation, one command
Circuit breaker
Open the case
Internal system · Pilot
The company’s agent platform
Routine is ordered on a form, not filed as a developer’s task
The pain
Repetitive manual work settled in chat threads: someone asked for it to be automated, the request got lost between people, and nobody saw the next team asking for the same.
Now
An employee files a request on a form, in the language of their own work. An agent is one file with a prompt and no code of its own, and requests are visible to all, so identical asks stop drifting apart.
A new agent
The audit gate
What agents may do
Open the case

Step05

Faster processes

What hurt the business

Any IT change drags on for months. Contractors miss deadlines and inflate estimates, and the business loses its pace of testing hypotheses.

Speed is a consequence, not a slogan: it appears once the system sits on a pipeline.

From idea to an application running in production takes a day, not months. Changes reach users the same day, with automated checks and automatic rollback.

System	First commit	Prod pipeline ready	Gap
Management finance loop	13 Jul	14 Jul	1 day
IT infrastructure inventory	17 Jul	17 Jul	same day
Product portal	23 Jul	23 Jul	same day

Internal system · In production
Management finance loop
A report in half an hour instead of weeks
The pain
Management reporting was assembled by hand over weeks: exports, merging, double-checking.
Now
The report comes together in half an hour, data pulls itself in, and budget variances are visible immediately.
Before → after
weeks → half an hour
Data collection
pulls itself in
The same system pays off across 3 more steps
Open the case
Internal system · In production
Product portal
An external PLM replaced in days
The pain
Product data lived in someone else’s system: nothing in it could be changed, and any modification meant months of waiting.
Now
An in-house portal replaced the external PLM in a few days of work. The production delivery pipeline was ready on the day of the first commit, so changes reach people the same day.
Timeline
Delivery pipeline
ready on the day of the first commit
Replaced
an external PLM system
The same system pays off across 2 more steps
Open the case
Open source · In production
Starter application template
From the first commit to a production pipeline in one day
The pain
Between «the first screen is written» and «people can use this» there are usually weeks of setup, and it is assembled again on every project.
Now
One command scaffolds not an empty skeleton but a configured workspace: stack, database, auth with roles, tests, CI and two environments with automatic production rollback.
Timeline
one day to a production pipeline
In the box
database, auth with roles, tests, CI, two environments
two of the three systems on the day of the first commit
The same system pays off on one more step
GitHub
Open the case
Open source · In production
Deploy from chat
A release without manual SSH, straight from chat
The pain
Between «the code is ready» and «people are using it» sits manual fiddling: SSH, a server, a web server, a certificate, a DNS record. Every time from scratch and from memory.
Now
The plugin and the MCP server give Claude Code direct access to the cloud: a server, a database, DNS, a certificate and the release itself are done by a command in chat.
A release
a command in chat instead of manual SSH
In the plugin
Infrastructure
server, database, DNS and certificate by a tool call
GitHub npm
Open the case
Own product · In production
Frontend factory
A screen is assembled from ready blocks, not drawn from scratch
The pain
Every new screen started from nothing: its own components, colours and spacing. A block that worked did not travel to the next project, because it was nailed to its own theme.
Now
A library of authored sections and template pages on top of stock shadcn components. A block transfers as a file: data arrives through props and the colour comes from the receiving app’s theme.
In the kit
Portability
A project’s foundation
webkoth.com/ui-kit
Open the case

Step06

Freer resources

What hurt the business

Growth runs into the scarcity and cost of developers. Payroll swells while tasks pile up in an endless backlog.

The main resource set free is people.

Systems are built not by hired programmers but by the company’s own domain experts (a finance analyst, a product specialist, a content manager) under engineering supervision. Growth stops depending on hiring.

43 %

finance analyst

339 of 784 commits

73 %

product specialist

67 of 92 commits

73 %

content manager

11 of 15 commits

Internal system · In production
Management finance loop
A finance analyst develops it, not a programmer
The pain
Every change ran into hiring and a queue to the developer: growth depended on whether a person could be found.
Now
The finance analyst extends the system directly; the engineer owns review and the release to production.
Maintained by
a finance analyst
Specialist’s path
one month to margin calculation
43 % of changes are made by a company specialist, not a programmer
The same system pays off across 3 more steps
Open the case
Internal system · In production
Product portal
A product specialist runs it: 73 % of changes are theirs
The pain
A fix in product data had to be ordered: from the PLM vendor as a paid modification, internally as a ticket to a developer. Either way it meant a queue.
Now
The portal is run by the product specialist, the person who fills in the product cards every day. The engineer owns review and the release to production, not the next card attribute.
Maintained by
a product specialist
Specialist’s path
days to a working portal
73 % of changes are made by the product specialist
The same system pays off across 2 more steps
Open the case
Open source · In production
Starter application template
Seven applications in a month with one team
The pain
Every new project started with a week of setup, and only an engineer could do it. The queue to that engineer was the real ceiling on speed.
Now
Setup stopped being the bottleneck: the order those three production systems were built in is folded into a single command. In that same month one team launched seven applications.
Launched
Maintained by
an engineer and company specialists
Workspace
skills and commands for daily work
The same system pays off on one more step
GitHub
Open the case
Open source · In production
Seller workspace
A seller runs sales without hiring an analyst
The pain
Going through sales, unit economics, the funnel, card SEO, ABC analysis and competitors is a job for a separate person. A small store has nothing to hire them with.
Now
An open template: one clone per store, keys in the environment, connectors to three marketplaces and seven commands for those questions. Intended so; how far it replaces an analyst I have not measured.
Commands
report, unit economics, funnel, SEO, ABC, competitors
Model
Changing a price
«before → after» first, confirmation after
GitHub
Open the case
Own product · In production
Content factory
A video from script to subtitles, without contractors
The pain
Video means a scriptwriter, a motion designer, an editor and someone to lay the text out across platforms. For one author that is a contract per video, or no videos at all.
Now
A workshop in a repository: commands write the script in blocks, overlays and diagrams are built in code, and a local Whisper does the transcription. Filming, editing and publishing stay with the human.
In the workshop
The graphics library
Subtitles
nine videos taken through to publication, two still in progress
Open the case

Named case

Case: HubMarket.ru

AI SaaS for marketplace sellers

My own product, which I run as founder and sole developer. Everything described in the six steps above (queues, an AI cascade with fallback, a data warehouse with reconciliation, a production pipeline from day one) runs here for external users.

hover any node and a description appears

data flow

Next.js 16React 19Prisma 7PostgreSQLpg-bossHonoAI SDKClaudeGeminiGroqPython · FastAPIPlaywrightSentry · pinoYooKassa

Product interface

Summary: revenue, profit, business health
Unit economics per SKU
Reviews: AI-drafted replies
Seasonality: demand forecast

How it happens

From idea to production

The page above is the work plan. Here is how it gets executed.

01
Review
Three questions: what you have already tried with AI and what of it works; who you plan to hire and why you haven’t yet; who in the company understands the painful process best. If the scheme doesn’t fit you, I’ll say so right away.
free · 30–45 min
02
Audit and map
A review of the prototype graveyard: what works, who owns it, on what data, what breaks. A process map: what goes into an application, what to an agent, what to a person with AI, what not to touch at all. Choosing the first process and measuring the baseline. Some prototypes get fixed in hours: quick wins already during the audit.
2–3 weeks · a document with a map and priorities
03
Launching the first process
The pipeline is set up on day one: project generator, CI, two delivery environments, auto-check and auto-rollback. Your domain expert builds the domain part with Claude Code within strict stack boundaries; I take it to production: data, exceptions, failures, monitoring, access. The system owner stays inside the company.
4–6 weeks · a working application + a trained employee
04
Support
Reviewing the changes your specialists make, shipping to production, the next processes. The only path to production is through review, so the system doesn’t fall apart when non-programmers grow it.
ongoing · growth without hiring

Step07

This is what business evolution is

An honest line to set me apart: the path did not work the first time. Of four attempts at one task, three were stopped, and I know exactly why the fourth one lives: methodology, not technology.

That is why I sell not «AI adoption» but getting to the result.

You already have AI. It just doesn’t work. I know what separates an attempt that will die from one that will run.

Four attempts at one task

Attempt	Period	Commits	Outcome
#1	29 May – 5 Jun	67	stopped
#2	19 Jun – 9 Jul	48	stopped
#3	9 Jul – 25 Jul	53	stopped
#4	13 Jul – 14 Aug	784	running and growing

In attempt #2 most changes were already made by domain experts, and the project still stopped. The difference between it and the fourth: strict stack boundaries, mandatory design before code, a single path to production through review, and a delivery pipeline from day one.

Request

Review my situation

The first step is a free diagnostic review (30–45 min) of your current processes and prototypes.

What you get from the review:

A map of bottlenecks and hidden losses in your current processes and spreadsheets.
An audit: why previous attempts to roll out software or AI stalled.
A step-by-step plan: how to digitise a key loop in one month with your own team.

Message me directly on Telegramor leave your contact in the form below:

From chaos to system From routine to automation

From chaos to system

Transparent finances

Precise decisions

From routine to automation

Faster processes

Freer resources

Case: HubMarket.ru

From idea to production

Review

Audit and map

Launching the first process

Support

This is what business evolution is

Four attempts at one task

Review my situation