Technical Glossary¶

A¶

API (Application Programming Interface): A set of protocols and tools for building software applications, specifying how software components should interact.
Aggregate (DDD): A cluster of domain objects that can be treated as a single unit, with one object designated as the aggregate root.
Agent (AI): An autonomous software entity that can perceive its environment and take actions to achieve specific goals.
ATS (Applicant Tracking System): Software used by recruiters to filter and manage job applications, often using keyword matching.

BFF (Backend for Frontend): A dedicated backend service optimized for a specific frontend application's needs.
Bulkhead Pattern: Isolation technique that prevents failures in one part of a system from cascading to other parts.

Circuit Breaker: A design pattern that prevents cascading failures by monitoring for failures and temporarily blocking requests.
CQRS (Command Query Responsibility Segregation): Pattern that separates read and write operations into different models.
Claude Code: Anthropic's AI-powered development environment with autonomous agent capabilities.
Container: A lightweight, standalone package that includes everything needed to run software.

DDD (Domain-Driven Design): Software design approach focusing on modeling software to match business domains.
Dead Letter Queue: Queue for messages that cannot be processed successfully after multiple attempts.
Docker: Platform for developing, shipping, and running applications in containers.

Event Sourcing: Storing all changes to application state as a sequence of events.
Event-Driven Architecture: Software architecture paradigm where components communicate through events.
Embedding (AI): Vector representation of text that captures semantic meaning for similarity comparisons.

Federation (GraphQL): Technique for composing a distributed graph from multiple GraphQL services.

GitOps: Operational framework using Git as a single source of truth for infrastructure and applications.
gRPC: High-performance, open-source RPC framework using Protocol Buffers.

Helm: Package manager for Kubernetes, simplifying deployment of applications.
Horizontal Scaling: Adding more machines to a resource pool (scaling out).

Idempotency: Property where an operation produces the same result regardless of how many times it's executed.
IaC (Infrastructure as Code): Managing infrastructure through machine-readable definition files.

Kubernetes (K8s): Open-source container orchestration platform for automating deployment, scaling, and management.
Kafka: Distributed event streaming platform for high-performance data pipelines.

LLM (Large Language Model): AI model trained on vast amounts of text data capable of understanding and generating human-like text.
Load Balancer: Distributes network traffic across multiple servers to ensure reliability and performance.

MCP (Model Context Protocol): Protocol enabling AI models to interact with external tools and services.
Microservices: Architectural style structuring applications as collections of loosely coupled services.
Message Queue: Component that stores messages between services for asynchronous processing.

N8N: Workflow automation tool with visual programming interface for creating integrations.

Observability: Ability to measure system's internal state by examining outputs (logs, metrics, traces).
OpenTelemetry: Observability framework for cloud-native software providing APIs and tools.
Outbox Pattern: Ensures reliable event publishing in distributed systems by storing events before publishing.

Prometheus: Open-source monitoring and alerting toolkit for cloud-native environments.
Pub/Sub (Publish-Subscribe): Messaging pattern where publishers send messages without knowing subscribers.

Qdrant: Vector database optimized for similarity search and neural network embeddings.

RAG (Retrieval Augmented Generation): Technique combining retrieval systems with generative AI for accurate responses.
RabbitMQ: Message broker implementing Advanced Message Queuing Protocol (AMQP).
Redis: In-memory data structure store used as database, cache, and message broker.
REST (Representational State Transfer): Architectural style for designing networked applications using HTTP.

Saga Pattern: Managing distributed transactions across microservices through coordinated local transactions.
Service Mesh: Infrastructure layer handling service-to-service communication in microservices.
SSE (Server-Sent Events): Technology enabling servers to push updates to web clients over HTTP.
Semantic Chunking: Splitting text based on meaning rather than arbitrary character counts.

Terraform: Infrastructure as Code tool for building, changing, and versioning infrastructure.
Tracing (Distributed): Tracking requests as they flow through distributed systems.

Vector Database: Database optimized for storing and querying high-dimensional vectors.
Vertical Scaling: Adding more power (CPU, RAM) to existing machines (scaling up).

WebSocket: Protocol providing full-duplex communication channels over TCP connection.
Worker (Background): Process that runs tasks asynchronously outside the main application flow.

This glossary is continuously updated as new terms are encountered in the documentation.