The website on our own code: releases in 2–3 days instead of 5–7 and 4x cheaper development
How we moved the site from a no-code builder to scalable infrastructure without stopping sales
- Webflow builder
- Changes through in-house developers
- Automations in Make
- Brief to release: 5–7 days
- Next.js, React, TypeScript, Tailwind
- Design system from Figma in code
- I build pages with Claude Code
- GitHub, automated tests and staging
- Own server in Docker, one-command deploy and rollback
- The same Make scenarios
- Brief to release: 2–3 days
5–7 → 2–3
days from brief to a live page
×4
lower development cost per quarter
0
release rollbacks since the move
73
pages moved without stopping sales
93
live automation flows kept running through the move, with no stop to requests or payments
50+
pages of infrastructure documentation before the move
Context and goal
Problem
The site ran on the Webflow builder, with requests and payments on Make automations. That infrastructure was hard to scale: a page change took 5–7 days from brief to release, Make was expensive, and Webflow IP addresses were being blocked in Russia, so the site had to rely on temporary CDN workarounds. Since 2022 the company had been moving its infrastructure from foreign services to solutions built for the Russian market, and the site was one of those dependencies.
Goal
Make the site’s infrastructure scalable and fast: ship pages faster and cheaper, stop depending on blocks, and keep sales running throughout the move. The constraint: no in-house development — from April 2026 developers worked as contractors paid by the hour.
My role
Before the move I documented the company’s whole infrastructure. From April I owned the automations. A contractor developer moved the backend using my documentation, and we tested forms and payments together. From August I built pages from layouts with Claude Code, and from late August I owned the site’s releases.
The main condition: sales don’t stop
The site is the company’s checkout. So every decision in the move kept the old setup working until the new one was tested.
Move it as is first
A copy of the old site runs on the new platform right away, and pages are rebuilt one by one.
Leave live processes alone
Requests and payments run through the same Make scenarios. The new site is connected to them only after testing on staging.
Speed with a safety net
AI speeds up page builds, and automatic checks keep errors away from users.
The same approach works for any migration: a CRM, a payment system, an internal tool.
A map of the system first
You can’t move blind: first we had to understand what the system consists of and what must not break.
Documentation before the move. I documented the company’s infrastructure — payments, analytics, CRM and newsletters, the bot, the learning platform and the site — over 50 pages. The contractor moved the backend from it, and later outsourced developers and marketing worked from it.
An automation map. We went through all 178 flows in Make, 93 of them live, and marked which part of the system each belongs to. That made it clear what was moving and what must not break.

- A page on the builder
- Request or payment
- Automation in Make
- CRM, payments, newsletters
- Page change through developers: 5–7 days
- A page in our own code from the design system
- Request or payment
- The same Make scenarios, tested on staging first
- CRM, payments, newsletters
- Page change: me with Claude Code, 2–3 days
A move without stopping sales
The map showed what had to move. The main condition was that sales never stop, not even for a day.
The new stack. The site moved to Next.js and React in TypeScript, with styles in Tailwind on design-system tokens. The code lives in GitHub, the site runs on our own server in Docker, and requests and payments go through the same Make scenarios.
The whole site from day one. We copied all 73 pages and ran the copy on the new platform. Users didn’t notice the move, while we rebuilt pages from layouts one by one and switched them separately.
Requests and payments without risk. We didn’t touch the live automations. The new site got copies of them, and before the switch we tested every payment method and every form on staging.
No traffic lost. Old links from newsletters, ads and search kept leading to the right pages, and the old version of the site was hidden from search engines so results wouldn’t show duplicates.
Design system and building with AI
The site moved as is. Next, pages had to be rebuilt and new ones shipped, quickly and without in-house developers.
One source of truth for design. Colours, fonts, sizes and spacing were carried over from Figma into code and defined in one place, and pages are built from shared React components. So new pages look consistent and get built faster.
A living style guide. A dedicated page shows every design-system element exactly as it looks on the site. Designers and everyone who builds pages check against it.
Building with AI. Claude Code reads the layout from Figma and builds the page from ready components. My part is to set the task, check the result on phone, tablet and desktop and decide what goes into the release.

› Colour tokens

Speed with a safety net
Fast AI builds without checks mean fast bugs on the live site. So speed came with a safety net.
Why it matters. When a product manager ships the site with AI, you need rules that keep what users see from breaking. We built them into the process itself: checks run automatically, so nobody has to remember them.
What we had to fix along the way. After moving to a new server, the old automatic release still reported success, but changes didn’t reach users — two releases were lost this way. I moved releases to a process with checks, and after every release I look at the changes on the live site. Another time, a repeat request from the same person created a duplicate, and the automation service switched the whole flow off: requests stopped coming in. I found the cause and restored the flow, all queued requests went through, and critical processes got monitoring and duplicate protection after that.
1
Change
An automatic check that no access keys got into the code and that documentation was updated together with the logic.
2
Push
GitHub runs automated tests and a payment check on its own. If anything fails, the code doesn’t go further.
3
Staging
Checked by hand on three screen widths and with test payments.
4
Release
Shipped to our own server in Docker with one command and an automatic check that the site works.
5
Rollback
The previous version is kept, and restoring it is one command.
What it gave the business. A page’s path from brief to release shrank from 5–7 to 2–3 days, and development costs fell 4 times. Since the move not a single release has had to be rolled back, and the team tests more hypotheses per season.
What we set up front and how we delivered it
- 01
Sales don’t stop for a single day. 73 pages moved without stopping sales: a copy of the site ran on the new platform from day one.
- 02
Requests and payments don’t break. Every form and payment method was tested on staging before the switch, and all 93 live automation flows were kept.
- 03
No traffic is lost. Old links from newsletters, ads and search lead to the right pages, and duplicates are hidden from search engines.
- 04
Pages ship faster. Brief to release: 2–3 days instead of 5–7.
- 05
Errors don’t reach users. Automated tests and staging: since the move, not a single release has had to be rolled back.
- 06
Development gets cheaper. Development costs per quarter fell 4 times.
«I recommend Ilya without reservation as someone who will get to the bottom of anything and find the shortest and most effective path to solving a problem, whether it is AI research, coding a page or building a large asset for the company end to end.»