Glossary

Each term has one meaning, and every chapter uses it the same way. In the chapters, the first use of a term on a page is underlined. Hover over it, or focus it, to see its definition.

Method terms

Teardown: The process of working out an app's design from its behavior, and the written result of that process.
Probe: A repeatable experiment a normal user can run on an app to expose one aspect of its design.
Signal: A behavior observed during a probe or during normal use.
Inference: A design claim drawn from one or more signals.
Observed: Confidence level. Seen directly in a probe. A fact about behavior.
Inferred: Confidence level. The design that best explains the observations, with the alternatives ruled out by a probe.
Speculative: Confidence level. Consistent with the observations, but at least one other design fits equally well.
Concern: One aspect of system design that applies across app types, such as sync or media.
Archetype: A generic app type, such as messaging or ride-hailing, defined by its dominant concerns.
Worksheet: The standard form a teardown is recorded in.
Constraint: A force every mobile app is subject to, such as an unreliable network or process death.

System terms

Client: The app running on the device.
Backend: Everything the client talks to over the network.
Local store: Structured data the client keeps on the device and can query.
Cache: A copy of data kept to avoid refetching it, which can be discarded without loss.
Replica: A copy of data that can be read and written on its own and later converges with other copies. A local store is a replica when the app writes to it first.
Source of truth: The copy of a piece of data that wins when copies disagree.
Mutation: A single intended change to data, such as "send this message" or "rename this item".
Optimistic update: Showing the result of a mutation in the UI before the backend has confirmed it.
Outbox: A durable, ordered queue of mutations that have been applied locally and not yet confirmed by the backend.
Idempotency key: An identifier the client attaches to a mutation so that the backend applies it at most once, however many times it is sent.
Reconcile: To replace optimistic local state with the confirmed state from the backend.
Rollback: To undo an optimistic update after the backend rejects the mutation.
Sync engine: The client component that sends the outbox, pulls remote changes and applies them to the local store.
Delta: The set of changes since a known point, as opposed to the full data set.
Cursor: An opaque token from the backend that marks a position in a change log or a list.
Change log: An ordered record on the backend of every change, which clients read by cursor.
Tombstone: A record that an item was deleted, kept so that the deletion can reach other replicas.
Backfill: Loading older data after the most recent data is already usable.
Conflict: Two replicas changed the same data without having seen each other's change.
LWW: Last write wins. A conflict rule in which the later change replaces the earlier one entirely.
Push hint: A message from the backend that tells the client that something changed and that it should pull, without carrying the change itself.
Process death: The operating system ending the app's process while it is in the background, without notice.
Cold start: Launching the app when no process exists for it.
Warm start: Returning to an app whose process is still alive.
Stale-while-revalidate: Showing cached data at once and refreshing it in the background.
Remote config: Values fetched from the backend at run time that change the app's behavior without a new release.
Feature flag: A remote config value that turns a feature on or off for a set of users.
Server-driven UI: A design in which the backend sends a description of the screen's layout, and not only its data.
Fan-out: Delivering one event to many recipients or devices.
Session: The period during which the backend accepts a client as a given user without asking for credentials again.
Persistent connection: A two-way connection the client and backend keep open, so that either side can send at any time.
Platform push: Messages delivered to a device by the operating system's own push service, which reach the device when the app is not running.
Silent push: A platform push that shows nothing to the user and asks the operating system to wake the app briefly.

Method terms, continued

Signature: The set of behaviors a design produces that its alternatives do not.
Design space: The set of workable designs for one problem.
Candidate design: One of the designs that would produce a given signal, listed before any is chosen.
Discriminating probe: A probe for which at least two candidate designs predict different outcomes.
Inference chain: The four steps from observation to claim. Signal, then candidate designs, then a discriminating probe, then a claim with a confidence word.
Confidence word: One of Observed, Inferred or Speculative, attached to every claim.
First-pass probe: One of the six probes in Chapter 4 that work on any app and route the reader to the relevant concern chapters.
Quick teardown: A teardown of one feature in about 30 minutes, using the first-pass probes only.
Full teardown: A teardown of several features that works through each relevant concern chapter.
Open question: A design question the teardown did not settle, recorded with its candidate designs and what would settle it.
Baseline: A run of a probe's steps without the applied force, for comparison.

The universal app model

UI: The client component that draws the screen and takes input.
Screen state: The data a single screen holds in memory to draw itself, including transient values such as scroll position and typed text.
Domain logic: The product's rules, applied on the client or in backend services.
Data layer: The client component that decides where each piece of data comes from and gives it to the screens.
Network client: The client component that sends every request to the backend and handles sessions, timeouts and retries.
Background workers: Client tasks that run while no screen is visible, when the operating system allows.
Platform services: Capabilities only the operating system provides, such as notifications, location, secure storage and the store's payment system.
Gateway: The backend's single entry point, which checks the session, limits rates and routes requests to services.
Services: The backend components that run the backend's share of the domain logic.
Backend store: The backend storage that holds data which outlives any device.
Async delivery: Moving an event to where it is needed without a waiting request, by push, persistent connection or queue.
Media delivery: The backend component that stores images, audio, video and files and serves them in several sizes or qualities.
Third parties: Systems the app's team does not run, such as payment, identity, maps, analytics and ads.

Startup and navigation

Resume: Returning to an app whose process and screens are both intact, so nothing is rebuilt. The cheapest case of a warm start.
Splash: The screen shown from launch until the app draws its first real screen.
Skeleton: A screen's real layout drawn with placeholders where content will appear.
First frame: The first thing the app itself draws after launch.
First content: The moment real data is visible after launch.
Startup coordinator: The piece of domain logic that decides which screen is shown first.
Deferred initialization: Setup that runs after the first frame without being asked for.
Lazy initialization: Setup that runs on first use of a feature.
Forced-update gate: A screen that replaces the app when its version is below the backend's minimum supported version.
Maintenance screen: A screen that replaces the app when the backend states that the service is unavailable.
Migration: Converting the local store written by an old version to the shape the new version expects.
Navigation state: The tree of selected tab, per-tab stacks and modals that records where the user is.
Route: A screen identifier plus its arguments. One entry in navigation state.
Back stack: The list of screens under the current one, which back pops in order.
Synthesized back stack: A back stack the router builds under a link's target, so that back leads to a parent screen.
Modal: A screen or stack presented over everything else, with its own way out.
Router: The client component that turns a link or notification tap into navigation state.
State restoration: Rebuilding the user's screen, view state and input after process death.
View state: The arrangement of a screen that is not data, such as scroll position or selected segment.
Draft: Unfinished input stored as data, keyed by the thing it belongs to.
Deep link: An address that identifies one screen with its arguments.
Custom-scheme link: A deep link in an address scheme private to the app, which works only when the app is installed.
Verified web link: An ordinary web address on a domain the app's maker has proven it owns, which the operating system hands to the app when installed.
Deferred deep link: A link whose target is remembered through installation and opened on first launch.
Link resolver: The backend service that maps a link to a target and records taps for deferred deep links.

State and API shape

Observed query: A query against a store that notifies the screen again whenever its result changes.
Shared store: A single client-side copy of each item, keyed by identity, that every screen observes.
Derived state: A value computed from other state and not stored itself, such as a badge count or a total.
Change event: A notification inside the client that a mutation changed an item, which screens holding a copy listen for.
Refetch on appear: Fetching a screen's data again every time the screen becomes visible.
Over-fetching: A response that carries more data than the screen uses.
Under-fetching: A response that is not enough for the screen, so the client must make further requests.
Batching: Sending several logical requests in one round trip.
Backend for frontend: A backend layer dedicated to one client, which composes screen-shaped responses from services.
Screen-shaped response: A response cut to what one screen or section draws, composed on the backend.
Screen-describing response: A response that lists the sections a screen has as well as their data. The entry point to server-driven UI.
Query interface: An API in which the client states the fields it needs and the backend returns exactly those.
Resource-oriented endpoint: An API endpoint that exposes one kind of backend item, which the client reads, writes and composes with others.
Remote procedure call: An API call that names an action and carries its arguments.
Partial failure: A response or screen in which some parts succeeded and others did not.

Storage and caching

Read policy: The rule a screen follows when data may exist both locally and on the backend. It sets which copy the screen reads, and in which order.
Network only: A read policy in which the screen always fetches and never reads a local copy.
Network first: A read policy in which the screen fetches, and reads the cache only if the fetch fails.
Cache then network: A read policy in which a cached copy younger than a time limit is shown without a fetch, and otherwise the screen fetches and waits.
Cache only: A read policy in which the screen reads local data and never fetches on its own account.
Memory cache: A cache held in the process's memory, lost at process death.
Disk cache: A cache held in files on the device, which survives process death.
Response cache: A cache that stores each response under the request that produced it.
Entity cache: A cache that stores each item once, by identity, so every screen reads the same record.
Time limit: The maximum age at which a cached entry is used without a refresh.
Validator: A version tag or modification time the client sends back so the backend can answer that nothing changed, without a body.
Invalidation: Marking a cached entry as out of date, on a local write or on a message from the backend.
Eviction: Deleting cache entries to stay within a bound.
Prefetching: Fetching data before the user asks for it, on a prediction that the user will.
Seeding: Starting a detail screen from data the list already held, without a new request.
Key-value settings: Small values stored by name and loaded quickly at launch.
Secure hardware-backed storage: Storage for small secrets, protected by the device's hardware and unlock state.
Metered network: A network on which data use is billed or capped, typically cellular.

Network

Timeout: The client's decision that a request has failed because nothing came back in time.
Backoff: Lengthening the wait after each failed attempt.
Jitter: Randomizing each retry wait so that clients do not retry together.
Retry budget: A cap on how many retries a layer or client may issue.
Request queue: The network client component that ranks, cancels and merges requests.
Cancellation: Dropping a request nobody is waiting for.
Deduplication: Attaching a second caller to an identical request already in flight.
Connection pool: The component that keeps connections open for reuse.
Multiplexing: Carrying many requests as separate streams over one connection.
Network switch: The device moving from one network to another, such as wireless to cellular, mid-request.
Failover: Redirecting requests to another host or region when one fails.
Captive network: A network that accepts the device and intercepts its traffic until the user signs in or accepts terms.
Data-saver mode: A device setting by which the user asks apps to use less data.

Real-time delivery

Polling: Repeating a request on a timer to find out whether anything changed.
Long polling: A request the backend holds open until it has an event to return or a time limit passes, after which the client sends the next one at once.
Server stream: One request whose response the backend keeps open and writes events into. Data flows one way, from backend to client.
Ephemeral signal: An event that is sent and never stored, such as a typing indicator, and that a disconnected client never learns of.
Presence: The backend's knowledge of which users or devices are currently connected.
Heartbeat: A small periodic message that lets each end of a connection detect that the other end is gone.
Acknowledgment: A message sent back along the delivery path to confirm that an event was accepted, stored, delivered or seen.
Sequence number: A position the backend assigns to each event in a stream or message in a conversation, used to order items, detect gaps and act as a cursor.
Catch-up: Pulling the events missed while disconnected, by cursor from the change log.

Lists and feeds

Offset paging: Asking for a page by a count of items to skip.
Cursor paging: Asking for a page by sending back the cursor the backend returned with the previous page.
Keyset paging: Asking for a page by sending the sort key of the last item held.
Ranked feed: A list whose order the backend computes for one user at one moment, with no stable sort key.
Session snapshot: A ranked ordering the backend computes once and stores for a session, so that it can be paged through consistently.
Ranking stability: Whether a ranked feed returns the same order when requested again.
New-items control: A control that tells the user new items exist and inserts them only when tapped.
Silent merge: Inserting new items into a visible list as they arrive, without a user action.
Gap: A stretch of a time-ordered list missing between the newest page and the stored items.
Anchor: The item at which a list is entered when it is not entered at its start.
Placeholder: A row drawn before its data has arrived.
View recycling: Reusing a small set of row views for whichever items are currently in sight.

Messaging

Client-generated id: A permanent identifier the client assigns to a new item, which also serves as its idempotency key.
Read position: One value per user per conversation holding the highest sequence number that user has seen.
End-to-end encryption: A design in which only the participants' devices can read content, and the backend stores and forwards data it cannot read.
Backend-readable: The opposite of end-to-end encryption. The backend can read message content.
Companion: A device that shows conversations by relaying through the phone and stops when the phone is unreachable.
Independent devices: A multi-device model in which each device has its own connection, cursor and local store.
Fan-out on write: Copying a message to a queue per recipient at send time.
Fan-out on read: Recipients reading a shared log by cursor, instead of receiving a copy each.
Resumable transfer: An upload or download sent in parts, so that it continues after an interruption instead of restarting.

Search and personalization

Search index: A data structure, derived from the data and kept up to date, that maps words to the items containing them so that a query does not scan every item.
Local filter: Searching by scanning rows the client already holds for the typed text, with no index.
On-device index: A search index the client builds over its local store.
Debouncing: Waiting for a short pause in typing before sending a query.
Indexing lag: The time between a write reaching the backend store and the item being findable through the search index.
Facet count: The number of results that would remain if a filter value were chosen, computed over the whole matching set.
Completion: A proposed ending for the text typed so far, drawn from popular queries.
Model: A function whose behavior was learned from data instead of written by hand.
On-device model: A model that runs on the device.
Backend model: A model that runs on the backend.
Model inputs: The values a model reads when it runs.
Model asset: A model file delivered to the device after install and updatable without an app release.
Backend profile: The record of a user that personalization reads, kept against the account on the backend.
Device profile: The record of a user that personalization reads, kept in one device's local store.
Default ranking: What an account with no history is shown.
Feedback delay: The time between a user's behavior and its visible effect on a personalized surface.
Interaction event: A record of something the user did, uploaded for personalization or analytics.

Payments, ads and growth

Store billing: The store's own payment system, reached through platform services, required for digital goods used in the app.
External payment provider: A third party that moves money from the buyer's card or bank to the seller, used for physical goods and services.
Receipt: A signed record of a store purchase, which the backend verifies with the store.
Hosted payment screen: A page the provider serves to collect payment details, so that they never pass through the app's backend.
Payment token: A reference that stands in for a card and can be charged only by that seller at that provider.
Provider callback: A request the provider sends to the backend to report a payment's outcome.
Bank challenge: Extra proof of identity the buyer's bank demands in the middle of a payment.
Entitlement: The backend's current answer to what an account may use.
Restore purchases: A control that asks the store for the store account's past purchases and runs each through receipt verification.
Trial: A free or reduced first period of a subscription.
Grace period: A limited time after a failed renewal in which the entitlement stays active while the charge is retried.
Banner: An ad format. A strip that stays at an edge of the screen.
Full-screen ad: An ad format. An ad that covers the screen between two actions.
Rewarded ad: An ad format. An ad the user chooses to watch in exchange for something in the app.
Native ad: An ad format. An ad drawn as an item inside a feed or list.
Ad slot: A position in the UI that an ad may occupy.
Ad component: The client logic that loads ads, holds them and decides whether one may be shown.
Ad source: Any system that can return an ad when asked.
Mediation layer: A component that asks several ad sources for the same ad slot and picks one.
Fill: The share of ad requests that come back with an ad.
Frequency limit: A cap on how often a user sees ads.
Attribution: Matching an install or later action to the link or ad that caused it.
Referral code: An identifier for the inviting user, carried in a link or typed.
Contact matching: Uploading identifiers from the device's contacts so that the backend can match them against its accounts.
Rating prompt: A request for a store rating, fired by a condition.
Re-engagement notification: A notification sent to bring back a user who has stopped opening the app.

Media

Image variant: One version of an image at one size, format and quality, produced by media delivery from the original.
Stand-in: What an image view draws before its image has arrived.
Dominant color: One color value per image, computed at upload and carried in the item data for use as a stand-in.
Blurred preview: A very small encoded version of an image, carried in the item data and drawn enlarged until the image arrives.
Progressive image: An image file stored as passes of increasing detail, so that the whole picture appears soft and sharpens as bytes arrive.
Downsampling: Decoding an image to fewer pixels than the file holds, to match the size it is drawn at.
Edge cache: A copy of media kept by media delivery on servers near the user.
Start delay: The wait between the tap on play and the first picture or sound.
Progressive download: Playing a single file while it is still arriving.
Adaptive streaming: Delivering media as segments in several quality levels, with the player choosing a level for each segment.
Segment: A piece of media a few seconds long, fetched as one unit.
Quality level: One encoding of an item at one bitrate and resolution.
Manifest: A small document listing an item's quality levels, tracks and segment locations.
Buffer: Media already fetched and not yet played.
Stall: Playback stopping because the buffer emptied.
Playback position: The time a user has reached in an item.
System media controls: The platform service that shows what is playing and passes lock-screen and headset commands to the app.
Picture-in-picture: A small floating video window, drawn by the operating system over other apps.
License: A key for protected content, issued by the backend with rules such as an expiry.
Upload session: A record on the backend of one file in transit, which remembers the parts it holds.
Part: One fixed-size piece of a file in a resumable transfer, identified by its position.
Transfer queue: The durable client store of files in transit, with their progress and conditions.
Transfer worker: The background worker that sends or receives files from the transfer queue.
Upload, then attach: Sending a file to media delivery first, then sending the mutation that refers to it.
Signaling path: The path through the backend that sets up and manages a call.
Media path: The route that carries a call's audio and video, separate from signaling.
Media engine: The client component that captures, encodes, sends, receives, buffers and plays live media.
Relay: A backend server that passes media between two devices without decoding it.
Media server: A backend server on the media path of a group call.
Forwarding server: A media server that forwards each participant's stream without decoding it.
Mixing server: A media server that decodes all streams and sends each participant one composed stream.
Quality layers: The same video encoded at several qualities at once, so that a forwarding server can choose per receiver.
Call push: A high-priority platform push that lets the app present an incoming call when it is not running.
Playout buffer: A short receive-side buffer that evens out irregular arrival at the cost of delay.
End-to-end delay: The time from an event in front of one device to its appearance on another.
Segmented delivery: Live streaming as segments served by media delivery, with a delay of many seconds.
Low-latency delivery: Live streaming tuned or built for a delay of a few seconds or less.
Live edge: The newest moment of a live stream available to play.

Quality

Crash report: A record of the process's state at the moment it failed, written to the device and uploaded on the next launch.
Analytics event: A named action with a timestamp and a few properties, recorded by the client for the team.
Event queue: A durable, bounded queue of analytics events awaiting upload, which may drop entries, unlike an outbox.
Sampling: Collecting a channel from only a fraction of users, sessions or events.
Session recording: A record of what a user saw and did, detailed enough to replay.
Masking: Replacing sensitive content before a recording or log leaves the device.
Consent gate: The client component that drops any event the user has not agreed to.
Low-power mode: A device setting by which the user asks the system and apps to use less battery.
Main thread: The single thread on which all drawing and input handling happen.
On-demand resources: Resources or features left out of the install and downloaded on first use.
Download size: What the store transfers when the app is installed.
Installed size: What the app occupies on the device once installed.
Thermal state: The operating system's report of how hot the device is.
Device class: A coarse bucket, such as low, middle or high, that the client assigns to a device.
Network class: A coarse bucket for current network quality and cost, taken from measurement.
Small variant: A second, smaller app by the same maker for the same product, on the same backend.
In-app data saver: A setting inside the app that reduces its data use, distinct from the device's data-saver mode.
Adaptation policy: The client logic that turns device class, network class and settings into limits.

UI technology, reach and modularity

Platform toolkit: The operating system's own UI toolkit, used by code written separately for each platform.
Mapped toolkit: A cross-platform toolkit that turns one shared screen description into the platform's own controls.
Self-drawn toolkit: A cross-platform toolkit that ships its own drawing engine and paints every pixel itself.
Embedded web content: A web page shown inside the app, loaded from the network, the app bundle or a cache.
Game engine: A runtime that redraws the whole screen as one surface many times a second.
Bridge: The narrow set of messages through which web content or a shared-code runtime reaches the host app.
Seam: A place where the user passes from one drawing path, team or module to another.
Screen reader: The system feature that speaks the UI's published structure and lets a user act without seeing the screen.
Text scaling: The app's text and layout following the system text size.
Reduced motion: A system setting that asks apps to replace large movement with a fade or nothing.
Touch target: The tappable area of a control.
Right-to-left layout: A layout mirrored for languages read from right to left.
Bundled text: Strings shipped inside the app, chosen by device language.
Backend text: Strings that arrive in responses, in a language the backend chooses.
Feature module: A vertical slice of code holding one feature's UI, screen state and logic.
On-demand module: A feature module left out of the installed package and delivered by the store at first use.
Design system: A shared module of UI components with their colors, type sizes and spacing.
SDK: A library from another company that connects the app to that company's service.
Public interface: The entry points a library exposes to its callers.

Trust

Access credential: A short-lived credential sent on every request.
Renewal credential: A long-lived credential sent only to obtain a new access credential.
Silent renewal: Replacing an expired access credential without the user noticing.
One-time code: A short code or link sent to a channel the user controls, valid once.
Identity provider: A third party that proves who the user is and returns a signed statement.
Device-bound credential: A key pair in secure hardware-backed storage, unlocked by biometrics or passcode, that signs a backend challenge.
Second factor: A second sign-in method required after the first.
Local gate: An unlock the operating system confirms on the device, which the backend never hears of.
Device list: The user-visible list of sessions, one per signed-in device.
Revocation: Ending a session from somewhere other than the device that holds it.
Guest session: A backend session for an account with no credentials.
Client check: Validation on the client for fast feedback, which the backend cannot rely on.
Step-up proof: A second proof of identity demanded before a sensitive action.
Certificate restriction: The client accepting only its own short list of backend certificates.
Rate limit: A cap on how often one party may call an endpoint.
System prompt: The permission dialog the operating system draws.
Explanation screen: The app's own screen shown before a system prompt.
Degraded mode: What a feature does without its permission.
System picker: A system screen that returns chosen items without granting library access.
Consent record: The stored choice per user and purpose.
Privacy listing: The maker's published statement of data collected, shown in the store.

The device

Exit grace period: A short extension the operating system grants an app on leaving the screen, to finish what it is doing.
Deferred task: Background work the app registers with conditions and the operating system runs at a time it chooses.
User-visible work: Long-running background work the user knows about, which the platform shows with a mandatory indicator.
Push wake: A short period of background execution granted to the app when a platform push arrives.
System-displayed notification: A notification whose text is in the push payload and is drawn by the operating system with no app code.
App-built notification: A notification composed by app code on the device after a push wake.
Local notification: A notification the app schedules with the operating system, fired with no backend or network.
Replacement key: An identifier that makes a later push or notification replace an earlier one.
Expiry: How long the push service keeps trying to deliver a message to an unreachable device.
Region monitoring: The operating system watching a short list of regions and waking the app on entry or exit.
Coarse movement updates: Wakes delivered when the device has moved a significant distance.
Surface: A place the app appears outside its own window, run as a separate process.
Shared storage area: An on-device container that the main app and its surfaces can both read and write.
Snapshot: A stored view the system displays for a widget with no app code running.
Timeline: A list of snapshots with the times each becomes current.
Live status: A lock-screen view that follows one ongoing activity.
Extension: A small program the system loads inside another app's flow for one task.

Change over time

Kill switch: A feature flag kept for emergencies, which turns a feature off for everyone.
Staged rollout: Releasing a version or a feature to a share of users that is raised step by step.
Experiment: A set of variants assigned at random, with measurement of what each group does.
Experiment variant: One of the behaviors an experiment assigns.
Unit of assignment: The thing an experiment randomizes, an account or an installation.
Exposure: The event recorded when a user actually meets the place where variants differ.
Targeting: A rule that decides who gets a config value, by version, device, region or account.
Shipped defaults: Config values compiled into the app, used when nothing is cached.
Component catalog: The set of component types compiled into the app that a described screen may use.
Renderer: The client component that turns a screen description into UI.
Action handler: The client component that turns backend-described actions into navigation, mutations or reloads.
Screen composer: The backend layer that joins a screen definition with data for one client.
Minimum supported version: The lowest app version the backend will serve.
Soft prompt: A dismissible message that a newer version exists.
Release train: Versions that leave on a fixed schedule with whatever is ready.
Version negotiation: Client and backend agreeing on a response shape by stated version or capabilities.
Non-compiled code: Scripts and assets run by an interpreter in the app, which can be delivered outside the store.

Archetypes

Match server: The backend service that owns the true state of a real-time match and advances it at a fixed rate.
Client prediction: The client applying the player's own input at once, before the match server confirms it.
Correction: The client replacing its predicted state with the match server's and replaying inputs not yet processed.
Matchmaking: The backend queue that groups waiting players into a match by skill, delay and size.
Live operations: Changing a shipped game on a schedule through config, catalog data and asset packs, with no release.
Ledger: A backend record of grants and spends from which a balance is derived.
Host app: The app that owns identity, payment, navigation and permissions and runs services inside itself.
Mini-program: A package of non-compiled code and assets that the host app downloads and runs in a sandbox.
Mini-program runtime: The host app component that interprets and draws a mini-program.
Scoped identity: An identifier for a user that is valid for one mini-program only.
Wallet: The host app's stored balance and saved payment methods, shared by every service.
Play queue: The ordered list of items the player will play, together with the index of the current item.
Episode feed: A document, published by a show's maker, that lists the show's episodes with the address of each audio file.
Host: The participant in a meeting whose role lets them admit, mute and remove others.
Lobby: The state of a participant who has asked to join a meeting and has not been admitted.
Participant list: The backend's record of who is in a call, with each person's role and mute state.
Call state: The backend record of one call, holding the participant list, roles, lobby, recording flag and media server.
Device binding: Tying an account to registered devices, so that a request from an unknown device needs a stronger proof.
Idle timeout: Ending or locking a session after a period without input.
Available balance: The balance after amounts reserved for unsettled transactions are subtracted.
Booked balance: The balance that counts settled entries only.
Risk scoring: A backend judgment of how risky a request is, which sets the proof demanded.
Turn: One prompt and its answer in a conversation with an assistant.
Resumable stream: A server stream whose events carry sequence numbers, so that a client can rejoin after a break.
Live audio path: A continuous two-way audio connection between the user and a model.
Long-running task: A request the backend runs as a job and announces when finished.
Usage limit: A per-account cap on use that the backend counts and enforces.
Operation log: The ordered record of every operation applied to one document, from which its state and history are derived.
Checkpoint: The full state of a document stored at one revision, so that a client need not replay the whole operation log.
Live cursor: The mark showing where another person is typing. An ephemeral signal, unrelated to the sync cursor.
Block: One paragraph-sized unit of a document body, with its own id and version.
Conflicted copy: A second item kept when two replicas changed the same note or file.
Accessory: A separate device with sensors and a short-range radio that relays through the phone.
Pairing: The one-time exchange that lets an app and an accessory reconnect automatically.
Sample: One measurement with the time the sensor recorded it.
Recording session: The client component that owns an ongoing workout, apart from any screen.
Platform health data store: A repository of health data the operating system keeps on the device, shared by apps with consent per data type and direction.
Firmware update: A file transfer of new software to an accessory.
Cart: The items a buyer has chosen and not yet ordered, stored as item references, options and quantities.
Guest cart: A cart that belongs to a device or a guest session and not to an account.
Cart merge: The rule that joins a guest cart with the account's cart at sign-in.
Hold: A short reservation recorded by the backend, with a deadline. It reserves one item for one buyer in a booking flow, or an amount against a balance before a transaction settles.
Waiting room: A queue in front of a booking flow that admits buyers at a rate the inventory system can handle.
Rotating code: A ticket code that changes with time, so that a copy stops working after a short while.
Device wallet: The operating system's store for payment cards and passes.
Pass: A ticket held in the device wallet, which the backend can update without the app running.
Story: A short sequence of full-screen items from one account that expires after a fixed time.
Seen-state: One value per viewer per author holding the newest story item that viewer has seen.
Candidate items: The set of items a ranking step gathers and scores for one user.
Swipe feed: A ranked feed shown one full-screen item at a time, advanced by a swipe.
Preload window: The number of upcoming items, and how much of each, that the client fetches ahead of the current one.
Player pool: A small fixed set of prepared players reused as the user moves between items.
Poster image: A still frame fetched as an image and drawn where a video will play.
Encoding pipeline: The backend process that turns an uploaded video into quality levels, segments and a manifest.
Position store: The backend record of playback position per user per item.
Trip: The unit of work in an on-demand service. A backend record that moves through states, whether it carries a person or goods.
Quote: A price the backend issues before a request, with an identity and a time limit, which the confirm request refers to.
Hold, then capture: Reserving an amount on a payment token at the start and charging the final amount after completion.
Relayed number: A phone number from a telephony third party that connects two parties for one trip without revealing either's number.
Tile: One square piece of the map at one zoom level, addressed by zoom, column and row.
Image tile: A tile delivered as a finished picture.
Data tile: A tile delivered as shapes and names that the device draws.
Road graph: The junctions, road segments and rules that a router needs.
Region package: A file downloaded on purpose that holds map data, and optionally a road graph and a place index, for one area.
Platform-provided storage: Storage the platform gives each user under their platform account and syncs between that user's devices, with no backend run by the app's team.
Platform account: The user's account with the device platform, as distinct from an account of the app's own.
Store account: The account a store purchase belongs to.
Device backup: The operating system's backup of a device, which includes app data outside the storage area declared as cache.
Local unlock: A purchase state the client decides for itself from a receipt checked on the device, with no backend entitlement.
Keep-both resolution: Resolving a conflict by keeping each version as a separate item or marked copy.
In-app camera: A camera preview and controls drawn by the app itself.