ICT-Platform Dev Specialist FA key terms

A design style that separates a system into horizontal layers such as presentation, business logic, and data access, where each layer may call only the layer beneath it, limiting coupling and simplifying substitution of components.

An architectural style in which an application is composed of small, independently deployable services that own their data and communicate over network protocols, trading operational complexity for independent scaling and release autonomy.

A principle that assigns distinct responsibilities to distinct modules so that changes to one concern, such as logging or persistence, do not require edits scattered across unrelated code.

Two complementary measures of module design: cohesion describes how strongly related the responsibilities inside one module are, while coupling describes how many dependencies a module has on others. Low coupling and high cohesion are preferred.

An approach where each request carries all information needed to process it, so any instance can serve it without relying on locally stored session data, enabling horizontal scaling and simpler failover.

A property of an operation that produces the same end state when applied once or many times, which allows clients and gateways to safely retry requests after timeouts without duplicating side effects.

A client-supplied unique identifier attached to a request so the server can detect and suppress duplicate submissions, typically by storing the key and the original response for a retention window.

The documented and machine-checkable agreement between a provider and its consumers, covering request and response shapes, error codes, and behavioral guarantees that must remain stable across versions.

A language-neutral, YAML- or JSON-based description of HTTP APIs that documents paths, operations, schemas, and security schemes, and can drive code generation, documentation, and contract tests.

The practice of exposing business entities as addressable resources manipulated through standard HTTP methods with meaningful status codes, rather than encoding actions in URLs or tunneling everything through POST.

A technique for splitting large result sets into bounded pages, using offset-based or cursor-based tokens, so responses stay within latency and memory budgets and clients can resume traversal reliably.

An edge component that fronts backend services and centralizes cross-cutting concerns such as authentication, routing, rate limiting, request transformation, and response caching for all consumers.

A control that caps how many requests a client may make in a time window, protecting shared resources from overload and enforcing fair use, usually implemented with token bucket or sliding window counters.

An integration style where producers publish events to a broker and consumers react asynchronously, decoupling services in time and enabling fan-out, buffering, and replay of message streams.

A messaging guarantee where every message is delivered one or more times, so consumers must be idempotent or deduplicate by message identifier to avoid processing the same event twice.

A holding queue for messages that repeatedly fail processing, isolating poison messages so they can be inspected and replayed without blocking healthy traffic on the main queue.

The process of organizing relational tables to eliminate redundant data and update anomalies, typically by applying successive normal forms that decompose relations based on functional dependencies.

A deliberate introduction of redundancy, such as duplicated columns or precomputed aggregates, to reduce join cost and improve read performance, accepted at the price of extra write maintenance.

An auxiliary data structure, commonly a B-tree or hash table, that lets the database locate rows without scanning the whole table, improving read speed while adding storage and write overhead.

The database optimizer's chosen strategy for retrieving a query's result, showing access paths, join order, and estimated costs, and the primary tool for diagnosing slow statements.

A setting that defines which concurrency anomalies a transaction may observe, such as dirty reads, non-repeatable reads, or phantom rows, balancing consistency against throughput and lock contention.

Four guarantees for database transactions: atomicity (all or nothing), consistency (valid state transitions), isolation (concurrent transactions do not interfere), and durability (committed changes survive failure).

A strategy where transactions proceed without locking and validate at commit time, often using version numbers or timestamps, aborting and retrying when a conflicting update is detected.

A consistency model in which replicas may temporarily diverge but converge once updates propagate, used in distributed stores where availability and partition tolerance are prioritized over immediate agreement.

A constraint ensuring that a foreign key value always matches an existing primary key in the referenced table, or is null, preventing orphaned rows and dangling relationships.

A rule set that automatically transitions stored objects between storage tiers or deletes them after a defined age, controlling cost and retention without manual intervention.

Managing servers, networks, and managed services through version-controlled declarative definitions applied by tooling, so environments are reproducible, reviewable, and recoverable rather than hand-built.

A deployment model where running instances are never patched in place; instead a new image is built and replaces the old one, eliminating configuration drift and making rollback a matter of redeploying a prior image.

A release technique that runs two identical environments and shifts traffic from the live one to the newly deployed one, enabling near-instant rollback by switching traffic back.

A progressive rollout that sends a small share of traffic to a new version, monitors error and latency signals, and expands exposure only if health criteria hold.

A mechanism by which clients locate healthy instances of a service through a registry or DNS, so scaling events and instance failures do not require hard-coded addresses.

A probe, such as liveness or readiness, that reports whether an instance is running and able to serve traffic, letting orchestrators restart failed containers and remove unready ones from load balancing.

A resilience pattern that stops calling a failing dependency after a threshold of errors, failing fast and periodically probing for recovery, so one slow service cannot exhaust caller resources.

A target range for a measured reliability indicator, such as the proportion of successful requests under a latency threshold, used to decide when error budget is exhausted and releases must slow.

The degree to which a system's internal state can be inferred from its outputs, achieved in practice by correlating structured logs, metrics, and distributed traces via shared identifiers.

A technique that propagates a trace context across service calls and records timed spans, letting engineers see where latency accumulates and which component caused a failed request.

A unique value attached to a request at entry and carried through every downstream call and log line, enabling reconstruction of a single transaction's path across components.

An authorization pattern where a client redirects the user to an authorization server, receives a short-lived code, and exchanges it with its secret for tokens, keeping credentials out of the browser.

An identity layer built on OAuth 2.0 that adds an ID token and a userinfo endpoint, allowing clients to authenticate users and obtain verified identity claims rather than only delegated access.

A signed, base64url-encoded token containing claims in a header, payload, and signature, verifiable without a database lookup but difficult to revoke before expiry.

An authorization model that grants permissions to roles and assigns roles to principals, simplifying administration but requiring care to avoid role explosion and over-broad grants.

The practice of granting each identity only the permissions needed for its current task and for no longer than necessary, shrinking the blast radius of compromised credentials or misconfigured automation.

The controlled storage, rotation, and audited retrieval of credentials such as API keys and database passwords, typically through a vault or managed secret store instead of source code or images.

A verification approach where consumer expectations and provider responses are checked against a shared contract, catching integration breakage without standing up full end-to-end environments.

The property that a new version of an interface or data format continues to serve existing consumers unchanged, usually preserved by additive changes and deprecated fields rather than removals.

A guidance model that favors many fast unit tests, fewer service-level integration tests, and a small number of slow end-to-end tests, optimizing feedback speed against confidence in real behavior.

A practice where developers merge small changes frequently and each merge triggers automated build, test, and static analysis so integration defects surface within minutes rather than at release.

Adding more instances of a component to share load, as opposed to enlarging a single machine, requiring stateless services or shared external state to distribute work effectively.

The practice of copying data and configuration to independent storage on a schedule and periodically proving that recovery meets targets for lost data and time to resume service.