Glossary

All terms

• AI agent

  An AI agent is a language model placed in a loop where it can decide what to do next, call tools to do it, observe the result and continue until a goal is reached. The distinguishing feature is that the sequence of steps is chosen by the model, not fixed by the developer.

• AI app builder

  An AI app builder is a tool that turns a description in plain language into a working application, generating the interface and the code rather than assembling it from visual components. You then refine the result by asking for changes in the same way.

• Answer engine optimization (AEO)

  Answer engine optimization is the practice of making a page suitable to be quoted as the answer to a question, rather than merely ranked as a link. It targets AI assistants, featured snippets and voice results, where the user gets a response instead of a list.

• Authentication

  Authentication is the process of establishing who a user is — verifying a password, a code, a passkey or a token from another identity provider. It answers the question of identity only. What that identity is then allowed to do is authorisation, which is a separate decision.

• Bring your own key (BYOK)

  Bring your own key means an application calls a hosted model with an API key the user supplies, instead of with the vendor’s metered key. The user pays Anthropic, OpenAI or similar directly. The application still proxies the request; it does not become a local model.

• CDN (content delivery network)

  A CDN is a network of servers spread across many locations that store copies of a site's files and serve each visitor from a nearby one. It cuts the physical distance a request travels, which is the part of page speed that no amount of code optimisation can fix.

• CNAME record

  A CNAME record is a DNS entry that makes one hostname an alias for another, so that app.example.com resolves to whatever your hosting provider's address currently resolves to. It points at a name rather than an IP address, which is why the provider can change servers without you touching your DNS.

• Context window

  The context window is the maximum number of tokens a model can have in front of it at one time, covering the system prompt, the conversation so far, any attached documents and the answer being generated. Nothing outside it exists for the model.

• Core Web Vitals

  Core Web Vitals are three metrics Google uses to measure the experience of loading and using a page: Largest Contentful Paint for loading speed, Interaction to Next Paint for responsiveness, and Cumulative Layout Shift for visual stability. They are scored from real visitors, not from a lab test.

• CRUD

  CRUD stands for create, read, update and delete — the four operations that cover almost everything an application does with stored data. The term is used as shorthand for the basic data layer of an app: if users can add records, see them, change them and remove them, you have built CRUD.

• Data controller

  A data controller is the organisation or person that decides why and how personal data is processed. Under GDPR the controller carries the primary legal responsibility: choosing a legal basis, informing individuals, answering their requests and reporting breaches, even when the actual processing is done by someone else.

• Data processor

  A data processor is an organisation that processes personal data on behalf of a controller and only on that controller's documented instructions. Hosting providers, database services and email tools are typical processors: they hold the data but do not decide why it was collected or what it is used for.

• Fine-tuning

  Fine-tuning means continuing to train an existing model on your own examples so that its weights shift toward the behaviour you want. Unlike prompting, the change is baked into the model and applies to every call without being restated.

• GDPR

  GDPR is the EU regulation that governs how personal data about identifiable people may be collected, stored and used. It applies to any organisation processing data about people in the EU, regardless of where the organisation is based, and it requires a documented legal basis for every processing activity.

• Generative engine optimization (GEO)

  Generative engine optimization is the practice of increasing the chance that AI systems which write answers — ChatGPT, Perplexity, Google’s AI results, Copilot — draw on your content and name you as a source. There is no ranking position to win, only inclusion in a generated response.

• Hallucination

  A hallucination is output from a language model that is fluent, confident and wrong: an invented citation, a function that does not exist in the library, a plausible date for an event that never happened. It is a normal mode of operation, not an error state.

• Hydration

  Hydration is the step where JavaScript takes over HTML that was rendered ahead of time on a server or at build, attaching event handlers and internal state to the existing markup so the page becomes interactive without being redrawn from scratch.

• Inference

  Inference is the act of running an already-trained model to get an answer, as opposed to training, which produces the model in the first place. Every prompt you send is one inference request, and it is where essentially all of the ongoing cost of using AI sits.

• Large language model (LLM)

  A large language model is a neural network trained on very large amounts of text to predict the next piece of text given what came before. Everything it does — answering, translating, writing code, summarising — is that one operation applied repeatedly.

• llms.txt

  llms.txt is a proposed convention for a markdown file at the root of a website that lists its most important pages with short descriptions, so a language model can find the relevant material without parsing navigation, scripts and layout. It was proposed by Jeremy Howard in 2024.

• Local AI

  Local AI means running a model on the same machine that uses it — your laptop, your phone or your own server — instead of calling a provider over the internet. The prompt and the output stay on the device, and there is no per-request cost.

• Low-code

  Low-code describes platforms where most of an application is assembled visually or through configuration, but where you can drop into real code for the parts that need it. The code is the escape hatch rather than the primary building material.

• MVP (minimum viable product)

  A minimum viable product is the smallest thing you can build that produces real evidence about whether people want what you are proposing. Its purpose is to answer a question you are genuinely uncertain about, not to be a first version of the finished product.

• No-code

  No-code describes tools that let you build working software through a visual interface — dragging components, configuring fields, connecting steps — without writing source code. The platform generates and runs the underlying application for you.

• Offline-first

  Offline-first is a design approach where an app treats the network as an optional extra rather than a requirement. The interface renders from locally stored data first and synchronises when a connection exists, so losing signal degrades one feature at a time instead of blanking the whole app.

• Ollama

  Ollama is an open-source tool that runs language models on your own computer and exposes them over a local HTTP API. It handles downloading, quantized model files and GPU setup, so using a local model becomes one command instead of a build process.

• PostgreSQL

  PostgreSQL is an open-source relational database that stores data in tables with defined columns and enforces relationships and constraints between them. It is queried with SQL, it guarantees transactions, and it has become the default choice for new applications that need data to stay correct.

• Prerendering

  Prerendering is the practice of running a JavaScript app once at build time and saving the resulting HTML for each route as a real file, so that crawlers, AI fetchers and first-time visitors receive finished markup instead of an empty container that only fills in after scripts execute.

• Progressive Web App (PWA)

  A Progressive Web App is a website that behaves like an installed app: it can be added to the home screen, opens in its own window without a browser address bar, and can keep working without a connection if it ships a service worker. It is distributed by URL, not through an app store.

• Prompt engineering

  Prompt engineering is the practice of structuring what you send a model so that it reliably produces what you need — the instruction, the context, the examples and the required output format. It is closer to writing a specification than to finding magic words.

• Quantization

  Quantization stores a model’s weights at lower numerical precision — 4-bit or 8-bit integers instead of 16-bit floats — so the model needs less memory and runs faster. It is what makes it possible to run a multi-billion-parameter model on a consumer graphics card.

• REST API

  A REST API is an interface where data is exposed as addressable resources at URLs, and standard HTTP methods say what to do with them: GET to read, POST to create, PUT or PATCH to change, DELETE to remove. Responses are usually JSON, and each request stands on its own.

• Retrieval-augmented generation (RAG)

  Retrieval-augmented generation means searching your own documents for passages relevant to a question, then putting those passages into the model’s prompt so it answers from them rather than from memory. The model is not changed; only what it is shown changes.

• Schema markup (structured data)

  Schema markup is machine-readable data added to a page that states explicitly what the page is about — that this is a recipe, that this number is a price, that this text is an author’s name — using the shared vocabulary from schema.org.

• Semantic HTML

  Semantic HTML means using elements that describe what content is rather than how it looks: a heading as an h2, a list as a ul, navigation in a nav element. Screen readers, search engines and AI systems rely on that structure to understand a page, since a styled div tells them nothing.

• Service worker

  A service worker is a JavaScript file the browser installs alongside a site and runs separately from the page, where it can intercept outgoing network requests and answer them from a local cache. It is what makes a web app load offline, and it only takes effect after a first visit made online.

• Single sign-on (SSO)

  Single sign-on lets a user authenticate once with a central identity provider and then reach several separate applications without logging in again. The applications never see the password; they receive a signed assertion or token from the identity provider stating who the user is.

• Single-page application (SPA)

  A single-page application loads one HTML document once and then rewrites the page in the browser with JavaScript as the user navigates, instead of requesting a new document from the server for every view. React, Vue and Svelte apps are single-page applications by default.

• Source code export

  Source code export is a platform feature that hands you the actual files of the application you built there, usually as a downloadable archive. It is the difference between renting an application and possessing something you could host and modify yourself.

• SSL certificate

  An SSL certificate is a file installed on a web server that proves a hostname belongs to whoever controls it and lets the browser set up an encrypted connection. It is what turns http into https. The protocol in use has been TLS for years, but the name SSL stuck.

• Static site generation (SSG)

  Static site generation builds every page of a site into a finished HTML file ahead of time, at deploy, instead of assembling it per visitor on a server. The result is a folder of files that any host or CDN can serve directly, with no application server and no database in the request path.

• Subdomain

  A subdomain is a prefix on a domain that points to its own destination, as in app.example.com under example.com. It is created in DNS and can be pointed at a completely different server from the main site, which is why apps, documentation and staging environments so often live on one.

• Supabase

  Supabase is an open-source backend platform built around a standard PostgreSQL database, adding authentication, file storage, auto-generated APIs and serverless functions on top of it. It is commonly described as an open alternative to Firebase, with the important difference that the underlying database is ordinary Postgres.

• Token

  A token is the unit of text a language model actually reads and writes. It is usually a fragment of a word rather than a whole word, so the model never sees letters or words directly — only a sequence of integers that stand for these fragments.

• Vendor lock-in

  Vendor lock-in is the situation where leaving a supplier costs more than staying, even when staying has become a bad deal. It is not a single feature but the accumulated cost of migrating your code, your data, your integrations and your users somewhere else.

• Vibe coding

  Vibe coding is building software by describing what you want to a language model and accepting the code it produces without reading it closely — judging the result by whether it appears to work rather than by inspecting how. The term was coined by Andrej Karpathy in early 2025.

• Web app manifest

  A web app manifest is a JSON file, usually served at /manifest.json and linked from the page head, that tells the operating system how a web app should behave when installed: its name, its icons, the address it opens at and whether it launches in its own window or a browser tab.

• WebGPU

  WebGPU is a browser API that gives web pages direct access to the GPU for both graphics and general-purpose computation. It is what makes it practical to run a language model inside an ordinary browser tab, without a plugin, a driver or a native install.

• Webhook

  A webhook is an HTTP request that one service sends to a URL you provide when something happens on their side, such as a payment succeeding. It reverses the usual direction: instead of your code asking repeatedly whether an event has occurred, the other system tells you once it has.

Build it yourself

NorthernGo turns a plain-text description into a working web app with a database, login and a live URL. Local AI generation runs on your own GPU, is unlimited, and is free on every plan.

Start building free