Trayd

Companies sign contracts every day, and almost none of it has survived digitisation intact. Agreements are drafted as Word or PDF files, negotiated over email, printed, signed, scanned, and sent back. Small changes cost days. Nobody can say with certainty which version was binding on which date. And a conventional contract is easy to alter after the fact, which is why disputes over what was agreed, and when, are routine rather than exceptional.

Smart contracts solve exactly this. A contract stored on a blockchain executes itself: when a defined condition is met, such as a confirmation from the other party or a date passing, the agreed action follows automatically. It cannot be quietly edited afterwards. But using one has meant knowing Solidity, managing wallets, budgeting gas fees, handling deployments and wiring up oracles. For a freelancer or a twelve-person agency, that is not a realistic entry point.

How a smart contract works

You write the agreement

Pick what is owed and what has to happen for it to be paid.

Amount

Release when

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import {IERC20} from
    "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract Escrow {
    IERC20  public immutable eurc;
    address public immutable freelancer;

    // 10,000 EURC, six decimals
    uint256 public constant AMOUNT = 10_000e6;

    bool public clientApproved;

    function release() external {
        require(clientApproved, "not approved");
        eurc.transfer(freelancer, AMOUNT);
    }
}

hash · changes with the source · 0x6b09df1b…13e5

2
It goes on the chain
Once deployed, the code is fixed. That is the part worth testing.
3
It waits for the condition
Nothing happens until clientApproved is true. It could be five minutes or five months.
4
It executes itself
No approval step, no reminder, no invoice chased. The contract pays out on its own.

Recorded on the blockchain · append-only

Nothing yet. Set the terms above and deploy.

Even the rejected amendment is recorded. Entries are only ever added, never changed or removed, which is what makes the history verifiable rather than merely stored.

Set the terms, deploy them, then try to change the amount. The Solidity above is the real contract, rewritten as you choose: the amount becomes its constant, the condition becomes its state variable and its require. The hash is computed from that source, which is why it moves while the contract is a draft and stops the moment it is on the chain.

What it was

Trayd was a no-code platform covering the whole contract lifecycle: writing, managing, executing. You defined the logic in an editor: tasks, deadlines, payment conditions, parties, approval steps, external triggers from an API. The platform compiled that into modular, auditable smart contracts, built on OpenZeppelin standards and its own contract library.

The Trayd Create view: a contract source panel beside its available actions, a console showing the calls that were run, and a storage panel listing the contract's parties, payment, conditions and deadline. — Create: the contract beside the actions it exposes, the console it answers on, and the state it holds — project, client, amount, conditions, deadline.

Execution ran on a Layer 2 chain such as Polygon or Base, which kept transactions fast and cheap, with deployment through MetaMask or WalletConnect and every transaction visible in an on-chain log. Completed agreements were persisted on GDPR-compliant infrastructure, and every change of state was written as a transaction, so the integrity of a workflow was cryptographically checkable rather than a matter of trust.

Around that sat a dashboard: the status of each contract, automatic reminders before deadlines, cashflow per project, exportable audit logs, and an API into existing ERP and accounting systems.

The Trayd Interact view: a table of deployed contracts with type, status, date, amount and transaction hash, and a details panel for the selected contract showing its full hash, network and block number. — Interact: every deployed contract with its status and transaction hash, and the full on-chain detail of the selected one.

Who it was for

Freelancers, agencies, startups and small and mid-sized companies, the ones that sign contracts constantly and have neither a legal department nor a developer to lean on. Germany alone has over 2.6 million SMEs, and most still run contracts on paper and email.

The existing tools each solve one part. Lawlift generates solid legal documents but stops there, with no execution and no payments. OpenLaw goes deep on the technology but is written for developers. Nothing joins visual contract authoring, automatic execution, payment release and an audit trail in one place.

The bet

The interesting part of Trayd was never the blockchain. It was access. A technology that had sat behind a wall of tooling for a decade would become something an ordinary business could use on an ordinary Tuesday, and trust would stop being a precondition for working together, because the contract itself would enforce it.

The plan, as written in May 2025

Revenue comes from three subscription tiers (€29, €59 and €99 per month, lower when paid annually), each with an allowance of contracts and a per-contract fee beyond it. A white-label tier for agencies and law firms was pencilled in for Q2 2027. The first year was set aside for building the MVP; the plan projected first revenue in Q3 2026, roughly 200 paying customers by the end of the second year, and around €460,000 in the third. Development was mapped across 26 months, with the public launch scheduled for June 2026.

How it ended

Trayd ended in March 2026.

The platform was built together with a blockchain developer who was set to join as CTO. He carried the technical work: the product that existed, existed because he wrote it. When the collaboration broke down, the codebase and the running platform stayed under his control, and I was left with access to none of it: no repository, no infrastructure, no product. There was nothing left to continue from, so I closed the project.

The failure was not technical. There was no written agreement over ownership of the code, no independent access to the repository or the hosting, and no separation between the person doing the work and the asset the company actually consisted of. Every one of those was mine to arrange, and I had arranged none of them. A single point of failure sat at the centre of the company, and I had built no way to survive it.

The irony is not lost on me. I spent a year on a product whose entire premise was that agreements should not depend on trusting the other side — and lost it to an agreement that depended on exactly that.

Trayd was submitted to the StartupTeens business plan competition in May 2025 under the name SmartFlow.