Book a consultation

Web agency · Tallinn, Estonia

We make websites.

And the software behind them. We write our own stack in Rust and run it on our own machines, so the site, the shop and the mail come from one place — and so does the answer when something breaks.

What we've built

Three systems, all live.

A property portal, a mail system and a site builder with a shop. Written here, running now, ours to keep running.

Community · Property portal

Kodu

A property portal for all of Estonia, running today at kodu.comm.ee with its first partner's listings — Lumi Kodud's, read off their own site by a feed. The one system here you can licence and run under your own name.

  • One filter row over the list and the map.
  • Addresses checked against the national register as you type.
  • Estonian, Russian, English and Ukrainian.
  • Invoices its users and matches payments off the bank statement.

Communication · Mail, end to end

The mailbox

Mail written, delivered and read by software we wrote. The server, the client and the screen. It ships with every site.

  • A list of people, not subject lines.
  • Tags, files and tasks stay with the message.
  • Reply in the thread, from your own address.
  • A stranger's first message is screened before it lands.

Commerce · Site and shop

A site and a shop

Pick a name and you have an address, a mailbox, a website and a webshop. Nothing to install, nobody to book. The console is where you run it.

  • Pages that change live as you type.
  • Categories, discounts, cart, orders.
  • Visitor numbers counted here, sold to nobody.
  • Every manual carries a Test panel you can press Run on.

Heavy AI integration

An assistant that works the screen, not a chatbot in the corner.

Every product here has the same assistant beside it. It reads what the product holds, it opens the product's own screens next to the conversation, and nothing it writes leaves without the owner's press. The same tools are on MCP for an agent of your own.

kodu.comm.ee/search?deal=rent&areas=tallinn&rooms=2&priceMax=670
The assistant beside the portal, asked for a two-room flat in Tallinn under 670 a month: it counts Lumi Kodud's six and opens that search on the page

«Leia mulle kahetoaline üürikorter Tallinnas, üür alla 670 €» — six, counted, Lumi Kodud's flats as cards beside the words, and the portal's own search open on the page with those filters lit.

mail.comm.ee/?c=140&t=221
The assistant found when and where the party is and opened the conversation it was said in beside itself

«Millal ja kus on Jürgeni sünnipäev?» — found in the thread, named with the message it came from, and that conversation opened beside the chat.

Both pictures were taken on a running system, the assistant answering for real; the address bar names where.

In the products

  • It steers the page: it names a screen and what the screen takes, and the product opens it — a search with the filters lit, a listing, a form filled from the register.
  • It remembers: what a thread said is kept as facts, found by the words, by the sound of them or by what they mean, each naming the message it came from.
  • It asks first: a send, a publish, a delete arrives as a card with one press on it, and the press is the owner's.
  • It runs where you say: a local model on your own machine, Google's over the wire, or one for the chat and the other for the reading — per deployment, per kind of work.

In yours

  • The same assistant over your data: your tables read through the tools your product already has, with the gates your product already keeps.
  • Screens it can open, not text it can paste: the answer is your own page, drawn by your own code.
  • An MCP surface for the agents your customers bring, every write a link their owner confirms.
  • A memory where it earns one — facts out of documents, mail or tickets, screened before anything reads them, embedded on your machine.

Why hire us

Rust, all the way down.

The mail server, the DNS, the HTTP, the portal, the shop and the page you are reading are one Rust workspace. Not because it is fashionable: because a wrong state that does not compile is a bug nobody has to find at three in the morning.

Types do the checking

An address, a money amount, a listing's deal and a mailbox's screen are types, not strings, and a closed set of values is an enum in the database too. No null, no exception, every match exhaustive — a case forgotten is a build that fails, not a customer that does.

Screens checked as they compile

Every screen is written in our own html! macro, and the markup is checked while it compiles: an unclosed tag, a nested <a> or a stray </nav> is a compile error. One set of controls — one field, one button, one gallery — and every product wears the same ones.

One database, normalised

PostgreSQL, one schema, no ORM. Every query is a file, compiled into typed Rust before the server starts, so a column renamed is a build that fails. Enums where the values are closed, indexes where the numbers said so — a search that took 1.8 seconds takes 60 milliseconds now — and migrations in one sequence nobody edits after they have run.

Architecture that stays put

Protocols know no product. Platform knows no application. An application never names another, and a feature — the assistant's memory — names none. A landing page is a tier of its own. Rules like these are written down under stable numbers, and every change cites the one it bends.

html! {
    section(class="ui-gallery", data-testid=section, data-slides=n) {
        for (nth, s) in slides.iter().enumerate() {
            a(class="ui-gal-shot", href=esc(s.src)) {
                img(src=esc(s.src), alt=esc(s.alt),
                    loading=[(nth > 0).then_some("lazy")]);
            }
        }
        if several { emit(arrows(&words, section)) }
    }
}

Maud's shape, none of its magic. A splice is raw unless esc says otherwise, an attribute in brackets is there only when its option is Some, and a tag that does not close does not compile.

Three ways in

Take one. Licence one. Or have one built.

Most of what a company needs, we have already written. The first question is which of these three you are asking for.

Take01

A site and a shop this afternoon

Pick a name. You get an address, a mailbox, a website and a webshop. Nothing to install, nobody to book.

  • Pages that change live as you type.
  • Categories, discounts, cart, orders.
  • Visitor numbers counted here, sold to nobody.
Register a site →

Licence02

A finished system under your name

Kodu is a property portal for a whole country. It exists and it runs. Licensing it costs a fraction of building it again.

  • The whole of it: model, screens, API, tests.
  • Your name, your hostname, your accounts.
  • Hosted here, or handed over.
See Kodu →

Build03

Custom software, kept alive

Hired for the whole thing, not a sprint. From the first call to launch day and every day after.

  • Written in Rust, built to outlive the project.
  • It stays ours to run and answer for.
  • Or your product, on the accounts and mail already here.
Book a free consultation →

How it's built

We host it. We prove it.

Anyone can write software. The question is who keeps it standing, and how anybody else builds on it.

1
script to a running machine

One script turns a clean server into the whole platform. Our machines, our deploy.

65
browser specs

Real Chrome against a real database, reset before every run. A button wired to nothing fails here, not in front of a customer.

2,700
checks underneath

Every model, every route, called with no credential and with somebody else's before it ships.

Run
documentation you can press

Every manual carries a Test panel. Pick an operation, press Run, and the call goes to the live server as you.

REST manual with a test panel open — an operation, its parameters and a Run button
REST. The manual, called: an operation arrives prefilled, Run, and 200 OK.
MCP manual with a test panel open — a tool call and its answer
MCP. The same panel over the tools an agent calls. A write asks first.
Margus Pärt

Who you'd be talking to

The person who writes the code answers the mail.

Gravitational Wave OÜ is a small software company in Estonia. Margus Pärt founded it and writes most of what it ships. The awkward parts — mail, invoicing, the national registers, the shop — are written here rather than bought in. That is why there is one place to ask.

Hire us and Margus is who you talk to. There is no account manager.

reg 12475903margus@comm.ee

07 — CONTACT

Tell us what you're building.

A few lines about the problem is plenty. No brief, no procurement, no discovery phase. The reply comes from the person who would write the code — usually the same day.

Free 30-minute consultation. Pick a day and a rough time and we'll confirm by mail. No obligation, and you talk to the person who would build it.

What you write is stored here and mailed to margus@comm.ee. Nothing else.