Engineering Concepts You Keep Mixing Up (Explained Simply)

If you’ve spent time learning backend engineering, system design, or LLMs, you’ve probably come across terms that sound similar but mean very different things.

I used to confuse many of these myself.

This guide is a collection of the most common pairs.

Networking

Latency vs Throughput vs Bandwith

• Latency (The Delay): How long a single request takes to complete.
• Throughput (The Actual Flow): How many requests a system can process over a period of time.
• Bandwidth (The Capacity): The maximum amount of data a network can carry per unit of time.

Databases

Replication vs Sharding

• Replication: Stores copies of the same data on multiple machines. Used for: High availability — Fault tolerance — Faster reads
• Sharding: Splits different pieces of data across multiple machines. Used for: Scaling storage — Scaling write — Handling larger datasets

APIs

Polling vs Webhooks

• Polling: A client repeatedly asks “Has anything changed yet?”.
• Webhooks: The server automatically sends a notification when something happens.

Load Balancer vs API Gateway

• Load Balancer: Distributes incoming traffic across multiple servers. Its job is performance and availability.
• API Gateway: Acts as the front door to your APIs. It can:
• Authenticate users
• Route requests
• Rate limit clients
• Log traffic
• Transform requests

Concurrency

Process vs Thread

• Process: An independent running program with its own memory.
• Thread: A lightweight execution unit that shares memory with other threads in the same process.

Concurrency vs Parallelism

• Concurrency: Multiple tasks make progress during the same period. They may take turns.
• Parallelism: Multiple tasks execute at exactly the same time. Usually requires multiple CPU cores.

Software Architecture

Monolith vs Microservices

• Monolith: The entire application is built and deployed as one unit. Simple to start. Harder to scale as it grows.
• Microservices: The application is split into smaller independent services. Each service can be:
• Developed independently
• Deployed independently
• Scaled independently

LLM Engineering

Quantization vs Distillation

• Quantization: Makes the same model smaller by reducing the precision of its weights. Benefits:
• Less memory
• Faster inference
• Lower hardware requirements
• Distillation: Trains a new, smaller model to imitate a larger one. Benefits:
• Smaller model
• Faster inference
• Often better efficiency

LoRA vs QLoRA

• LoRA: Fine-tunes a model by training only a small set of additional weights. The original model stays frozen.
• QLoRA: Combines LoRA with quantization so very large models can be fine-tuned on much smaller GPUs.

SFT (Supervised Fine-Tuning) vs RLHF (Reinforcement Learning from Human Feedback)

• SFT: The model learns from example input-output pairs. Think: “Here is the correct answer.”
• RLHF: The model learns from human preferences. Think “Humans liked this answer more.”

Prefill vs Decode

• Prefill: The model reads and processes your entire prompt.This builds its internal context (KV cache).
• Decode: The model generates the response one token at a time.

Temperature vs Top-p

• Temperature: Controls how random the output is.
• Top-p: Limits the model to sampling from only the most likely tokens whose cumulative probability reaches p.

Security

JWT vs Session

• JWT (JSON Web Token): The server issues a signed token after authentication. The client stores the token (typically in a cookie or local storage) and sends it with every request.
• Session: After authentication, the server creates a session and stores it. The client only stores a session ID (usually in a cookie).

OAuth vs OpenID Connect

• OAuth 2.0: A protocol for authorization. It allows an application to access another application’s resources on a user’s behalf without knowing the user’s password.
• OpenID Connect (OIDC): An authentication layer built on top of OAuth 2.0. It verifies who the user is and provides identity information through an ID Token.