Glossary

A commercial CMS and portal platform widely used in the CIS, valued mainly for its native integration with 1C accounting and its built-in CRM.

The additional cardholder verification step at checkout — a bank confirmation in an app or by code — which also shifts liability for fraud from the merchant to the issuer.

Showing two versions of a page or flow to comparable groups of real users at the same time and keeping the one that performs measurably better.

Designing and building so that people with visual, motor, hearing, or cognitive impairments can use the product: keyboard navigation, screen reader support, sufficient contrast, and clear labels.

The bank-side service that lets a business accept card payments: the acquirer receives the transaction, settles the funds, and carries the risk on the merchant's behalf.

The internal interface your staff work in — managing content, orders, users, and settings — usually the screen the business spends the most hours in.

The tracking and payout layer behind partner marketing: attributing a registered player to the partner who referred them and calculating commission on agreed terms.

An approach to building software in short cycles with frequent feedback, instead of planning everything up front and delivering once at the end. Scope, priorities, and estimates are revisited as the team learns.

A system where a language model does not only answer, but also calls tools — searching a database, creating a ticket, sending a message — in a loop until a task is finished.

An agreed interface that lets one piece of software talk to another — your app to your server, or your product to a third-party service such as payments or maps.

A single entry point in front of your services that handles authentication, routing, rate limits, and logging, so each service does not implement them separately.

Everything between a finished build and an app users can install: developer accounts, store listings, privacy declarations, review, and staged rollout.

A way of structuring an interface library in layers — from the smallest elements up through components to full page templates — so larger pieces are assembled from smaller agreed ones.

An append-only record of who did what and when — logins, permission changes, edits to financial or personal data — kept separately from application logs.

Authentication establishes who the user is; authorization decides what that user is allowed to do. They are separate systems and are routinely confused, which is how data ends up visible to the wrong people.

The server side of a product: business logic, database, authentication, and integrations that users never see but every feature depends on.

The ordered list of everything the team might build: features, fixes, technical work, and ideas. Items at the top are described in detail and ready to start; items further down are deliberately rough.

Regular copies of data and configuration kept somewhere separate, together with a tested procedure for restoring them.

A shared, tamper-resistant ledger maintained by many nodes, where records are added in verified blocks and cannot be quietly rewritten.

The subsystem that defines and executes promotions: welcome offers, deposit matches, free spins, cashback and loyalty levels, together with the wagering conditions attached to each.

The consistent visual and verbal system that makes a company recognisable: logo, colour, typography, imagery, and tone of voice, documented as rules rather than as a single picture.

The role that turns business needs into requirements developers can build from — mapping processes, resolving contradictions between departments, and writing down the rules nobody had written down.

Replacing manual, repetitive steps — copying data between systems, assembling reports, routing requests, issuing documents — with software that performs them on a trigger or a schedule.

Storing the result of an expensive operation so the next request can be answered from memory instead of recomputing it. Caches live in the browser, on a CDN, in the application, and in front of the database.

A content delivery network: a global set of servers that keep copies of your images, scripts, and pages close to users, so a visitor in Warsaw is served from Europe rather than from a single origin server elsewhere.

A payment forcibly reversed by the cardholder's bank after a dispute, taking the money back from the merchant along with a fee, often months after the sale.

An automated conversation in a messenger or on a site that answers questions, takes orders, or collects data — rule-based, model-driven, or a mix.

The share of customers who stop paying or stop using the product in a given period — the leak that every acquisition effort is working against.

Automation that tests every change and delivers it to staging or production, so releases are frequent, repeatable, and low-risk.

The logged-in area where a customer sees their own data — orders, documents, balance, requests — and acts on it without contacting support.

Running a product on infrastructure rented from a provider such as AWS, Google Cloud, or Hetzner, instead of owning servers. Capacity, storage, and managed services are provisioned on demand and billed by usage.

A content management system: the admin interface where non-technical people create and edit pages, posts, products, and media without touching code or waiting for a developer.

An independent review of an existing codebase and its architecture that ends in a written report: what works, what is risky, what it costs to fix, and in which order it should be done.

Who legally owns the result — source code, designs, and documentation — and from what moment: on payment, on delivery, or never, if the contract is silent.

The practice of having every change read by another engineer before it reaches the main branch. The reviewer checks correctness, clarity, security, and whether the change fits the existing architecture.

Software that extracts meaning from images and video — counting objects, spotting defects, reading plates, checking that a photo shows what it claims to.

Packaging an application together with everything it needs to run — runtime, libraries, configuration — into an image that behaves identically on a laptop, in testing, and in production.

The maximum amount of text a model can hold in view at once — the prompt, the retrieved documents, the conversation so far, and the answer it is generating.

Google's set of measurable page experience metrics: how quickly the main content appears, how fast the page responds to the first interaction, and how much the layout shifts while loading.

A company's main site — services, cases, team, contact — built to be found in search and updated by the client's own staff without a developer.

Connecting your site or product to the system where sales work — so a form submission becomes a lead with its source attached, and status changes flow back automatically.

Systematic work on the share of visitors who complete the action that matters — signing up, paying, submitting a brief — using data rather than redesign instinct.

The site working correctly across the browsers and devices your audience actually uses, not only the one it was built on.

Infrastructure that moves value between networks by locking an asset on one chain and issuing a claim on another, since the chains themselves cannot see each other.

Building one codebase that runs on several platforms — typically iOS and Android — to cut cost and time-to-market.

Who holds the private key. Custodial means your service holds it on the user's behalf; non-custodial means the user holds it and your product never can move their funds.

A view of the whole experience from the customer's side — first search, comparison, signup, first use, support, renewal — including the parts that happen outside your product.

A decentralised autonomous organisation: a group whose decisions are made by token-holder voting and executed by smart contracts, with the treasury and the rules held on-chain.

A decentralized application: a frontend that reads from and writes to smart contracts instead of relying on a single company's server.

Moving existing records into a new system with their meaning intact — mapping fields, cleaning duplicates, and reconciling what the old system allowed but the new one does not.

The system that stores a product's data and guarantees it stays consistent. Relational databases such as PostgreSQL organise data into related tables with strict rules; document stores such as MongoDB trade some of those guarantees for flexible structure.

An engagement model where a group of specialists works full-time on your product for an agreed monthly cost, as an extension of your organisation rather than as a vendor delivering a fixed scope.

Decentralized finance: lending, trading, and other financial services run by smart contracts rather than banks or brokers.

The visual design of a screen as it will look — real colours, type, images and content — the stage after wireframes and before development.

A shared library of components, tokens, and rules that keeps a product's interface consistent and speeds up design and development.

Named values for the visual decisions of a product — colours, spacing, type sizes, radii, shadows — stored once and referenced everywhere instead of being written out in each file.

The practice of treating development and operations as one responsibility: the people who write the code also automate how it is built, deployed, monitored, and recovered.

An exchange that runs as smart contracts: trades settle on-chain from the user's own wallet, with no account, no deposit, and no company holding the funds.

A short, focused phase before development where goals, constraints, users, and scope are clarified so the build starts with a shippable plan.

Recording every movement of money as two matching entries — one account debited, another credited — so the books always balance and no amount appears from nowhere.

A site that sells directly: catalogue, cart, checkout, payment, delivery calculation, and the back office where orders and stock are managed.

A way of turning text, images, or audio into numeric vectors where similar meanings end up close together, so a system can find items by sense rather than by exact keyword match.

Converting data into a form that is unreadable without a key. In transit it protects traffic between the user and the server; at rest it protects what is stored in databases, backups, and files.

Connecting a product to the system of record for stock, prices, invoices, and accounting — 1C, SAP, or similar — so numbers match in both places without manual entry.

Holding payment with a neutral third party that releases it when agreed work is accepted, so neither side has to trust the other with the money first.

The process of forecasting how much time and money a piece of work will take. A professional estimate is a range with stated assumptions and risks, not a single confident number.

A repeatable test set for model behaviour: fixed inputs with expected properties, scored automatically so you can tell whether a change made the system better or worse.

The runtime that executes smart contracts on Ethereum and on the many chains that copied it, which is why one contract can deploy to Polygon, Arbitrum, BNB Chain, and Base.

A switch that turns a feature on or off at runtime, for everyone or for a chosen group, without deploying new code.

The browser-based design tool where interfaces are drawn, components are maintained, and prototypes are assembled. Everyone works in the same file simultaneously and comments directly on the design.

Further training an existing model on your own examples so it adopts a specific style, format, or narrow task, rather than being instructed about it in every request.

A contract model where a defined scope is delivered for an agreed total price. Any change to the scope requires a formal change request and a new price.

Google's cross-platform framework that draws its own interface rather than using the system's native controls, producing iOS, Android, web, and desktop builds from one Dart codebase.

An experienced technical leader working part-time — setting architecture and hiring direction, reviewing decisions, representing engineering to investors — without a full-time executive hire.

Everything the user sees and touches in the browser or app — layout, interactions, and the way the interface talks to the backend.

Giving a model a set of described functions it may invoke — look up an order, create a ticket, check stock — so it returns a structured call your code executes instead of inventing an answer.

A single integration that gives an operator access to content from many game studios at once, instead of a separate technical integration per provider.

The payment a user makes to the network for executing a transaction. It depends on how much computation the operation requires and on how busy the network is at that moment.

The European regulation on personal data. It requires a lawful basis for collecting data, limits on what is collected and how long it is kept, and gives people the right to access, correct, and delete their data.

A query language for APIs where the client specifies exactly which fields it needs and receives them in one response, instead of calling several REST endpoints and discarding the surplus.

The checks around a model that constrain what it may be asked and what it may return — input filtering, output validation, refusal rules, and limits on which actions it can trigger.

A confident, fluent, and factually wrong answer from a language model. The model is predicting plausible text, so a fabricated price, clause, or citation looks exactly like a correct one.

The transfer of a product to another team or to your own staff: source code, infrastructure, accounts, documentation, and the knowledge needed to run and change it without the original authors.

A content management system that stores and edits content but has no front end of its own: it delivers content through an API to a website, a mobile app, or any other channel.

A structured expert review of an interface against established usability principles — visibility of status, error prevention, consistency — rather than against personal taste.

Where the site runs and the address it answers on — plus the DNS, certificates, and mail records that make both work together.

Turning a design into working pages in the browser — semantic structure, styling, and behaviour across screen sizes.

The property that repeating the same request produces the same result as doing it once — a retried payment charges the card once, not twice.

How content and functions are organised, labelled, and connected: the navigation, the grouping of sections, and the vocabulary used throughout the product.

Defining servers, databases, and networking in version-controlled files, so environments are created by running the code rather than by clicking through a console.

Connecting your product to an external system — CRM, ERP, accounting, payments, delivery, marketplaces — so data moves between them automatically instead of being re-entered by hand.

Building a product so it can be adapted to other languages and regions — text separated from code, plus correct handling of dates, numbers, currency, and text direction.

A flow-based way of working where tasks move across a board of stages and the team limits how many items can be in progress at once, instead of committing to a fixed scope per sprint.

An orchestrator that runs containers across a cluster — placing them, restarting what dies, scaling with load, and routing traffic to healthy instances.

Know Your Customer and Anti-Money Laundering: the mandatory checks that verify who a user is and screen their activity against sanctions lists and suspicious patterns before and during service.

A single page built around one action — book a demo, leave a request, buy — with no navigation competing for the visitor's attention.

A network built on top of a base blockchain that processes transactions separately and periodically writes a compressed proof back to the main chain, inheriting its security at a fraction of the cost.

Working code that the current team is afraid to touch: the original authors have left, tests are missing or not trusted, and nobody is certain what depends on what.

Bringing an old but working system up to date — replacing it piece by piece, or rebuilding it — without stopping the business that depends on it daily.

A smart contract holding reserves of two or more assets that traders swap against, with the price set by a formula over the balances rather than by an order book.

An AI model trained on large text corpora that can understand and generate language — the engine behind assistants and content tools.

Simulating many simultaneous users to find out how a system behaves under expected and peak traffic: where response times degrade, what breaks first, and at what point it stops recovering.

Ongoing work after launch: security updates, dependency upgrades, hosting and monitoring, fixing what breaks, and small changes as the business shifts.

A product where independent sellers and buyers transact, and the operator provides the rules, trust, payouts, and dispute handling rather than the goods.

An open protocol for connecting AI assistants to tools and data sources through one standard interface, instead of a bespoke integration per model and per app.

A buffer between parts of a system: one service posts a job, another picks it up when ready, so slow or failing work does not block the request that triggered it.

The small responses an interface gives to a single action — a button settling, a field validating as you type, a list animating to show what just changed.

An architecture where a system is split into small independent services, each owning its data and deployed separately. Services communicate over the network through APIs or message queues.

Splitting a project into stages with a defined deliverable, a review, and a payment attached to each, instead of one handover at the end.

The instrumentation that shows what a running system is doing: metrics, logs, error tracking, and alerts that notify the team when something degrades, ideally before users notice.

An architecture where the whole backend is one deployable application. Modules call each other directly in the same process rather than over the network.

The deliberate use of animation in an interface: transitions between states, feedback on actions, loading behaviour, and the timing and easing that make them feel intentional.

An architecture where one deployment serves many customer organisations, with their data strictly isolated from each other. The alternative is a separate installation per client.

A wallet that requires several independent signatures before a transaction executes — typically three of five keyholders, each on separate hardware.

The smallest version of a product that delivers real value and lets you test the idea with real users before investing in the full build.

A mobile application written with the platform's own tools — Swift for iOS, Kotlin for Android — and compiled specifically for that system, with direct access to every device capability.

A mutual agreement that neither side discloses the other's confidential information — your idea, data, and commercial terms, and the vendor's methods and rates.

Working with a development team in a nearby country — similar time zone, overlapping working day, a short flight away — rather than offshore across a twelve-hour gap.

A non-fungible token: a unique on-chain record of ownership of a specific item, which may be an image, a ticket, a certificate, a game asset, or a membership.

Building software through visual tools and configuration instead of writing code — site builders, automation platforms, internal-tool generators.

The single number a team agrees best represents delivered value — weekly active teams, completed bookings, documents signed — and against which roadmap decisions are judged.

Being able to answer why a system behaved as it did from the data it already emits — logs, metrics, and traces tied together by a request id.

Turning scans, photos, and PDFs into structured data — reading an invoice or passport and returning the fields rather than a wall of text.

Designing an app so that it works without a connection: data is stored on the device, actions are queued, and everything synchronises when the network returns.

The division between data and logic that live in the blockchain, where they are public, permanent, and expensive, and everything kept in ordinary systems, where it is cheap, fast, and changeable.

Regulated APIs that let a licensed third party read a customer's bank data or initiate a payment, with the customer's explicit consent.

A service that delivers outside data — prices, match results, interest rates — onto the chain, because a smart contract cannot read anything beyond its own network on its own.

Delegating a whole piece of work — a product, a module, a redesign — to an external team that owns the delivery process and hands back a result. Unlike outstaffing, you buy an outcome rather than people.

Hiring specialists from a vendor who work inside your team and processes, while the vendor handles contracts, payroll, and HR.

The service that connects your product to card networks and banks: it collects card details securely, authorises the charge, and reports the result back to your system.

The security standard that applies to anyone who handles payment card data. Its requirements cover storage, transmission, access control, logging, and regular testing.

A controlled attack on your own system by specialists who attempt to break in the way a real attacker would, ending in a report of exploitable weaknesses ranked by impact.

The internal account that holds a player's balance: deposits, withdrawals, bets, winnings, and bonus funds kept separately, with every movement recorded as an immutable ledger entry.

Collecting and interpreting data about how people actually use a product: which steps they complete, where they drop out, which features are ignored, and what differs between the users who stay and those who leave.

The point where a product solves a real problem well enough that people keep using it and tell others — growth starts pulling instead of being pushed.

A website that behaves like an installed application: it can be added to the home screen, launched without browser chrome, work offline for cached content, and receive push notifications.

The person accountable for scope, schedule, and communication — keeping the plan honest, flagging risks early, and being the client's single point of contact.

Designing the instructions given to a language model — role, task, constraints, output format, examples — so that it produces a usable result consistently rather than occasionally.

A small, throwaway build whose only purpose is to answer one technical question: can this integration work, will this model be accurate enough, will this load be handled. It is not a product and is not meant to ship.

A clickable model of the product used to validate flows and ideas with users before engineering time is spent.

Messages delivered to a device even when the app is closed, through Apple's and Google's notification services. They can be broadcast to everyone or triggered by a specific event for one user.

Planned testing — manual and automated — that catches defects and regressions before users do.

A technique where a language model is given relevant excerpts from your own documents at the moment of answering, instead of relying only on what it learned during training.

Capping how many requests a client may make in a window, and returning a clear refusal rather than letting the system degrade for everyone.

Granting permissions to roles rather than to individuals, so access follows a person's job and changes when the job does.

A framework for building native-feeling iOS and Android apps from a single JavaScript/TypeScript codebase.

Reworking an existing product's interface — sometimes only the visual layer, sometimes the structure and flows underneath it.

An exploit where a contract calls out to another address, and that address calls straight back in before the first call has updated its balances — repeating the withdrawal against stale state.

Changing the internal structure of code without changing what it does from the outside. The behaviour stays identical; the code becomes easier to understand, test, and extend.

Building one interface that adapts its layout to any screen width, from a phone to a wide monitor, instead of maintaining separate mobile and desktop versions.

The most widespread style of web API, where data is exposed as addressable resources and manipulated with standard HTTP methods — GET to read, POST to create, PUT or PATCH to update, DELETE to remove.

A document a company sends to several vendors describing what it needs, so proposals and prices can be compared on the same basis.

Independent testing that a game's random number generator is genuinely unpredictable and statistically fair, carried out by an accredited lab such as GLI or eCOGRA.

An ordered plan of what gets built and when, grouped into releases, so the team and stakeholders share one picture of the product's direction.

What the product returns against what it cost — revenue gained, hours saved, errors avoided — measured against a baseline recorded before the work started.

The endpoint your application talks to in order to read chain state and broadcast transactions — either a node you run or a hosted provider such as Alchemy or Infura.

The share of total stakes a game returns to players over a very long run — a 96% slot pays back 96 units per 100 staked across millions of spins, not per session.

Software as a Service: a product delivered over the web on a subscription, with the vendor handling hosting, updates, and uptime.

A system's ability to handle growth in users, data, or features without a rewrite or a drop in speed and reliability.

The gradual growth of a project beyond what was agreed, through small additions that each look harmless. No single request causes the overrun; their sum does.

A specific Agile framework with fixed-length sprints, defined roles (product owner, development team, scrum master), and a set of recurring meetings: planning, daily standup, review, and retrospective.

Search that matches on meaning rather than characters, so a query for "cancel my order" finds a page titled "Returns and refunds" with no shared keywords.

Search engine optimisation: the technical and content work that makes a site findable for the queries your customers actually type. It covers crawlability, speed, structure, metadata, and the quality of the pages themselves.

Generating the HTML of a page on the server for each request, so the browser receives a complete document instead of an empty shell that has to fetch and assemble content with JavaScript.

A hosting model where you deploy individual functions or containers and the cloud provider runs them on demand, scaling to zero when idle. You pay per execution rather than for a server that runs all month.

A web application that loads once and then redraws the interface in the browser as the user navigates, instead of requesting a new page from the server on every click.

A service level agreement fixes the availability and response commitments: how much downtime is acceptable, how fast an incident is acknowledged, and how fast each severity level must be resolved.

Code stored on a blockchain that executes agreed rules automatically when conditions are met, with no intermediary.

A systematic security review of contract code by specialists, combining manual analysis with automated tooling, ending in a report of findings by severity and a re-check after fixes.

The dominant language for EVM smart contracts — statically typed, compiled to bytecode, and deployed to an address where the code is public and, by default, permanent.

The software behind sports betting: live odds feeds, event and market trees, bet slips, risk limits, settlement after results, and the back office that operators use to manage all of it.

A fixed, short iteration — usually one or two weeks — that ends with working software and a demo, keeping progress visible.

The certificate that encrypts traffic between browser and server and turns the address bar from a warning into a padlock.

Letting users authenticate through one corporate identity provider — Google Workspace, Microsoft Entra, Okta — instead of holding a separate password in your product.

A token designed to hold a steady value, usually one unit of a currency such as the dollar. It is backed either by reserves held off-chain or by collateral locked in contracts.

Adding external engineers directly into your existing team and process, under your technical management, rather than handing a scope to a vendor to deliver separately.

A full copy of the production setup, running the next release with test data, where changes are checked before real users see them. Larger projects also use preview environments for individual features.

Locking tokens in a protocol for a period in exchange for rewards. In proof-of-stake networks it secures the chain; in applications it is also used for access tiers and governance weight.

Building every page into a ready HTML file at deploy time, so requests are served as files from a CDN with no application server involved in the response.

What a product costs over its life, not just to build: hosting, third-party services, support, updates, and the engineering time to keep it current.

The senior engineer responsible for technical decisions on a project — architecture, stack, code quality, and the trade-offs between speed and durability.

The set of languages, frameworks, databases, and services a product is built on. The choice determines development speed, hiring options, hosting cost, and how long the product stays maintainable.

Shortcuts in code or architecture that speed up delivery today but make every later change slower and riskier until they are paid back.

An independent assessment of a product's code, architecture, team, and operations — usually before an investment, acquisition, or a decision to take over development.

The document that fixes what will be built: screens, roles, integrations, acceptance criteria, and explicitly what is out of scope.

A web application that runs inside Telegram, with access to the user's account, payments, and the chat it was opened from — no install, no store review.

Mainnet is the live blockchain where transactions involve real value. A testnet is a parallel network with worthless tokens, used to deploy and test contracts under realistic conditions before release.

The moment a project's token is minted and distributed — to investors, team, treasury, and the public — usually alongside the first listing and the start of vesting.

A hosted website builder for landings and simple sites, where pages are assembled from ready blocks without development.

A contract model where you pay for the hours actually worked at agreed rates, rather than for a fixed scope at a fixed price. Priorities can change between sprints without renegotiating the contract.

A unit of value or rights issued on a blockchain. Fungible tokens are interchangeable like currency; non-fungible ones are unique. Most are created from standard contracts such as ERC-20 or ERC-721.

Agreed contract interfaces that make a token readable by any wallet, explorer, or exchange: ERC-20 for interchangeable units, ERC-721 for unique items, ERC-1155 for both at once.

The economic design of a token: total supply, how new units are issued, who holds what at launch, vesting schedules, and what the token actually buys or unlocks inside the product.

A vendor takes the product from idea to working, deployed system — design, development, testing, launch, and handover — so the client receives something ready to use rather than parts to assemble.

Requiring a second proof of identity in addition to a password: a code from an authenticator app, a hardware key, or a one-time code sent to the user. SMS is the weakest of these options.

What one customer costs to acquire and serve against what they pay over their lifetime — the arithmetic that decides whether growth makes you money or loses it faster.

Watching representative users attempt real tasks in the product or prototype, without hints, and recording where they hesitate, misread, or fail.

The sequence of screens and decisions a person passes through to complete one task: signing up, placing an order, submitting a claim. It is drawn as a map before any screen is designed in detail.

Interviews, usability tests, and analysis that show how real people use a product, so design decisions rest on evidence, not opinion.

A store built for embeddings: instead of matching exact values, it finds the records whose meaning sits closest to a query in high-dimensional space.

Depending on one provider or technology so deeply that leaving means rebuilding — proprietary services, exported data in a format nobody else reads, or a platform only one agency can maintain.

A system that records every change to the codebase with its author, time, and reason, lets several people work in parallel on separate branches, and makes it possible to return to any previous state.

Building software by describing what you want to an AI assistant and accepting what it produces, without reading most of the resulting code. It reaches a working prototype remarkably fast and leaves a codebase nobody on the team can fully explain.

Connecting a product to users' crypto wallets so they can sign in, sign transactions, and hold assets without custody by the app.

An agreed window after launch during which the vendor fixes defects in delivered functionality at no additional cost.

An approach to the internet built on blockchains, wallets, and tokens, where users own their identity and assets.

A reverse API call: instead of your system asking a service for updates, the service sends an HTTP request to your endpoint the moment something happens — a payment succeeds, a document is signed, an order ships.

A structured review of an existing site — speed, search visibility, accessibility, code quality, security — ending in a prioritised list of what to fix and what it is worth.

A persistent two-way connection between browser and server, so updates arrive the moment they happen instead of waiting for the next request.

One product deployed under several brands, where each client gets their own domain, logo, colours, and sometimes feature set, over a shared codebase.

A low-fidelity layout of a screen that fixes structure and content priority before any visual design is applied.

The most widely used CMS, strong for content sites and blogs, extended through a very large plugin ecosystem.

A cryptographic proof that a statement is true — this user is over 18, this batch of transactions is valid — without revealing the data behind it.