#DevOps
36 posts tagged with this topic. ← All tags
-
Distributed tracing: following a request across multiple services.
How distributed tracing tracks a request through multiple services using trace context propagation, and how to implement it with OpenTelemetry.
-
Observability: logs, metrics, traces and how they differ.
The three pillars of observability -- logs, metrics, and distributed traces -- what each tells you, and how they work together.
-
Blue-green deployments: zero-downtime releases.
How blue-green deployments eliminate downtime during releases, how to implement them, and what to watch out for.
-
Load balancing: distributing traffic without a single point of failure.
How load balancers distribute traffic across server instances, the algorithms they use, and how health checks keep traffic away from failed instances.
-
The 12-factor app: principles that make deployment not a surprise.
A practical walkthrough of the 12-factor app methodology and how each factor prevents the common failure modes of deployment.
-
DNS: the lookup chain and the TTL that affects your deploys.
How DNS resolution works step by step, what TTL means in practice, and why DNS propagation can hold up your deployments.
-
CDN architecture: what edge nodes do and how cache invalidation works.
How CDN edge nodes cache and serve content, the difference between push and pull CDNs, and how cache invalidation propagates.
-
Static vs dynamic rendering: making the right choice for each page.
The tradeoffs between static and dynamic rendering, what determines the right choice for a given page, and how modern frameworks handle the decision.
-
React Server Components: the mental model, not the hype.
What React Server Components actually are, how they differ from client components, and when to use each one.
-
Code splitting at the route level: loading less on every page.
What code splitting is, how route-level splitting works in React, and how to measure whether it's reducing your initial load.
-
Tree shaking: why your bundle is larger than it should be.
What tree shaking is, how it works, what breaks it, and how to verify it's actually happening in your build.
-
Image optimization: format, lazy loading, and the 5 minutes that pay off.
The image optimization techniques with the best effort-to-impact ratio, with concrete implementation examples.
-
Core Web Vitals: LCP, CLS, INP and the code changes that move the numbers.
What each Core Web Vital measures, why it matters for user experience, and the specific code changes that improve each metric.
-
Accessibility in React: the ARIA patterns that actually matter.
The ARIA attributes and accessibility patterns that have the most impact on screen reader users, with React implementation examples.
-
AI-assisted coding: what it changes and what it doesn't.
A grounded look at what AI coding tools actually change about software development workflows and where the limits are.
-
Fine-tuning vs prompting: when each one is the right tool.
What fine-tuning actually does, when it outperforms prompting, and when prompting is the better choice.
-
LLM cost optimization: tokens, batching, and the settings that matter.
Practical techniques for reducing LLM API costs without degrading output quality.
-
MCP: the protocol that lets AI models use tools.
What the Model Context Protocol is, how it works, and how to build an MCP server that exposes tools to AI models.
-
Multi-agent systems: orchestrating LLMs that call each other.
What multi-agent LLM systems are, the patterns for structuring them, and the practical challenges of building reliable agent pipelines.
-
Prompt injection: the security problem unique to LLM applications.
What prompt injection is, why it is hard to prevent, and the mitigations available for LLM application developers.
-
RAG: retrieval-augmented generation without the buzzwords.
What RAG is, how the pipeline works step by step, and when it is the right architecture for an LLM application.
-
LLM context windows: why length limits change how you design prompts.
What context windows are, how they constrain LLM application design, and the practical patterns for working within and around the limits.
-
Message queues: why you'd send a job to a queue instead of handling inline.
What message queues are, the problems they solve, and when adding a queue is the right architectural decision.
-
Redis for session storage: faster than a database for ephemeral data.
Why Redis is a better session store than a relational database, how to set it up, and what operational concerns to keep in mind.
-
Timeouts and retries: the two settings every HTTP client needs.
Why timeouts and retries are mandatory for any HTTP client in production, how to set them correctly, and how to avoid making things worse.
-
API keys vs OAuth: which auth model to use for which integration.
The mechanics of API keys and OAuth, when each is appropriate, and how to implement them securely.
-
Webhooks: receiving HTTP calls instead of making them.
How webhooks work, how to implement a secure receiver, and the operational challenges involved in handling them reliably.
-
Database transactions: what ACID actually guarantees.
What ACID properties mean in practice, with concrete examples of what breaks when each guarantee is violated.
-
The debugging loop: reproduce, isolate, fix, verify.
A structured approach to debugging that works across languages, systems, and types of bugs.
-
Feature flags: shipping incomplete code without breaking anything.
How feature flags work, the different types, and how to use them to decouple deployment from release.
-
Health check endpoints: what belongs in them.
What health check endpoints should verify, the difference between liveness and readiness, and how to implement them correctly.
-
Structured logs: why JSON beats printf in production.
What structured logging is, why plain text logs break down at scale, and how to implement structured logging in common languages.
-
Idempotency keys: making retries safe.
What idempotency keys are, why they matter for distributed systems, and how to implement them on both the client and server side.
-
Caching strategies: in-memory, HTTP headers, and when each is correct.
A practical guide to the main caching layers available to web applications and the decision logic for choosing between them.
-
The N+1 query problem: how it hides in your ORM.
What the N+1 query problem is, how ORMs generate it invisibly, and the techniques to detect and fix it before it hits production.
-
Preview deployments: every PR reviewable without a meeting.
How preview deployments work, why they replace synchronous review sessions, and how to set them up with modern CI pipelines.