15 questions found
What is a canary release, and how does it reduce the blast radius of a risky Node.js deployment?
Advanced
A canary release routes a small percentage of traffic to a new version while the majority hits the stable version -- key metrics are monitored closely, and traffic is gradually shifted further if healthy, or rolled back immediately if problems appear, limiting exposure to a small user subset.
http:
route:
- destination: { host: myapp, subset: stable }
weight: 95
- destination: { host: myapp, subset: canary }
weight: 5
Real-world example
A social platform rolls out a new algorithm to 5% of users first, catching a subtle bug affecting a specific segment before it impacts everyone.
Common follow-ups: How does canary deployment compare to feature flags as a way to control exposure?;What metrics should automatically trigger rolling back a canary before a human notices?
Docker & Containerization for Node.js;Logging & Monitoring
What is a feature flag, and how would you implement one in a Node.js application to control a new feature's rollout?
Intermediate
A feature flag is a runtime conditional determining whether code executes, letting a feature deploy dormant and be enabled gradually without a new deployment -- decoupling deploying code from releasing features, enabling instant rollback by flipping the flag off.
if (await isFeatureEnabled('new-checkout-flow', req.user)) {
return renderNewCheckout(req, res);
}
renderLegacyCheckout(req, res);
Real-world example
A team rolls out a redesigned checkout behind a flag enabled first for employees, then 1%, 10%, and 100% of customers, able to instantly disable it if conversion rates dropped.
Common follow-ups: How do flags managed via a service like LaunchDarkly differ from a hand-rolled environment-variable flag?;What's the maintenance burden of flags left in the codebase long after a feature fully rolls out?
Architecture & Design Patterns;Testing with Jest
Mocha & the Node Test Runner
What is observability (as distinct from traditional monitoring), and what are its three commonly cited pillars?
Advanced
Observability is a system's property of exposing enough internal state that engineers can diagnose novel, unanticipated problems from external outputs -- the three pillars are logs (discrete events), metrics (aggregated numerical measurements), and traces (following a request's path across distributed services).
logger.info({ event: 'order_placed', orderId, durationMs }, 'Order placed');
metrics.increment('orders.placed');
const span = tracer.startSpan('process-payment');
span.end();
Real-world example
A team investigating a latency spike uses distributed tracing to follow slow requests across five microservices, finding the delay originates from a single downstream call dashboards alone hadn't surfaced.
Common follow-ups: How does observability differ practically from having lots of dashboards and alerts?;What tools like OpenTelemetry provide a vendor-neutral way to instrument all three pillars?
Logging & Monitoring;Debugging & Diagnostics
What is a container registry, and how does it fit into the deployment pipeline for a containerized Node.js application?
Intermediate
A container registry stores and versions built Docker images -- after CI builds and tags an image, it's pushed to the registry, from which the deployment target pulls the specific tagged version to run, providing a consistent, immutable artifact identical across every environment.
docker build -t 123456789.dkr.ecr.us-east-1.amazonaws.com/myapp:v1.2.3 .
docker push 123456789.dkr.ecr.us-east-1.amazonaws.com/myapp:v1.2.3
Real-world example
A team tags every image with the Git commit SHA, pushes to a private ECR registry, and deploys that exact immutable image to staging then production.
Common follow-ups: Why is tagging images with 'latest' risky for production deployments compared to an immutable version tag?;How do private registries handle authentication for pulling images?
Docker & Containerization for Node.js;Git & Project Management
What is the purpose of a .dockerignore file when preparing a Node.js project for cloud deployment?
Beginner
A .dockerignore file excludes files -- most importantly node_modules, .env files, and local build artifacts -- from being copied into a Docker build context, keeping images smaller and preventing accidentally baking local secrets or a platform-specific node_modules into a production image.
node_modules
npm-debug.log
.env
.git
coverage
Real-world example
A team's Docker images failed on a different CPU architecture until adding .dockerignore excluding node_modules, forcing 'npm ci' inside the build to install correctly-architected dependencies.
Common follow-ups: Why can copying a local node_modules folder into a Docker image cause native-module compatibility issues?;What other sensitive files should always be excluded from a build context?
Docker & Containerization for Node.js;Security