Most founders who want a smart contract come to us with an idea already formed: a token, a reward scheme, a membership or an in-game asset. You don't need the technical detail, but knowing a few basic facts early directly affects your budget and timeline. Here are the seven things we'd like a business owner with no blockchain background to know before the first meeting.
1. A smart contract runs exactly as written
A blockchain is a shared ledger kept not on one company's server but on many independent computers at once. A smart contract is a small program that lives on that ledger. Don't let the word “contract” mislead you: it isn't a legal document but a set of rules written in code. It applies rules such as “if this address pays this much, transfer this asset to it” without waiting for anyone's approval.
The key point: the program does what was written, not what you meant. If the code has a gap, the first person to spot it will use it, and the network treats that as a valid transaction. There's no bank or helpline to reverse it.
2. Deployed code can't be patched later
With ordinary software, when a bug appears we fix it and ship a new version. Code written to a chain doesn't change by default. Fixing a faulty contract usually means deploying a new one and moving users, balances and connected apps across, which is costly and damages trust.
There is a remedy: an upgradeable design. Users talk to a fixed address, which passes the work to the real code behind it; when needed, that code is swapped. But if a key can change the code, your users must trust whoever holds it rather than the rules; if it's stolen, an attacker can change the rules too.
A decision for the start
Upgradeability can't be added afterwards; it has to be settled before deployment. We ask: how much value will this contract hold, and will the rules really need to change later? If the answer is “no”, a small, unchangeable contract is usually safer.
3. Testing and audit take longer than writing
A smart contract's code is often surprisingly short. What takes time isn't writing it but making sure those lines behave correctly in every situation. That's why on Web3 projects we spend more time testing than writing. The order usually runs like this:
- 1
Automated tests: For each rule we write tests for both what should happen and what shouldn't; for example, that an unauthorised withdrawal attempt is rejected.
- 2
Testnet trial: The contract is deployed to a test network that resembles the real one but carries no real money; wallet connection and transaction flows are tried end to end.
- 3
Independent audit: Where needed, the code goes to a security team that didn't write it, and the issues found are fixed.
- 4
Staged release: The contract goes to the main network, running at first with low limits and close monitoring.
In an independent audit, outside specialists read the code line by line and report findings by severity. It isn't cheap, can take weeks and doesn't guarantee bug-free code; but a second pair of eyes can catch what the author missed. We recommend it if the contract will hold users' money, carry significant value or be impossible to upgrade. For a small trial carrying no value, thorough tests are usually enough.
4. The network decides fees and audience
“Which blockchain?” looks like a technical preference but is really a business decision. We build on Ethereum and compatible networks, and on TON; we choose together with the client, based on three questions:
- Where are your users? For a product running inside Telegram, TON is a natural option; for an existing Ethereum community, a compatible network makes more sense.
- What does each transaction cost? For small, frequent transactions, a high-fee network makes the product unusable.
- How quickly is a transaction final? In a game, seconds matter; in a transfer made a few times a year, they don't.
Every transaction that changes a record on the chain carries a fee, paid in the network's own currency and varying with how busy the network is. By default whoever starts the transaction pays, meaning your user, who needs a wallet balance beforehand. For users new to crypto, that's a serious barrier. You can arrange to cover the fee yourself, but then it's a running cost. When budgeting, put these fees alongside the development cost.
5. Whoever holds the keys has the say
A contract usually includes special powers: pausing the system, changing a fee rate or upgrading the contract. These are tied not to a username and password but to a private key: a long secret string that proves you own a wallet. Whoever gets hold of it can do everything you can; lose it, and there's no “forgot my password” button to press.
So we don't tie admin rights to a single key; we use a multi-signature wallet: for example, nothing goes through unless at least two of three authorised people approve. A single stolen key then can't put the system at risk. Who holds the keys, and what happens when someone leaves the team, should be in writing before release. After handover these rights should sit with you, not us.
If you don't know who can pause or change your contract, it isn't yours yet.
6. Not everything belongs on the chain
Writing data to a chain is expensive, and the data is public and can't be deleted. So we put on-chain only what everyone must be able to verify: who owns what, whether a payment was made. The following almost always stay off-chain, in an ordinary database:
- Personal data: Names, emails and addresses can't be erased once on a chain, which may conflict with data protection rules.
- Large files: Images and documents are stored off-chain; the chain holds only a short fingerprint proving the file is unchanged.
- Frequently changing content: Product descriptions, campaign copy and other data updated daily.
- Business information that must stay private: Anyone can read every record on the chain.
Most of a good Web3 product is really an ordinary web or mobile app; the contract is its small but critical core. Sometimes the honest answer is that the idea doesn't need a blockchain at all; when so, we say it plainly.
7. The legal side is a separate job
Working code doesn't make what you're doing lawful. Selling tokens, collecting money from users, distributing rewards or chance-based mechanics can fall under financial, consumer, tax and personal data rules in many countries. Those rules differ by country and change over time; a model allowed in one country may need a licence, or be banned, in another.
This article is not legal advice
We build software; we don't give legal counsel, and this article is not legal advice. If your project involves collecting money, selling tokens or distributing rewards, we recommend consulting a lawyer who knows this field before development starts.
Questions to ask a development team
When gathering quotes, ask these questions alongside price and delivery date:
- How, and on which testnet, will you test the contract, and will you share the results?
- Will the contract be upgradeable, and if so, who holds the right to upgrade it?
- Who will hold the admin keys, and will a multi-signature wallet be used?
- Do you recommend an independent audit, and if not, why not?
- Who monitors the contract after release, and what's the first step if something goes wrong?
Used in the right place, a smart contract is a sturdy tool that needs no middleman, but it doesn't forgive mistakes. Keeping the scope small, making time for testing and settling admin rights early all cost less than any later fix.
