In a technical discussion you mostly use comparison and justification structures: The trade-off is…, This scales better because…, The bottleneck is…. Practice those and plug in the terms of your stack.
Easy phrases (79)
Can you check the logs for any errors?
When to use it: Asking a teammate to investigate application logs during debugging
The database query is taking too long to execute.
When to use it: Reporting a performance issue with a slow database query
I'll set a breakpoint here and step through the code.
When to use it: Describing a debugging approach using breakpoints
Let's roll back the deployment to the previous version.
When to use it: Deciding to revert a deployment after discovering issues in production
We need to write unit tests before merging this.
When to use it: Reminding the team about testing requirements before code integration
This function has too many responsibilities. Let's split it up.
When to use it: Suggesting refactoring a function that violates the single responsibility principle
The API response time is within acceptable limits.
When to use it: Confirming that performance metrics are meeting requirements
I'm seeing a null pointer exception in production.
When to use it: Reporting a runtime error found in the production environment
Can you reproduce the bug in the staging environment?
When to use it: Asking if a reported bug can be replicated in a non-production environment
Let's add integration tests for the payment flow.
When to use it: Suggesting comprehensive testing for a critical business feature
Make sure to handle the edge cases in the input validation.
When to use it: Reminding a teammate to account for unusual inputs during validation
The API is returning a 503 — the service must be down.
When to use it: Diagnosing a service outage based on HTTP status codes
Can you bump the Node version in the Dockerfile?
When to use it: Asking someone to update the runtime version in a container configuration
The build is failing because of a dependency conflict.
When to use it: Explaining why CI pipeline is broken due to package version issues
I ran the memory profiler and found a 200MB allocation spike during image processing.
When to use it: Using profiling tools to investigate high memory usage
Can you check if the SSL certificate has expired?
When to use it: Investigating a connection error that might be caused by an expired cert
The pipeline passed — you're good to merge.
When to use it: Telling a teammate that CI checks succeeded and they can proceed
Make sure you hash the password — never store it in plain text.
When to use it: Reminding about security best practices for password storage
The migration script ran successfully on staging.
When to use it: Confirming that a database migration was tested in a non-production environment
The DNS propagation is still in progress — give it a few more hours.
When to use it: Explaining why a domain change hasn't taken effect yet
Run the linter before pushing — it'll catch most of the formatting issues.
When to use it: Reminding a teammate about code quality tools
The rollback went smoothly — we're back on the previous version.
When to use it: Confirming a successful deployment rollback after a failed release
Can you tail the logs while I reproduce the bug?
When to use it: Coordinating real-time debugging with a teammate
This endpoint returns paginated results — you need to pass the page number and page size.
When to use it: Explaining API pagination to a frontend developer
The environment variables aren't loading — check the dotenv configuration.
When to use it: Debugging a configuration issue in a local development setup
Let's add input validation on the server side — never trust the client.
When to use it: Emphasizing security best practices for data validation
We need to sanitize all user input to prevent SQL injection attacks.
When to use it: Discussing security measures for database queries
The API rate limit is set to a hundred requests per minute per user.
When to use it: Communicating API usage limits to consumers
This query uses a left join to include records with no matching entries.
When to use it: Explaining SQL join logic to a teammate
Just push your changes and let the pipeline handle the rest.
When to use it: Encouraging a teammate to trust the CI/CD automation
That commit broke the build — can you revert it?
When to use it: Asking a teammate to undo a problematic code change
The staging environment is frozen — nobody deploys until after the release.
When to use it: Communicating a deployment freeze before a major release
This endpoint needs to support both JSON and XML response formats.
When to use it: Defining API content negotiation requirements
We should tag all our cloud resources for cost tracking.
When to use it: Setting up cost management practices in cloud infrastructure
I set up a GitHub Actions workflow to automatically run tests on every pull request.
When to use it: Describing a CI/CD automation that was recently configured
I hardcoded the timeout for now, but we should make it configurable.
When to use it: Noting a temporary shortcut that needs to be improved later
The webhook isn't firing — check if the event subscription is still active.
When to use it: Debugging a webhook integration that stopped working
The database connection string should come from an environment variable, not the code.
When to use it: Enforcing twelve-factor app principles for configuration
Let's add a caching layer to reduce database load.
When to use it: Proposing a cache to improve performance
The load balancer distributes traffic across multiple server instances.
When to use it: Explaining load balancing basics
Our CI/CD pipeline automatically runs tests and deploys to staging.
When to use it: Describing continuous integration and deployment workflow
GraphQL lets the client request exactly the data it needs.
When to use it: Explaining GraphQL advantages over REST
The feature flag lets us toggle functionality without redeploying.
When to use it: Discussing feature flag usage in production
Let's set up A/B testing to measure the impact of this change.
When to use it: Planning experimentation for a new feature
Our SLA guarantees 99.9% uptime for production services.
When to use it: Discussing service level agreements
We need to encrypt data at rest and in transit.
When to use it: Discussing data security requirements
Technical debt is slowing down our feature development velocity.
When to use it: Sprint retrospective discussing code quality
Redis is a great choice for session caching and rate limiting.
When to use it: Choosing a caching technology
REST APIs should use proper HTTP status codes for error responses.
When to use it: API design best practices
Terraform manages our cloud infrastructure declaratively.
When to use it: Discussing infrastructure as code tools
Clean code should be readable without needing extensive comments.
When to use it: Code review discussion on readability
Git hooks can enforce coding standards before each commit.
When to use it: Setting up pre-commit hooks for code quality
We need to add rate limiting to protect our API from abuse.
When to use it: Implementing API security measures
The monolith is easier to debug but harder to scale independently.
When to use it: Comparing monolith vs microservices trade-offs
Structured logging makes it easier to search and filter log entries.
When to use it: Setting up application logging
Environment variables should never be hardcoded in source code.
When to use it: Security best practice discussion
Version control is essential for collaborative software development.
When to use it: Basic development workflow
The adapter pattern lets incompatible interfaces work together.
When to use it: Applying structural design patterns
Unit tests should be fast, isolated, and repeatable.
When to use it: Testing best practices discussion
We should use parameterized queries to prevent SQL injection attacks.
When to use it: Application security discussion
Feature toggles allow us to ship code without exposing incomplete features.
When to use it: Feature management in continuous delivery
Code reviews catch bugs early and spread knowledge across the team.
When to use it: Team development practices
Content delivery networks cache static assets closer to the end user.
When to use it: Improving web application performance
Linting tools enforce consistent code style across the project.
When to use it: Code quality tooling
Rolling deployments gradually replace old instances with new ones.
When to use it: Deployment strategies overview
Semantic versioning communicates the impact of changes through version numbers.
When to use it: Software release management
Mocking external dependencies makes unit tests faster and more reliable.
When to use it: Unit testing strategy discussion
Smoke tests verify that the most critical functionality works after deployment.
When to use it: Post-deployment verification
Docker Compose defines multi-container applications in a single YAML file.
When to use it: Local development environment setup
Pagination prevents the API from returning excessively large result sets.
When to use it: API design for large datasets
Lazy loading defers initialization of resources until they are actually needed.
When to use it: Performance optimization pattern
Health check endpoints allow the load balancer to detect unhealthy instances.
When to use it: Service availability monitoring
The singleton pattern restricts a class to a single instance throughout the application.
When to use it: Creational design patterns
Integration tests verify that different modules work correctly together.
When to use it: Testing pyramid discussion
Git rebase keeps a cleaner commit history compared to merge commits.
When to use it: Git workflow preferences
Stateless services are easier to scale horizontally than stateful ones.
When to use it: Cloud architecture scalability discussion
Feature branches should be small and merged frequently to reduce conflicts.
When to use it: Git branching strategy
Input validation should happen on both the client side and the server side.
When to use it: Application security layers
Refactoring improves code structure without changing its external behavior.
When to use it: Code maintenance and quality
Intermediate phrases (120)
We should refactor this into a microservices architecture.
When to use it: Proposing an architectural change to break a monolith into smaller services
Let's add an index to optimize this query.
When to use it: Suggesting a database optimization by adding an index
The deployment pipeline failed at the testing stage.
When to use it: Reporting a CI/CD pipeline failure during the test phase
This endpoint should follow RESTful conventions.
When to use it: Discussing API design standards for a new endpoint
We should implement rate limiting on the API.
When to use it: Suggesting adding rate limiting to protect API from abuse
I think we should use a message queue for this.
When to use it: Suggesting asynchronous processing with a message queue system
The CI pipeline runs linting, tests, and builds automatically.
When to use it: Explaining what the continuous integration pipeline does
The test coverage for this module is below the minimum threshold.
When to use it: Pointing out insufficient test coverage in a code module
We should paginate this API response to handle large datasets.
When to use it: Suggesting pagination to improve API performance with large result sets
Run EXPLAIN on that query — I bet it's doing a full table scan.
When to use it: Using database tools to diagnose slow query performance
We need to implement request throttling with exponential backoff on the client side.
When to use it: Discussing client-side strategies to handle API rate limits gracefully
We're using JWT for authentication on all our endpoints.
When to use it: Explaining the authentication mechanism used in the API
I'll spin up a new environment for testing this feature.
When to use it: Creating an isolated deployment to test a feature branch
The webhook payload is malformed — check the content type header.
When to use it: Debugging a webhook integration that's sending bad data
We should use feature flags to roll this out gradually.
When to use it: Proposing a phased release strategy using feature toggles
This class is closed for modification but open for extension — just add a new strategy.
When to use it: Applying the open/closed principle from SOLID design principles
We need sticky sessions enabled so the WebSocket connections stay on the same node.
When to use it: Configuring load balancer session affinity for stateful connections
We need to add CORS headers or the browser will block the request.
When to use it: Explaining a cross-origin issue when the frontend calls the API
Let's cache the response with a TTL of five minutes.
When to use it: Suggesting a caching strategy for frequently accessed data
The Kubernetes cluster needs more nodes to handle the traffic spike.
When to use it: Requesting infrastructure scaling during a high-traffic event
We should use WebSockets for real-time updates instead of polling.
When to use it: Suggesting a more efficient approach for live data in the UI
There's a memory leak — the heap keeps growing over time.
When to use it: Identifying a performance issue through memory profiling
Let's use Terraform to manage our infrastructure as code.
When to use it: Proposing infrastructure as code tooling for reproducible deployments
The OAuth flow is broken — users can't log in with Google anymore.
When to use it: Reporting a critical authentication bug affecting third-party login
I'll write a cron job to clean up stale sessions every night.
When to use it: Planning a scheduled maintenance task for session management
That query is doing a full table scan — it needs an index.
When to use it: Identifying a slow database query during performance analysis
The serverless function timed out — we need to increase the timeout limit.
When to use it: Debugging a Lambda or Cloud Function that exceeded its execution time
This design pattern is called the observer pattern — it's great for event-driven systems.
When to use it: Explaining a software design pattern to a teammate
Let's set up Prometheus and Grafana for monitoring and alerting.
When to use it: Proposing an observability stack for production systems
The technical debt in this module is making it nearly impossible to add new features.
When to use it: Arguing for a refactoring effort because legacy code is slowing down development
We need to rotate the API keys — they may have been compromised.
When to use it: Responding to a potential security incident involving exposed credentials
We should add a health check endpoint so the load balancer knows if the service is alive.
When to use it: Implementing service health monitoring in a distributed system
The database needs a foreign key constraint to enforce referential integrity.
When to use it: Suggesting a schema improvement for data consistency
The docker image is too large — we should use a multi-stage build.
When to use it: Optimizing container image size for faster deployments
Let's add structured logging so we can query the logs more easily.
When to use it: Improving observability by switching from plain text to JSON logs
That's a tight coupling between these two modules — let's introduce an interface.
When to use it: Suggesting decoupling through abstraction during an architecture review
The refresh token has a seven-day expiry — the access token expires in fifteen minutes.
When to use it: Explaining the token lifecycle in an OAuth-based authentication system
I'm going to write a data migration script to backfill the new column.
When to use it: Planning to populate a newly added database column with historical data
We should use a CDN to serve static assets — it'll reduce latency for global users.
When to use it: Optimizing content delivery for international users
I refactored the code to use dependency injection — it's much easier to test now.
When to use it: Explaining a refactoring that improved testability
The pod is stuck in a CrashLoopBackOff state — let's check the container logs.
When to use it: Troubleshooting a Kubernetes pod that keeps restarting
This is a breaking change — we need to version the API.
When to use it: Flagging an incompatible change that requires API versioning
The auto-scaler kicked in and spun up three more instances.
When to use it: Describing an automatic scaling event in response to traffic
The A/B test results show a fifteen percent improvement in conversion rate.
When to use it: Sharing results from an experiment to justify a product decision
We should debounce the search input to avoid hammering the API.
When to use it: Optimizing frontend behavior to reduce unnecessary API calls
The Helm chart needs to be updated before we deploy to the new cluster.
When to use it: Preparing Kubernetes deployment configurations
This recursive function will cause a stack overflow with large inputs.
When to use it: Warning about a potential runtime error in the code
The CI job takes forty minutes — we need to parallelize the test suite.
When to use it: Identifying a slow pipeline and proposing optimization
We added a fallback mechanism in case the third-party API goes down.
When to use it: Explaining a resilience strategy for external dependencies
Let me check the network tab — it might be a CORS preflight issue.
When to use it: Debugging a browser request failure using developer tools
We need to implement proper request throttling to protect the backend.
When to use it: Discussing API protection mechanisms for high traffic
I'm going to squash these commits before merging to keep the history clean.
When to use it: Organizing git history before a merge
We should implement the pub/sub pattern for real-time notifications.
When to use it: Proposing an architecture for pushing notifications to clients
The microservice has too many responsibilities — we should split it up.
When to use it: Identifying a service that has grown too large and needs decomposition
The secret is stored in the vault — don't hardcode it in the config.
When to use it: Ensuring secrets management best practices
The middleware is stripping the authorization header before it reaches the controller.
When to use it: Debugging an authentication issue in the request pipeline
The schema migration needs to be backward compatible — we can't break existing clients.
When to use it: Discussing safe database schema changes in a running system
The worker thread is consuming messages from the queue faster than expected.
When to use it: Observing message consumption rates in a queue-based system
The API gateway handles authentication, so individual services don't have to.
When to use it: Explaining centralized auth in a microservices architecture
The time complexity is O(log n) because we're using binary search.
When to use it: Explaining algorithm efficiency during a technical discussion
The backup script failed silently — we didn't realize we had no backups for a week.
When to use it: Describing a dangerous operational failure that went unnoticed
Let's use a NoSQL database for this — the data is unstructured and schema-less.
When to use it: Choosing the right database type for flexible data requirements
The monorepo approach makes it easier to share code between packages.
When to use it: Explaining repository structure choices to the team
The deployment got stuck — the readiness probe keeps failing.
When to use it: Troubleshooting a Kubernetes deployment that won't become healthy
The open/closed principle says we should extend, not modify existing code.
When to use it: Citing SOLID principles during a design discussion
We should store the configuration in a config map instead of baking it into the image.
When to use it: Following Kubernetes best practices for configuration management
The dependency graph has a circular reference that's causing the build to fail.
When to use it: Identifying a problematic dependency cycle in the project
We need to add a liveness probe so Kubernetes can restart unhealthy pods.
When to use it: Configuring health checking in a Kubernetes deployment
We should use a service account with least-privilege permissions.
When to use it: Applying the principle of least privilege for security
We should break this monolith into microservices to improve scalability.
When to use it: Discussing architecture migration from monolith to microservices
We need to version our API to avoid breaking existing clients.
When to use it: Planning API versioning strategy
We can use Kubernetes to orchestrate our container deployments.
When to use it: Proposing Kubernetes for container management
This algorithm has O(n log n) time complexity.
When to use it: Analyzing algorithm performance
We should apply the single responsibility principle to this class.
When to use it: Code review discussing SOLID principles
WebSockets provide full-duplex communication between client and server.
When to use it: Explaining real-time communication protocols
We need to add a composite index on these two columns for faster queries.
When to use it: Database optimization discussion
The observer pattern would be ideal for this notification system.
When to use it: Choosing a design pattern for event handling
Infrastructure as code ensures our environments are reproducible.
When to use it: Discussing DevOps practices
Set up alerting thresholds for CPU, memory, and error rates in our monitoring dashboard.
When to use it: Configuring observability and monitoring
The factory pattern will help us create different payment processors dynamically.
When to use it: Designing extensible payment system
The dependency injection container manages the lifecycle of our services.
When to use it: Discussing inversion of control and DI
The cache invalidation strategy uses a time-to-live of five minutes.
When to use it: Configuring cache expiration policies
The strategy pattern allows us to swap sorting algorithms at runtime.
When to use it: Applying design patterns for flexibility
The N+1 query problem is causing significant performance degradation.
When to use it: Identifying ORM performance anti-pattern
Blue-green deployment minimizes downtime during releases.
When to use it: Discussing deployment strategies
Denormalization can improve read performance at the cost of data redundancy.
When to use it: Database design trade-off discussion
Container images should be as small as possible to reduce attack surface.
When to use it: Docker security best practices
Canary releases let us test changes with a small percentage of traffic first.
When to use it: Discussing progressive deployment strategies
The open-closed principle says classes should be open for extension but closed for modification.
When to use it: Explaining SOLID principles during code review
Let's refactor this function to reduce its cyclomatic complexity.
When to use it: Code quality improvement discussion
Connection pooling reduces the overhead of creating new database connections.
When to use it: Database connection optimization
Distributed tracing helps identify latency bottlenecks across services.
When to use it: Implementing observability in microservices
Immutable infrastructure means we replace servers instead of updating them.
When to use it: Discussing modern infrastructure practices
The Liskov substitution principle ensures subclasses can replace their parent class.
When to use it: SOLID principles in object-oriented design
The API gateway handles routing, authentication, and request transformation.
When to use it: Describing API gateway responsibilities
The interface segregation principle prevents clients from depending on methods they do not use.
When to use it: Applying SOLID design principles
Chaos engineering helps us discover weaknesses in our production systems.
When to use it: Discussing resilience testing practices
Optimistic locking uses version numbers to detect conflicting updates.
When to use it: Concurrency control in databases
Trunk-based development keeps branches short-lived and encourages frequent merges.
When to use it: Discussing branching strategies
Serverless architectures scale automatically but can have unpredictable costs.
When to use it: Evaluating serverless trade-offs
The publish-subscribe pattern decouples message producers from consumers.
When to use it: Designing event-driven systems
We need to rotate our encryption keys periodically for compliance.
When to use it: Security and compliance requirements
Sticky sessions can cause uneven load distribution across servers.
When to use it: Load balancing issues discussion
GraphQL subscriptions use WebSockets for real-time data updates.
When to use it: Real-time API design
The dependency inversion principle ensures high-level modules do not depend on low-level ones.
When to use it: Discussing SOLID architectural boundaries
Helm charts simplify Kubernetes application deployment and management.
When to use it: Kubernetes tooling discussion
Kafka provides durable, high-throughput message streaming for event-driven systems.
When to use it: Choosing message broker technology
Graceful degradation ensures the system continues operating with reduced functionality during failures.
When to use it: System reliability design
The decorator pattern adds behavior to objects without modifying their class.
When to use it: Structural design pattern application
Namespace isolation in Kubernetes separates resources between different teams.
When to use it: Multi-tenant Kubernetes management
Contract testing validates that services communicate correctly at their boundaries.
When to use it: Microservice integration testing
Runbooks document step-by-step procedures for handling common operational incidents.
When to use it: Incident response documentation
Cross-site scripting attacks inject malicious scripts into trusted web pages.
When to use it: Web security vulnerability discussion
Multi-region deployments provide geographic redundancy and lower latency for global users.
When to use it: Global infrastructure planning
Configuration drift occurs when environments gradually become inconsistent over time.
When to use it: Infrastructure management challenges
Read replicas offload read traffic from the primary database to improve throughput.
When to use it: Database scaling with replication
The repository pattern abstracts data access behind a clean interface.
When to use it: Data layer design discussion
OpenTelemetry standardizes the collection of traces, metrics, and logs.
When to use it: Observability tooling standardization
Database connection strings should be stored in a secrets manager, not in config files.
When to use it: Secrets management best practice
Continuous monitoring detects performance regressions before users are affected.
When to use it: Production monitoring strategy
Advanced phrases (100)
We need to set up a caching layer to reduce latency.
When to use it: Proposing a caching strategy to improve response times
The memory leak is caused by a retain cycle.
When to use it: Identifying the root cause of a memory leak in the application
The load balancer is distributing traffic unevenly across the instances.
When to use it: Diagnosing a load balancing issue affecting server performance
We should invalidate the cache after every write operation.
When to use it: Discussing cache invalidation strategy to ensure data consistency
We should implement circuit breakers for external service calls.
When to use it: Proposing a resilience pattern to handle failures in external dependencies
We need to normalize the database schema to reduce redundancy.
When to use it: Discussing database design improvements to eliminate duplicate data
Let's use a blue-green deployment strategy to minimize downtime.
When to use it: Proposing a deployment strategy that allows zero-downtime releases
The container keeps crashing due to an out-of-memory error.
When to use it: Reporting a container failure caused by excessive memory consumption
The event-driven architecture decouples our services effectively.
When to use it: Explaining the benefits of the current system design approach
I optimized the algorithm from O(n²) to O(n log n).
When to use it: Reporting a performance improvement through algorithmic optimization
We should move to an event-driven architecture so services don't need to know about each other.
When to use it: Proposing a design where services communicate through events instead of direct calls
This endpoint should be idempotent so retries don't cause side effects.
When to use it: Discussing API design to ensure safe retry behavior
That's an O(n squared) solution — we can do better with a hash map.
When to use it: Discussing algorithm complexity and suggesting optimization
We should use the bulkhead pattern to isolate failures in the payment service from affecting search.
When to use it: Applying resilience patterns to prevent one service failure from impacting unrelated services
We should shard the database — a single instance can't handle this load.
When to use it: Discussing horizontal scaling strategies for a growing database
We're hitting connection pool exhaustion under heavy load.
When to use it: Identifying a database connection management issue during load testing
This is a classic race condition — two threads are writing to the same resource.
When to use it: Identifying a concurrency bug during debugging
I'd prefer GraphQL here — we're over-fetching data with REST.
When to use it: Suggesting a different API approach when too much data is being returned
Can we add a dead letter queue for messages that fail processing?
When to use it: Suggesting error handling for a message-driven architecture
We're following a trunk-based development approach with short-lived branches.
When to use it: Explaining the team's branching strategy
We should implement eventual consistency here — strong consistency would kill performance.
When to use it: Making a trade-off decision in a distributed system design
I've set up a blue-green deployment strategy to minimize downtime.
When to use it: Explaining a zero-downtime deployment approach
The event sourcing approach lets us reconstruct any past state of the system.
When to use it: Explaining the benefits of an event-driven architecture pattern
We need to set up proper log aggregation — searching individual servers isn't scalable.
When to use it: Arguing for centralized logging in a multi-server environment
I think we should use a reverse proxy here to handle SSL termination.
When to use it: Suggesting infrastructure architecture for HTTPS handling
We should implement a saga pattern for this distributed transaction.
When to use it: Discussing how to handle multi-step transactions across microservices
The canary deployment caught a regression — only two percent of users were affected.
When to use it: Reporting a successful early detection of a bug through gradual rollout
We're getting a lot of N plus one queries — we should eager-load the associations.
When to use it: Identifying a common ORM performance anti-pattern
Let's add request tracing so we can follow a request across all services.
When to use it: Implementing distributed tracing for debugging in microservices
The post-mortem revealed that the root cause was a misconfigured environment variable.
When to use it: Sharing findings from an incident retrospective
We're using optimistic locking to handle concurrent updates.
When to use it: Explaining concurrency control strategy in the data layer
I'd suggest using the strategy pattern here instead of a giant switch statement.
When to use it: Recommending a design pattern to replace complex conditional logic
The database replica is lagging behind the primary by three seconds.
When to use it: Monitoring replication lag in a database cluster
We should set up SLOs for latency and availability before we launch.
When to use it: Establishing service level objectives as part of production readiness
We're storing sensitive data at rest — make sure it's encrypted with AES-256.
When to use it: Ensuring compliance with data security requirements
Let's use a write-through cache to keep the data consistent.
When to use it: Discussing caching strategies that prioritize data consistency
The configuration drift between staging and production caused the bug.
When to use it: Explaining why something worked in staging but broke in production
We're implementing the CQRS pattern to separate reads from writes.
When to use it: Explaining an architectural pattern for high-performance systems
The garbage collector is causing latency spikes — we need to tune the GC settings.
When to use it: Investigating JVM or runtime performance issues
The data warehouse is optimized for analytical queries, not transactional ones.
When to use it: Explaining the difference between OLAP and OLTP systems
The horizontal pod autoscaler scales based on CPU utilization.
When to use it: Explaining Kubernetes autoscaling configuration
I added a retry with exponential backoff for transient failures.
When to use it: Implementing a resilience pattern for unreliable network calls
The service mesh handles all the inter-service communication for us.
When to use it: Explaining how infrastructure-level networking is managed
The ingress controller is routing traffic to the wrong backend service.
When to use it: Debugging a Kubernetes networking issue
Have you considered using a bloom filter to speed up the lookup?
When to use it: Suggesting a probabilistic data structure for performance optimization
The database transaction is holding a lock for too long — it's blocking other writes.
When to use it: Diagnosing a concurrency issue caused by long-running transactions
Let's add a materialized view to pre-compute those aggregations.
When to use it: Optimizing database performance for frequent aggregate queries
The cold start latency on Lambda is about two seconds — we might need provisioned concurrency.
When to use it: Discussing serverless performance trade-offs
We need a chaos engineering practice to test our system's resilience.
When to use it: Proposing systematic failure testing for production systems
We're using a sidecar container for logging in each pod.
When to use it: Explaining a Kubernetes deployment pattern for centralized logging
We're using a trie data structure for the autocomplete feature.
When to use it: Explaining the implementation choice for a search suggestion feature
The error budget is almost used up — we need to focus on reliability this sprint.
When to use it: Using SRE concepts to prioritize stability over features
We should implement graceful shutdown so in-flight requests can finish before the service stops.
When to use it: Ensuring zero-downtime during service restarts
The response time p99 is over two seconds — we need to optimize.
When to use it: Analyzing latency percentiles and identifying performance issues
I'm going to add a composite index on those two columns — it'll cover the most common queries.
When to use it: Optimizing database performance with a multi-column index
The hot path is allocating too many objects — it's putting pressure on the garbage collector.
When to use it: Identifying performance issues caused by excessive memory allocation
Let's add OpenTelemetry instrumentation for distributed tracing.
When to use it: Setting up observability tooling across microservices
The database schema needs a third normal form review.
When to use it: Discussing database normalization during schema design
JWT tokens should have a short expiration time with refresh token rotation.
When to use it: Discussing secure authentication token strategy
The serverless function cold start is causing latency spikes.
When to use it: Debugging serverless performance issues
We use an event-driven architecture with a message queue for decoupling.
When to use it: Explaining system architecture decisions
The incident postmortem revealed a cascading failure in our microservices.
When to use it: Reviewing a production incident
Let's implement the circuit breaker pattern to handle downstream failures gracefully.
When to use it: Designing resilient microservice communication
The query execution plan shows a full table scan instead of using the index.
When to use it: Debugging slow database queries
We should use OAuth 2.0 with PKCE for our mobile authentication flow.
When to use it: Designing secure mobile auth
Kubernetes pods are being evicted due to memory pressure on the node.
When to use it: Troubleshooting Kubernetes resource issues
We should implement idempotent endpoints to safely handle retries.
When to use it: Designing fault-tolerant APIs
We need to handle eventual consistency in our distributed database.
When to use it: Discussing distributed systems trade-offs
Dead letter queues capture messages that failed processing for later analysis.
When to use it: Configuring message queue error handling
The horizontal pod autoscaler adjusts replicas based on CPU utilization.
When to use it: Kubernetes autoscaling configuration
The SLO for this service is a 200-millisecond response time at the 99th percentile.
When to use it: Defining service level objectives
The saga pattern coordinates transactions across multiple microservices.
When to use it: Managing distributed transactions
GraphQL resolvers should batch database queries to avoid performance issues.
When to use it: Optimizing GraphQL backend performance
Consistent hashing distributes load evenly across cache nodes.
When to use it: Designing distributed caching architecture
Database migrations should be backward compatible for zero-downtime deployments.
When to use it: Planning database schema changes safely
We should implement the strangler fig pattern to migrate away from the legacy system.
When to use it: Planning incremental legacy modernization
The CQRS pattern separates read and write models for better scalability.
When to use it: Discussing advanced architectural patterns
Webhook retries should use exponential backoff to avoid overwhelming the endpoint.
When to use it: Designing reliable webhook delivery
The service mesh handles cross-cutting concerns like authentication and observability.
When to use it: Discussing service mesh benefits
Event sourcing stores every state change as an immutable event in the log.
When to use it: Discussing event sourcing architecture
Sharding the database horizontally distributes data across multiple nodes.
When to use it: Database scaling strategy
The write-ahead log ensures durability of database transactions.
When to use it: Database internals discussion
Materialized views precompute query results for faster reads.
When to use it: Database performance optimization
Two-phase commit ensures atomicity across distributed databases but introduces latency.
When to use it: Distributed transaction protocols
The bulkhead pattern isolates failures to prevent them from spreading.
When to use it: Microservice resilience patterns
The B-tree index structure enables efficient range queries on sorted data.
When to use it: Database indexing internals
Error budgets define how much unreliability a service can tolerate.
When to use it: SRE practices and SLO management
Write-behind caching asynchronously persists updates to the database.
When to use it: Advanced caching pattern discussion
Schema-on-read provides flexibility for handling semi-structured data.
When to use it: Data lake and NoSQL design discussions
The CAP theorem states that distributed systems can guarantee only two of consistency, availability, and partition tolerance.
When to use it: Distributed systems theory
Token bucket algorithms control the rate at which requests are processed.
When to use it: Rate limiting implementation details
Bitmap indexes are efficient for columns with low cardinality.
When to use it: Database indexing strategy
Backpressure prevents fast producers from overwhelming slow consumers in streaming systems.
When to use it: Stream processing architecture
The sidecar pattern deploys a helper container alongside the main application container.
When to use it: Kubernetes design patterns
Gossip protocols enable nodes in a cluster to share state information efficiently.
When to use it: Distributed systems communication
Mutation testing measures the effectiveness of your test suite by introducing code changes.
When to use it: Advanced testing methodology
The leader election algorithm determines which node coordinates work in a distributed system.
When to use it: Distributed consensus mechanisms
Partitioned consumer groups enable parallel processing of message queue topics.
When to use it: Message queue scaling patterns
The outbox pattern ensures reliable message publishing alongside database transactions.
When to use it: Distributed messaging reliability
Well-defined bounded contexts prevent domain model pollution across microservices.
When to use it: Domain-driven design in microservice architecture
Other everyday developer situations
- Daily standup280 phrases
- Code review275 phrases
- Pull requests300 phrases
- Bug reports300 phrases
- Meetings300 phrases
- Job interviews300 phrases
- Slack and chat300 phrases
- Email298 phrases
- Polite phrases300 phrases
- Pair programming300 phrases
- Documentation300 phrases
Guides with more context
Take it to your phone
In the Devlingo app you get 10 new phrases a day, each with real-world context, pronunciation and examples, and the widget shows the phrase of the day on your iPhone Home Screen.