Will you work on something we already have?

Usually, yes — most of this work is somebody else's code. We read it first and tell you what we found, including the parts we would leave alone. If the honest answer is that it should be rebuilt rather than patched, you hear that before you spend anything on patching it.

You do, from the first commit. The repository is on your account and we are a collaborator on it — remove us and nothing stops working.

What happens if we stop working together?

You keep everything and none of it needs us. That is what handing over the accounts and writing the documentation is for, and the documentation is written for whoever picks the thing up next.

Can you work with our own developer?

Yes, and some of the best work is a small change somebody else then maintains. We write to be read by whoever comes next, and that includes the people who are already there.

How long does it take?

It depends on what has to connect to what, and we will not name a date before we have seen it. The scope builder on this site asks the questions we would ask on a call, and answers with the phases and what each of them needs from you.

Developers

Broken, missing, or still done by hand.

That is the whole list of reasons a company calls a developer. We take one of the three, build it, hand over the code and the accounts, and stay afterwards only if you want us to.

Tell us what is broken Work out the scope

Three shapes of work on one line. They start in different places and all three cross the same mark: the day it becomes yours.

What we write: TypeScript on Next.js and Node. Plain CSS on one token file. No page builder, and no theme you are not allowed to open.
Where it lives: Your repository, your domain, your hosting account. We are a collaborator on it, never the owner.
What you keep: The code, the keys and a written handover — on the day it ships, not on request afterwards.

Three ways in

Which one you need is usually obvious after ten minutes of looking at what you already have. All three end in the same place.

It works, and it costs you an hour a day.

Something is done twice, or by hand, or only by the one person who knows how. Too healthy to replace, too big to keep ignoring. It is the most common reason anyone calls us, and it is usually somebody else's code.

We read it before we touch it and tell you what we found — including the parts we would leave alone. Then one change, in your repository, with a note saying what it does and what it does not.

What you get

One change in your own repository, a short note on what it does, and a way to undo it.

How it goes

You show us the thing.
We read what is there and say what we found.
One change, reviewed with you.
It ships, and it is yours.

There is nothing yet, and the deadline is real.

A site, a store, or a connection between two systems that were never meant to meet. It starts from what exists — a spreadsheet, a phone, a folder of photographs — because that is what the new thing has to be better than.

Three languages from the first commit rather than bolted on at the end: adding a second language afterwards is a rewrite of every page and every address on the site.

What you get

The running thing, the repository behind it, every account in your name, and the documentation to change it without us.

How it goes

We agree what is in it and what is not.
We build in the open — you see it working before it is finished.
You check it on your own phone.
It goes live, and the accounts are already yours.

It is live, and it has to stay live.

Something small breaks. A price list changes. A law changes. A browser changes. None of it is a project, and all of it needs somebody who already knows how the thing is built.

This is what the other two turn into when they work. The arrangement carries on past the handover, month by month, and it ends when you decide it should.

What you get

Someone who already knows how it is built, a note on every change, and an arrangement that runs month by month.

How it goes

We agree what is covered.
You write when something is wrong.
We fix it and say what we did.
It continues month by month, and it ends when you say so.

How the work is done

None of this has the name of a methodology. It is what happens on every project, including the site you are reading.

We read the thing before we touch it. The first deliverable is what we found, not a plan.
Nothing ships that the checks refuse: types, the linter, the test suite, a walk over every link, and a comparison of every page's metadata against what is published today.
Three languages from the first commit. Estonian, Russian and English are content, not a plugin.
It has to work with a keyboard, on a phone, and for someone who has turned animation off. That is not a final pass — it is how it is built.
No library where fifteen lines of CSS will do. Every dependency is something somebody has to update later, and that somebody may be you.
The reason is written next to the code, in plain words, so the next person does not have to guess what a line was for.

What it is made of

The list is short on purpose. Every name on it is inside this site too, so what it produces is the page you are reading.

TypeScriptEvery file. A type error is a bug found before a visitor finds it.
Next.js, App RouterPages are rendered to HTML on the server, so a search engine and an old phone both get the finished page.
ReactFor the parts a person operates. Everything else is HTML that needs no JavaScript at all.
CSS on design tokensOne file decides colour, spacing, type and motion. Changing a margin does not start with learning a framework.
NodeThe checks: the tests, the link walk, the metadata comparison, the image work.
PlaywrightA real browser walks the finished site and reports what it actually saw.
Canvas and three.jsThe 2D drawing on this site is written by hand. The 3D figure is three.js, in a chunk of its own, over a still frame that stays if it cannot load.
The Anthropic SDKThe agent that answers on this site. Claude is the model; the rules it works under are ours.
Hosting in StockholmThe nearest region to Tallinn. Where anything travels beyond it — the chat's replies are generated in the United States — is written down in the privacy policy.

What else we work with

Not all of it is inside this site — a payment provider and a database have nothing to do on a studio's own pages. These are the tools a client project gets built with, chosen for the job rather than out of habit.

Next.js
React
TypeScript
Node.js
Tailwind CSS
PostgreSQL
Stripe
Vercel
Anthropic
Playwright
Figma
GitHub

What is yours on the last day

Not on request, and not after a separate conversation about it. It is part of the work, and it is the part most quotes leave out.

The codeEvery commit from the first one, in a repository on your account. We are a collaborator on it. Remove us and nothing stops working.
The accountsDomain, hosting, mail, analytics — the accounts the thing runs on, and the keys that open them.
The documentationHow it is built, how to run it, how to change the text, and what to do when something breaks. Written for the person who will do it — who may not be a developer.

What we actually fixed

KS Rataiksratai.lt

A car service in Kaunas. Seven services, three languages, an enquiry form on every service page, and the technical SEO behind it.

14 August 2026Delivered, then continued as a monthly support arrangement.

Read the case

One entry. Only work that is delivered, dated and still running goes on this list, and this is what that leaves. The rest is on the portfolio page, where each case says what was measured and what was not.

See the rest of the work

Questions

Will you work on something we already have?: Usually, yes — most of this work is somebody else's code. We read it first and tell you what we found, including the parts we would leave alone. If the honest answer is that it should be rebuilt rather than patched, you hear that before you spend anything on patching it.
Who owns the code?: You do, from the first commit. The repository is on your account and we are a collaborator on it — remove us and nothing stops working.
What happens if we stop working together?: You keep everything and none of it needs us. That is what handing over the accounts and writing the documentation is for, and the documentation is written for whoever picks the thing up next.
Can you work with our own developer?: Yes, and some of the best work is a small change somebody else then maintains. We write to be read by whoever comes next, and that includes the people who are already there.
How long does it take?: It depends on what has to connect to what, and we will not name a date before we have seen it. The scope builder on this site asks the questions we would ask on a call, and answers with the phases and what each of them needs from you.

Tell us what is broken. We will tell you what it takes.

Tell us what is broken See the work