Based in Kyiv

©2026

The Fifty-Line Generator Behind Every Arche Site

A small brass gear mechanism resting on dark velvet

Three years ago we ripped out Gatsby from every project in our pipeline and replaced it with a script short enough to read over coffee. Here is what changed, what broke, and why we have not looked back since.

In the spring of 2021 our build times had crept up to eleven minutes for a six-page brochure site. Eleven minutes to change a headline. We were running Gatsby because everyone else was, because it looked serious on a proposal, because the plugin ecosystem promised to solve problems we did not actually have. Oleh Dmytrenko, who handles most of our frontend tooling, finally asked the question nobody wanted to answer out loud: what are we actually using any of this for?

Why We Stopped Reaching for Gatsby

The honest answer was almost nothing. Our client sites are mostly static. A bakery’s menu page, a dentist’s booking form, a hotel’s gallery. None of it needed GraphQL stitched between a CMS and a React tree. We were paying a complexity tax for features we never touched, and the tax came due every time a junior developer joined and had to learn the stack before they could fix a typo.

The November Build That Took 11 Minutes

The breaking point was a job for Hotel Dnister in Lviv. A single price change on the room rates page triggered a full rebuild, image reprocessing included, and the client was on the phone waiting. Eleven minutes felt like an hour. We shipped the fix, closed the laptop, and started sketching an alternative that weekend.

An espresso cup with steam next to a closed laptop
Fifty lines, short enough to read over coffee.

What Fifty Lines Actually Do

What we ended up with is a Python script, currently forty-seven lines in its core form, that reads Markdown files with YAML front matter, runs them through Jinja2 templates, and writes plain HTML to a folder. No virtual DOM, no hydration, no client-side router. It builds a typical five-page site in under four hundred milliseconds.

Templates, Not Components

We write templates the way we used to write components, but without the overhead of a framework deciding when things re-render. A template is a file. It includes other files. Data comes from front matter or a small JSON file sitting next to the content. There is no abstraction layer between us and the output, which means when something looks wrong in the browser, it is almost always wrong in the template, not buried three dependencies deep.

Blackouts Changed Our Priorities

This decision started as a performance argument, but it became a resilience argument once the power schedule took over daily life in Kyiv. A build process that depends on five hundred node modules and a stable internet connection is a liability when you have ninety minutes of electricity and a battery pack at forty percent. Our generator runs offline. It has no install step beyond Python itself, which ships on most machines already.

Building Offline, Shipping Fast

Yevgenia Marchuk, who does most of our client-facing development now, keeps a copy of the generator on a USB drive. During a blackout last December she built and deployed a fix for Kooperativa, the bakery chain we work with, from a cafe with a generator and spotty wifi, in under two minutes total. That would not have been possible with a framework that wanted to reinstall its dependency tree first.

We are not trying to prove a point about minimalism. We are trying to make sure a power cut does not become a missed deadline.

The Cost of Owning Your Tools

None of this is free. When you write your own build tool, you also own every bug in it. There is no Stack Overflow thread for a problem only your studio has. We have a recurring Sunday slot, half-jokingly called Maintenance Sundays, where whoever is free spends an hour patching the generator, writing a missing feature, or just reading through the code to remember how it works.

What We Lost Along the Way

We lost some conveniences. Hot module reloading, for one. Our workaround is a file watcher that rebuilds on save and a browser extension that refreshes the tab, which is less elegant but does the job in about two hundred milliseconds. We also lost the ability to hire someone who already knows our exact stack, since nobody has used our exact stack before they joined us. Onboarding now includes an afternoon reading the generator’s source.

What We’d Tell a Studio Thinking About This

We get asked about this setup often enough that we have a standard answer, which usually comes with caveats about team size and client type. It is not a universal recommendation. But for a studio our size, doing the kind of work we do, it has paid for itself many times over.

  • Measure your actual build times before blaming the framework, sometimes the bottleneck is images, not JavaScript
  • Write the smallest tool that solves today’s problem, not next year’s hypothetical one
  • Budget real maintenance time for homemade tools, treat it as a cost of ownership, not an afterthought
  • Keep a offline-capable fallback for anything client-facing, infrastructure assumptions break under local conditions you cannot control

Three Years Later

The generator has grown since that first weekend, mostly in small ways. It now handles image resizing through a single Pillow call, supports a basic sitemap generator, and has a plugin system that is really just a folder of optional Python files. It has never crashed a deploy. It has never needed a security patch at midnight because a dependency three levels down got compromised.

We still get proposals rejected because a client’s IT department wants to see “a real framework” on the spec sheet. That happens maybe twice a year. We have made peace with losing those jobs in exchange for keeping every other one running smoothly, blackout or not.

Leave a Reply

Your email address will not be published. Required fields are marked *

Recent posts