✕

Operations, management and continuity

Infrastructure

The business stays yours. The machinery under it is ours to run.

Systems builds the ground and secures it. Infrastructure takes the controls: we set it up, we keep it running day after day, and we are the ones awake when something moves. A trading floor, a company, or one person with an online shop — the same hands and the same watch.

You are reading a house we run ourselves. It was already watching when you arrived — ·

What you stop carrying

Six things that leave your hands on the first day and do not come back.

The machines

Where it runs, how large, and what that should cost. We choose it, we set it up, and we resize it when your traffic changes — before it becomes a problem you can see.

The address

Domain, certificates, and mail that arrives instead of landing in a spam folder. Renewed before you remember it exists, because an expired name is a closed business.

The shop

Checkout, payment methods, country by country, and the order that must never be lost. Built once, then kept working — including on the day your supplier changes something.

The copies

Backups you never have to think about, and a restore we have actually performed. A copy nobody has ever brought back is not a copy — it is a hope.

The speed

Pages that open quickly wherever the visitor is standing. Slow is money walking out, so speed is part of running the house, not an extra line to buy.

The patching

Updates, certificates about to lapse, the component with a hole in it. Closed by us, on our calendar — not on your worry, and not at three in the morning on yours.

Who is watching, and when

What actually happens between the moment something breaks and the moment it is standing again.

The moment it happens

The system notices

Every request, every door and every key is filed at the edge as it happens. Nothing waits for a nightly job to discover it in the morning.

In the same breath

A phone rings in Zürich

Not a mailbox, not a dashboard somebody may open tomorrow. The alert goes where it cannot be quietly ignored.

Before you ask

You hear it from us

What happened, what it touched, and what has already been done about it. You do not learn that your house is down from your own customers.

Until it is standing

It gets repaired, not escalated

The same hands that set it up go in and fix it. There is no tier above us to pass it to, so there is nobody for us to wait for.

At the end of the month

It is written down

What failed, why, and what we changed so that it cannot fail the same way twice. A fault that is not written down comes back.

What arrives in writing, every month

One sheet. Readable by someone who is not an engineer, because that is who it is for.

Hours standing
The hours it was up, and the minutes it was not — measured from outside your house, so the figure is not ours to flatter.
What we changed
Every change we made, in plain language. You can read it in a minute and still know exactly what moved.
What broke
What failed, what it touched, and what we did — including the faults you never noticed, which are most of them.
What comes next
What we intend to do next month, written before we do it. Nothing happens to your house as a surprise.
What it costs
The same figure as last month, unless you asked for something new. No line ever appears on this sheet on its own.

The interface

What we hand you is the half that runs in your house: the drill that tests your own copies every night, and the single call that puts a house under management. Our operations room stays closed — what runs on your side is yours to read before you trust it.

"""MatchTop · restore drill — the piece that proves a copy is a copy.
Standard library only. It runs in your house, on your own copies, where you can watch it."""

import hashlib, hmac, json, os, subprocess, time
from pathlib import Path
from urllib.request import Request, urlopen

KEY    = bytes.fromhex(os.environ["MT_KEY"])    # one key per house, never on disk
EDGE   = os.environ["MT_EDGE"]                   # no address baked into the build
SHADOW = Path(os.environ["MT_SHADOW"])            # a shadow copy. never the live house.


def newest_copy(vault: Path) -> Path:
    """Drill the copy you would actually reach for, not a convenient one."""
    copies = sorted(vault.glob("*.dump"), key=lambda p: p.stat().st_mtime)
    if not copies:
        raise FileNotFoundError("the vault is empty")   # the loudest fault there is
    return copies[-1]


def fingerprint(copy: Path) -> str:
    """So that tomorrow we can prove this was the file we brought back."""
    h = hashlib.sha256()
    with copy.open("rb") as f:
        for block in iter(lambda: f.read(1 << 20), b""):
            h.update(block)
    return h.hexdigest()


def bring_it_back(copy: Path) -> dict:
    """Restore into the shadow, then ask it a question only a live house can answer."""
    SHADOW.mkdir(parents=True, exist_ok=True)
    started = time.monotonic()
    subprocess.run(["pg_restore", "--clean", "-d", "mt_shadow", str(copy)],
                   check=True, timeout=1800)
    asked = subprocess.run(["psql", "-d", "mt_shadow", "-tAc",
                            "select count(*) from orders"],
                           capture_output=True, text=True, check=True)
    return {"seconds": round(time.monotonic() - started, 1),
            "orders":  int(asked.stdout.strip())}   # a restore nobody queried is not a restore


def file_it(result: dict) -> str:
    """Signed and filed, pass or fail. The month's sheet is written from these."""
    body = json.dumps(result, separators=(",", ":"), sort_keys=True).encode()
    call = Request(EDGE, body, {
        "Content-Type": "application/json",
        "X-MT-House":   os.environ["MT_HOUSE"],
        "X-MT-Seal":    hmac.new(KEY, body, hashlib.sha256).hexdigest(),
    })
    with urlopen(call, timeout=8) as answer:        # we dial out. nothing dials in.
        return json.load(answer)["filed"]


def drill(vault: Path) -> None:
    copy   = newest_copy(vault)
    result = {"copy":        copy.name,
              "age_hours":   round((time.time() - copy.stat().st_mtime) / 3600, 1),
              "fingerprint": fingerprint(copy)[:16]}
    try:
        result |= bring_it_back(copy)
        result["verdict"] = "came back"
    except Exception as fault:
        result["verdict"] = "did not come back"      # the drill exists for this branch
        result["fault"]   = str(fault)[:200]           # and this is the night we are worth it
    file_it(result)


if __name__ == "__main__":
    drill(Path(os.environ["MT_VAULT"]))               # every night, watched or not

Measured on our own house

No client figures on this page. We quote nothing we have not measured ourselves, so these four are from the houses we run with our own hands.

2
houses we run
this one and a clinic's — we are our own first client, and our own first complaint
7
doors on this one
one per language, all of them under a single watch and a single bill
0
consoles to learn
nothing for you to log into and nothing to remember — you ask, and it is done
1
person answers
no tier, no ticket, and nobody standing in front of him taking notes

What cannot be copied

Not a comparison of prices. A comparison of how the two houses are built.

The usual arrangement
Here
Who answers
A duty roster you never meet. Whoever picks up has to be told what your system is before he can help.
The person who set it up. He already knows your system by hand, so there is nothing to explain first.
Office hours
A fault at 23:40 is a ticket read at 09:00. The night belongs to you, alone.
The watch keeps no office hours. The alert goes to a phone, and the phone is not switched off.
Each year
Another seat, another module, another tier. The arrangement can only grow heavier.
We take out what you stopped needing. The operation gets lighter — and so does what it costs you.
When it breaks
They tell you that it broke. Repairing it is quoted separately, by somebody else.
We built the engine too, so we go in and repair it. One house answers for both halves.
The day you leave
Their console, their formats, their exit fee. Walking away costs a whole project.
Your account, your domain, your data. We hold the keys we were handed, and we hand them back the day you ask.

None of that is a list of features, and that is exactly why it cannot be out-bid. A firm with a duty roster cannot give you the person who built your system. A firm whose invoice must grow every year cannot take a line out of it. A firm that only watches cannot repair. They are not behind us — they are built differently, and they cannot cross over without ceasing to be themselves.

It is also why there is no price list on this page. We look at what must not stop, we measure the operation, and then we quote what we measured. Each pays to their own size — a shop run by one person is not charged as though it were a trading floor.

Tell us what you would rather hand over

Two lines are enough. We read them ourselves and we answer ourselves — there is no queue standing behind this window.

It reaches one person, and that person answers. Nothing here is shared, sold or passed on.

Mr. MatchTop · matchtopalgorithm.ai