English for developers · Bug reports

Bug report phrases for clear tickets

Quick answer

These 300 bug report phrases from the Devlingo app follow the structure every team uses: steps to reproduce, expected result, actual result and environment. Each one comes with when to use it and the audio, and they also cover following a bug up to the fix.

Updated

A good ticket has four fixed lines: Steps to reproduce, Expected behavior, Actual behavior and Environment. The rest is detail: version, browser, a screenshot of the error.

Easy phrases (93)

  1. I found a bug in the checkout flow.

    When to use it: Reporting a new bug you discovered in the application

  2. I can reproduce it every time on iOS 17.

    When to use it: Confirming consistent reproducibility on a specific platform

  3. Let me assign this bug to the backend team.

    When to use it: Routing a bug to the appropriate team for fixing

  4. I've attached a screenshot showing the error.

    When to use it: Including visual evidence when reporting a bug

  5. The app crashes when you tap the submit button twice.

    When to use it: Describing a crash scenario with specific reproduction steps

  6. I'll open a ticket for this in our issue tracker.

    When to use it: Creating a formal record of a bug in the project management tool

  7. Is this a known issue or something new?

    When to use it: Checking if a bug has already been reported before

  8. We need to hotfix this in production immediately.

    When to use it: Communicating urgency for a critical production issue

  9. I'm going to add more logging to help us debug this issue.

    When to use it: Planning to add observability to investigate a hard-to-reproduce bug

  10. The button doesn't work.

    When to use it: Describing a UI element that's broken

  11. The page is loading too slowly.

    When to use it: Reporting a performance issue

  12. It was working yesterday.

    When to use it: Noting that a feature recently broke

  13. Can you check the logs?

    When to use it: Asking someone to look at application logs

  14. The data is not showing up.

    When to use it: Reporting missing data in the UI

  15. I need more details to fix this.

    When to use it: Requesting additional context about a bug

  16. The fix is already deployed.

    When to use it: Informing that a bug fix is in production

  17. Which version are you running?

    When to use it: Identifying the software version for troubleshooting

  18. I'll look into it.

    When to use it: Acknowledging a bug report and committing to investigate

  19. The form validation is broken.

    When to use it: Reporting issues with input validation

  20. Does this happen every time?

    When to use it: Asking about the frequency of a bug

  21. The notification is not being sent.

    When to use it: Reporting a notification delivery failure

  22. The search is returning wrong results.

    When to use it: Reporting incorrect search behavior

  23. I closed this ticket as a duplicate.

    When to use it: Marking a bug as already reported

  24. Let me try to reproduce it.

    When to use it: Committing to verify a bug

  25. The images are not loading.

    When to use it: Reporting broken image loading

  26. Is there a workaround for this?

    When to use it: Asking for a temporary fix

  27. I assigned this bug to you.

    When to use it: Delegating a bug to a teammate

  28. The layout is broken on mobile.

    When to use it: Reporting a responsive design issue

  29. I can reproduce this bug consistently on the staging environment.

    When to use it: Confirming a bug is reproducible in a specific environment

  30. Please include the steps to reproduce when filing a bug report.

    When to use it: Asking a colleague to add reproduction steps to their bug ticket

  31. The button overlaps the navigation bar on smaller screen sizes.

    When to use it: Reporting a UI layout issue on certain devices

  32. Can you attach a screenshot showing the visual glitch?

    When to use it: Requesting visual evidence for a UI bug

  33. This only happens on Safari; Chrome and Firefox work fine.

    When to use it: Reporting a browser-specific compatibility issue

  34. Let me check the application logs to see what happened right before the crash.

    When to use it: Starting crash investigation by reviewing logs

  35. The config file on production is different from what we have in the repository.

    When to use it: Discovering a configuration drift between environments

  36. We should mark this as a P1 since it affects all users on the latest version.

    When to use it: Discussing priority classification for a widespread bug

  37. I filed a bug report with the expected behavior and the actual behavior clearly documented.

    When to use it: Describing the format of a well-written bug report

  38. I set a breakpoint and stepped through the code to find where the value becomes undefined.

    When to use it: Describing a debugging technique with breakpoints

  39. The layout breaks completely when the user switches to landscape orientation on tablets.

    When to use it: Reporting a responsive design issue on tablets

  40. After rotating the device, the scroll position resets to the top of the page.

    When to use it: Reporting a state preservation bug on device rotation

  41. I added the environment details and browser version to the bug ticket.

    When to use it: Enriching a bug report with system information

  42. Can you reproduce this on your machine or is it only happening in the CI pipeline?

    When to use it: Trying to determine if a bug is environment-specific

  43. The dark mode toggle does not update the status bar color until you restart the app.

    When to use it: Reporting a visual inconsistency with theme switching

  44. We should add a regression test for this bug to make sure it does not come back.

    When to use it: Suggesting preventive testing after fixing a bug

  45. The user reported that submitted data appears in the wrong order after refreshing the page.

    When to use it: Relaying a user-reported data display issue

  46. The tooltip gets cut off when it renders near the edge of the viewport.

    When to use it: Reporting a UI positioning bug with tooltips

  47. I need to check whether this crash happens only on iOS 16 or also on iOS 17.

    When to use it: Testing device and OS compatibility for a reported crash

  48. The error message shown to the user is too technical; we need a more user-friendly fallback.

    When to use it: Suggesting UX improvements for error handling

  49. The PagerDuty alert woke me up at 2 AM for what turned out to be a false positive.

    When to use it: Describing an incident that turned out not to be a real issue

  50. The feature flag is enabled in staging but disabled in production, which explains the different behavior.

    When to use it: Discovering why a bug appears in one environment but not another

  51. Let me write a minimal reproduction case so the library maintainer can investigate this bug.

    When to use it: Creating a minimal reproduction to report a bug upstream

  52. The modal overlay does not prevent clicks from reaching the elements underneath it.

    When to use it: Reporting a UI bug where a modal does not block interactions

  53. The keyboard covers the input field on shorter devices and users cannot see what they are typing.

    When to use it: Reporting a UI issue with the keyboard on smaller screens

  54. The password reset link expires after 15 minutes but the error message says it is valid for 24 hours.

    When to use it: Reporting inconsistency between behavior and displayed information

  55. We need to check if the bug is related to the library upgrade we did last sprint.

    When to use it: Investigating if a dependency update caused a bug

  56. I am writing a postmortem document to capture what went wrong and how we can prevent it in the future.

    When to use it: Creating documentation after a production incident

  57. The accessibility labels are missing on all the icon-only buttons, making the app unusable with VoiceOver.

    When to use it: Reporting an accessibility bug affecting screen reader users

  58. I verified the fix by running the full regression test suite and all 847 tests passed.

    When to use it: Confirming a bug fix through comprehensive testing

  59. Can you reproduce this bug consistently?

    When to use it: Asking a teammate if they can trigger the bug reliably every time

  60. We need to triage these incoming bugs by severity.

    When to use it: Organizing new bug reports by how critical they are to the product

  61. What are the exact steps to reproduce this issue?

    When to use it: Requesting detailed reproduction steps for a reported bug

  62. Please include the error message and stack trace in the bug report.

    When to use it: Asking someone to add detailed error information when filing a bug

  63. We need to roll back the last deployment immediately.

    When to use it: Urgently requesting a revert of the most recent production release

  64. This bug was marked as resolved but I can still reproduce it.

    When to use it: Reopening a closed bug because the fix did not actually address the problem

  65. I logged the issue with screenshots and device information.

    When to use it: Confirming that a bug has been properly documented with visual evidence

  66. Can you attach the network request and response logs?

    When to use it: Asking a reporter to provide HTTP traffic details for debugging

  67. I'm marking this as a P1 since it affects all checkout flows.

    When to use it: Setting a high priority on a bug that impacts the core revenue path

  68. This works on Chrome but the layout breaks on Safari.

    When to use it: Reporting a cross-browser visual rendering inconsistency

  69. The hotfix was deployed and the error rate is dropping.

    When to use it: Giving a positive status update after applying an emergency production fix

  70. Which commit introduced this regression?

    When to use it: Trying to identify the specific code change that caused a feature to break

  71. The OOM killer terminated the process because it exceeded the container memory limit.

    When to use it: Explaining a process crash caused by running out of memory in a containerized environment

  72. I've added a workaround but we still need a proper fix.

    When to use it: Communicating that a temporary solution is in place but technical debt remains

  73. The coupon code validation accepts expired coupons.

    When to use it: Reporting a business logic bug where date validation is not working for promotional codes

  74. Please assign this bug to the backend team for investigation.

    When to use it: Routing a bug to the appropriate team during triage

  75. The search results page shows zero results even though matching items exist.

    When to use it: Reporting a bug where the search index or query logic fails to return valid matches

  76. The toggle switch animates but the underlying state does not change.

    When to use it: Reporting a UI bug where a visual element does not update the data model

  77. The intermediate certificate is missing from the chain, causing verification to fail on older clients.

    When to use it: Diagnosing an SSL issue where the certificate chain is incomplete

  78. I can reproduce the bug on the staging environment but not locally.

    When to use it: Noting that a bug is environment-specific and cannot be debugged on the developer machine

  79. The garbage collector pauses are causing latency spikes over 500 milliseconds.

    When to use it: Identifying GC stop-the-world events as the cause of application latency issues

  80. Let me check the audit log to see who changed the configuration.

    When to use it: Investigating a configuration change by looking at the system audit trail

  81. Users on the free tier can access premium features due to a permissions bug.

    When to use it: Reporting that authorization logic incorrectly grants elevated access

  82. The progress bar resets to zero when the screen orientation changes.

    When to use it: Reporting a UI state loss caused by activity recreation on orientation change

  83. Please add the affected version number to the bug report.

    When to use it: Asking for version specifics to properly categorize and prioritize a bug

  84. The date picker allows selecting dates in the past for future-only events.

    When to use it: Reporting a validation bug where past dates should be disabled but are not

  85. I'm writing a regression test to make sure this bug does not come back.

    When to use it: Creating an automated test to prevent a fixed bug from reappearing in the future

  86. The email address field accepts strings without the at sign.

    When to use it: Reporting that input validation is not enforcing basic email format requirements

  87. The dark mode colors are not applied to the third-party payment sheet.

    When to use it: Reporting that a vendor-provided UI does not respect the app's theme settings

  88. The splash screen flickers before the main view appears on low-end devices.

    When to use it: Reporting a visual glitch during app launch on slower hardware

  89. Make sure the rollback plan is documented before we proceed with the release.

    When to use it: Requesting that a recovery strategy be written down before a risky deployment

  90. The user sees an infinite loading spinner because the error response is not handled.

    When to use it: Reporting that a missing error handler leaves the UI in a permanent loading state

  91. The crash only occurs when the device runs out of disk space during a write operation.

    When to use it: Identifying a rare crash condition triggered by insufficient storage

  92. Setting up a debug proxy to inspect the requests between the app and the server.

    When to use it: Describing the approach of using a proxy tool to capture and analyze network traffic

  93. The fix was validated in production and we're closing the incident.

    When to use it: Confirming that a production issue has been resolved and the incident can be closed

Intermediate phrases (125)

  1. Can you provide the steps to reproduce this issue?

    When to use it: Asking a reporter to describe how to trigger the bug

  2. This bug is critical and is blocking users from signing up.

    When to use it: Communicating the severity and user impact of a bug

  3. This looks like a regression from last week's release.

    When to use it: Identifying a bug as something that was previously working

  4. What environment are you seeing this on — staging or production?

    When to use it: Clarifying in which environment the bug occurs

  5. I'm marking this as high priority since it affects all users.

    When to use it: Setting the priority level of a bug based on user impact

  6. We should add a test case to prevent this from happening again.

    When to use it: Suggesting preventive measures after fixing a bug

  7. The bug has been fixed and the ticket is ready for QA verification.

    When to use it: Updating a bug status after the fix is implemented

  8. Please include the device model and OS version in the bug report.

    When to use it: Requesting environment details for proper bug documentation

  9. Let's reopen this bug — it's happening again after the latest deploy.

    When to use it: Reopening a previously closed bug that has reappeared

  10. The fix is in the pull request — can someone review it urgently?

    When to use it: Requesting an urgent code review for a bug fix

  11. I can only reproduce this on slow network connections.

    When to use it: Describing a bug that appears under specific network conditions

  12. I'm filing this bug as severity one — it's affecting revenue.

    When to use it: Assigning a high severity level to a bug that impacts business metrics

  13. Can you create a minimal reproducible example so we can isolate the issue?

    When to use it: Asking for a simplified test case to debug a problem

  14. This bug seems to be environment-specific — it only happens on the CI server.

    When to use it: Noting that a bug only appears in a particular environment

  15. I attached a video recording showing the exact steps to trigger the bug.

    When to use it: Providing a screen recording as evidence when reporting a bug

  16. Can you check the browser dev tools console for any JavaScript errors?

    When to use it: Asking someone to use browser developer tools for debugging

  17. Let's try resetting the local database and see if the bug persists.

    When to use it: Suggesting a database reset as a debugging step

  18. This bug only appears on slow network connections — I tested with throttling enabled.

    When to use it: Reporting a bug that is network-speed dependent

  19. I'm escalating this to the platform team — it looks like an infrastructure issue on their side.

    When to use it: Routing a bug to a different team after investigation

  20. The expected behavior is X, but the actual behavior is Y.

    When to use it: Using standard bug report format

  21. This looks like a regression from the last release.

    When to use it: Identifying a bug that was introduced by recent changes

  22. I can reproduce it consistently with these steps.

    When to use it: Providing reliable reproduction steps

  23. Let me check the stack trace.

    When to use it: Looking at the error details for debugging

  24. The API is returning a 500 error.

    When to use it: Reporting a server-side error from API

  25. I narrowed it down to this specific commit.

    When to use it: Identifying the root cause commit

  26. It's an intermittent issue, hard to reproduce.

    When to use it: Describing a flaky bug

  27. There's a null pointer exception on line 42.

    When to use it: Pinpointing a specific crash location

  28. We should add this edge case to our test suite.

    When to use it: Suggesting a test to prevent future regressions

  29. The memory usage keeps increasing over time.

    When to use it: Reporting a potential memory leak

  30. Let me do a git bisect to find when this broke.

    When to use it: Using version control to track down a regression

  31. I think there's a race condition here.

    When to use it: Suspecting a concurrency issue

  32. This only happens in production, not in staging.

    When to use it: Noting environment-specific behavior

  33. The response time has degraded significantly.

    When to use it: Reporting API performance degradation

  34. I'm going to reopen this bug, the fix didn't work.

    When to use it: Reopening a bug that wasn't properly fixed

  35. Let's add some debug logging to track this down.

    When to use it: Proposing to add temporary logging

  36. The timeout is set too low for this operation.

    When to use it: Identifying a configuration-related issue

  37. The error handling needs to be more robust here.

    When to use it: Suggesting better error handling

  38. I'm seeing a CORS error in the console.

    When to use it: Reporting a cross-origin resource sharing issue

  39. The database connection is timing out.

    When to use it: Reporting database connectivity issues

  40. The memory usage keeps climbing until the app eventually crashes with an out-of-memory error.

    When to use it: Describing a memory leak that leads to a crash

  41. I'm seeing intermittent timeouts on the API calls to the payment gateway.

    When to use it: Reporting network-related bugs with a third-party service

  42. This bug should be classified as critical since it blocks the checkout flow.

    When to use it: Arguing for a higher severity on a bug ticket

  43. The cached data is stale because we forgot to invalidate it after the update.

    When to use it: Identifying a caching bug where old data persists

  44. We need a hotfix deployed to production immediately to stop the data corruption.

    When to use it: Urgently requesting a production fix for a critical issue

  45. This test is flaky because it depends on the order of asynchronous operations.

    When to use it: Explaining why a test passes sometimes and fails other times

  46. The monitoring alert fired because error rates exceeded the threshold at 3 AM.

    When to use it: Triaging an incident based on monitoring alerts

  47. The error handling is missing for the case when the third-party API returns a 503.

    When to use it: Identifying a gap in error handling for external service failures

  48. The date picker shows the wrong month when the locale is set to Arabic.

    When to use it: Reporting a locale-specific bug in a UI component

  49. The bug only occurs when the user has more than 10,000 records in their account.

    When to use it: Describing a bug that manifests at scale

  50. I can see from the profiler that there is a significant memory leak in the image processing pipeline.

    When to use it: Using a profiler to identify memory issues

  51. The dropdown menu flickers when you hover near the boundary between two items.

    When to use it: Reporting a subtle visual/UI glitch

  52. User data got corrupted because the migration script ran twice on the same database.

    When to use it: Reporting data corruption caused by a migration issue

  53. This regression was introduced in version 3.2.1 according to the git bisect results.

    When to use it: Reporting the exact version where a regression appeared

  54. I downgraded the severity from critical to major after confirming a workaround exists.

    When to use it: Adjusting bug severity after finding a temporary solution

  55. The form validation passes on the client side but fails on the server with different rules.

    When to use it: Reporting inconsistent validation between frontend and backend

  56. The loading spinner never disappears if the API call fails without throwing an error.

    When to use it: Reporting a UI state bug when an API silently fails

  57. The currency formatting breaks for locales that use a comma as the decimal separator.

    When to use it: Reporting a locale-specific formatting bug

  58. The event listeners are not being cleaned up on component unmount, causing a memory leak.

    When to use it: Identifying a common frontend memory leak pattern

  59. The search index is out of sync with the database, returning results that were deleted hours ago.

    When to use it: Reporting data inconsistency between search index and database

  60. We rolled back the deployment because the new build caused a spike in error rates.

    When to use it: Describing an emergency rollback during an incident

  61. The text input field does not handle emoji characters correctly and corrupts the string.

    When to use it: Reporting a unicode handling bug in a text field

  62. The Grafana dashboard shows a clear correlation between the memory spike and the deployment timestamp.

    When to use it: Using monitoring tools to correlate incidents with deployments

  63. The CDN is serving a stale version of the JavaScript bundle even after we purged the cache.

    When to use it: Debugging a caching issue with CDN content delivery

  64. The admin panel shows different user counts than the analytics dashboard due to a counting discrepancy.

    When to use it: Reporting a data inconsistency between two systems

  65. The automated smoke tests caught the regression before it reached production.

    When to use it: Describing how automated tests prevented a production bug

  66. The request body is being parsed as text instead of JSON because the content type header is missing.

    When to use it: Debugging an API request parsing issue

  67. The test keeps failing randomly because it relies on real network calls instead of mocked responses.

    When to use it: Explaining the root cause of a flaky test

  68. I am going to add verbose logging around the failing code path to capture more diagnostic data.

    When to use it: Adding instrumentation to help debug an elusive bug

  69. Users on Android 12 report that push notifications are arriving but not showing in the notification tray.

    When to use it: Reporting a device-specific notification bug

  70. The environment variable for the database connection string was not set in the Kubernetes deployment config.

    When to use it: Finding a missing configuration that causes failures in production

  71. The infinite scroll triggers multiple duplicate API requests when the user scrolls too fast.

    When to use it: Reporting a UI/network performance bug with infinite scroll

  72. I traced the root cause to an off-by-one error in the pagination logic.

    When to use it: Identifying the root cause of a bug after investigation

  73. The CORS preflight request is being blocked, which prevents the frontend from calling the API.

    When to use it: Debugging a cross-origin request issue

  74. The chart component renders incorrectly when all data points have the same value.

    When to use it: Reporting a UI edge case with data visualization

  75. I cherry-picked the hotfix commit to the release branch and deployed it to production within the hour.

    When to use it: Describing an emergency fix process for production

  76. The progress bar animation stutters on low-end devices due to the heavy main thread usage.

    When to use it: Reporting a performance-related UI bug on certain hardware

  77. The SQL injection vulnerability was found during the penetration test in the search endpoint.

    When to use it: Reporting a security bug discovered during testing

  78. The auto-save feature is conflicting with the manual save, causing data to be overwritten silently.

    When to use it: Reporting a data loss bug caused by competing save mechanisms

  79. The SSL certificate renewal job failed silently and now the API is returning certificate errors to all clients.

    When to use it: Triaging a production incident caused by expired certificates

  80. The bug is closed as won't fix because the affected feature is being deprecated in the next major version.

    When to use it: Closing a bug report because the feature is being removed

  81. The expected behavior is a 200 response, but we're getting a 502.

    When to use it: Describing the gap between expected and actual API responses in a bug report

  82. This test is flaky — it passes locally but fails in CI.

    When to use it: Reporting an unreliable test that behaves differently across environments

  83. The bug only appears on Android 14 with dark mode enabled.

    When to use it: Narrowing down a cross-platform bug to a specific OS version and setting

  84. The discount calculation has a rounding error on orders over a thousand dollars.

    When to use it: Reporting a business logic bug where monetary calculations are slightly off

  85. The UI shows a stale state after navigating back from the detail screen.

    When to use it: Reporting that the view does not refresh its data when the user returns

  86. Push notifications are not arriving on iOS when the app is in the background.

    When to use it: Reporting that remote push notifications fail to deliver in a specific app state

  87. The deep link opens the wrong screen when the user is not logged in.

    When to use it: Reporting that a deep link does not handle unauthenticated users correctly

  88. The feature flag was accidentally enabled in production.

    When to use it: Reporting that an experimental feature was unintentionally turned on for all users

  89. I'm preparing a hotfix for the payment processing crash.

    When to use it: Informing the team that an urgent fix is being developed for a critical production bug

  90. The flaky test is caused by a hardcoded date that only fails in January.

    When to use it: Identifying the root cause of an intermittent test failure tied to calendar logic

  91. The app crashes when the user denies location permission and taps the map.

    When to use it: Reporting a crash caused by unhandled permission denial in a specific user flow

  92. The response payload is missing the pagination metadata.

    When to use it: Reporting that an API response lacks required pagination fields like total count or next cursor

  93. The tax calculation applies the wrong rate for Canadian provinces.

    When to use it: Reporting a business logic error where regional tax rules are incorrectly implemented

  94. The modal gets stuck in an open state if you tap outside while it's animating.

    When to use it: Reporting a UI state bug where a dismiss gesture conflicts with an ongoing animation

  95. The universal link falls back to the browser instead of opening the app.

    When to use it: Reporting that an app link does not trigger the native app as expected

  96. The SSL certificate will expire in three days and nobody renewed it.

    When to use it: Raising an urgent alert about an impending certificate expiration

  97. The test relies on a specific database seed that wasn't included in the setup.

    When to use it: Explaining why a test fails when run in isolation without its required test data

  98. I'm bisecting the commits to find when the performance degraded.

    When to use it: Using git bisect to narrow down which change introduced a slowdown

  99. The form submits empty data when the user double-taps the submit button.

    When to use it: Reporting a race condition in form handling caused by rapid user input

  100. I've narrowed it down to a null pointer in the deserialization logic.

    When to use it: Sharing progress on debugging a crash to a specific code location

  101. The notification token is not being refreshed after the user reinstalls the app.

    When to use it: Reporting that push tokens become stale when the app is reinstalled

  102. Scrolling the list causes the keyboard to dismiss and then reappear.

    When to use it: Reporting a UI flicker where the keyboard state oscillates during scrolling

  103. The data migration needs to handle the legacy format where emails were stored uppercase.

    When to use it: Identifying an edge case in data migration for older records with different formatting

  104. The minimum order amount check is evaluated before applying the discount.

    When to use it: Reporting that business rule ordering causes incorrect validation of order totals

  105. The app intercepts the deep link but crashes before navigating to the target screen.

    When to use it: Reporting that deep link handling crashes mid-flow before presenting content

  106. The CNAME record is pointing to the old domain and needs to be updated.

    When to use it: Identifying a DNS misconfiguration after a domain migration

  107. The feature flag targets the wrong user segment in the European region.

    When to use it: Reporting that flag targeting rules are misconfigured for a geographic segment

  108. We should cherry-pick the fix instead of deploying the entire release branch.

    When to use it: Suggesting a targeted hotfix approach rather than a full deployment

  109. The hotfix needs to be backward compatible with the previous API version.

    When to use it: Specifying a constraint for an emergency production fix

  110. The bug is a side effect of the cache invalidation we shipped last week.

    When to use it: Tracing a newly discovered bug to a recent change in caching behavior

  111. The test passes in isolation but fails when run as part of the full suite.

    When to use it: Describing a test that has hidden dependencies on shared state from other tests

  112. The connection pool is exhausted because queries are not releasing connections back.

    When to use it: Diagnosing why the application runs out of database connections under load

  113. On Windows the file path separator causes the import to break.

    When to use it: Reporting a cross-platform bug related to path handling differences between operating systems

  114. The API returns a 200 status but the response body contains an error object.

    When to use it: Reporting an API contract violation where the status code contradicts the response content

  115. The deferred deep link data is lost after the app finishes installing.

    When to use it: Reporting that app install attribution via deferred deep links is not working

  116. The gradual rollout was paused because the error rate exceeded the threshold.

    When to use it: Describing why a canary deployment was halted based on monitoring metrics

  117. The test timing out after thirty seconds suggests an unresolved promise.

    When to use it: Diagnosing a test timeout caused by an asynchronous operation that never completes

  118. The subscription renewal webhook is not reaching our endpoint.

    When to use it: Reporting that external payment provider callbacks are failing to arrive

  119. The shipping cost is calculated based on the billing address instead of the delivery address.

    When to use it: Reporting a business logic error where the wrong address is used for cost computation

  120. The feature flag SDK caches the initial evaluation and never refreshes during the session.

    When to use it: Reporting that feature flag changes are not picked up until the user restarts the app

  121. The backward-incompatible change broke all clients on versions below 3.0.

    When to use it: Reporting a rollout issue where an API change affected older client versions

  122. The API rate limiter counts authenticated and unauthenticated requests separately.

    When to use it: Explaining an unexpected rate limiting behavior found during debugging

  123. The order total includes items that were removed from the cart before checkout.

    When to use it: Reporting a business logic bug where deleted cart items still affect the final price

  124. The auto-scaling group launched new instances but they timed out during the bootstrap phase.

    When to use it: Reporting that newly launched instances fail to complete their initialization process

  125. We cannot rollback because the new migration is not backward compatible.

    When to use it: Explaining why a simple rollback is not possible after a breaking database change

Advanced phrases (82)

  1. The expected behavior is a success message, but instead we get a blank screen.

    When to use it: Describing the gap between expected and actual behavior

  2. Is there a workaround we can suggest to users in the meantime?

    When to use it: Asking about temporary solutions while the bug is being fixed

  3. I'm closing this issue since it's no longer reproducible after the update.

    When to use it: Closing a bug report that is no longer valid

  4. Could this be related to the memory leak we found last sprint?

    When to use it: Investigating whether a new bug is connected to a known issue

  5. This is a cosmetic issue — the button text is truncated on smaller screens.

    When to use it: Reporting a low-severity visual bug

  6. The logs show a null pointer exception when the user profile is empty.

    When to use it: Sharing technical findings from error logs

  7. I've narrowed it down to the authentication middleware causing the timeout.

    When to use it: Sharing root cause analysis after investigating a bug

  8. The race condition occurs when two users update the same record simultaneously.

    When to use it: Describing a concurrency bug with a specific trigger

  9. This edge case wasn't covered in our original test suite, so let's update it.

    When to use it: Identifying a gap in test coverage that allowed a bug to slip through

  10. After investigating, I believe this is a duplicate of issue #342.

    When to use it: Identifying a bug report as a duplicate of an existing issue

  11. The crash log is showing a null pointer dereference in the payment module.

    When to use it: Sharing specific crash log findings with the team

  12. The acceptance criteria don't match the actual implementation — should we update the ticket or the code?

    When to use it: Flagging a mismatch between requirements and implementation

  13. I deployed a temporary hotfix to unblock users while we work on the proper solution.

    When to use it: Communicating a quick fix deployed to mitigate a production issue

  14. The root cause was a stale cache invalidation strategy.

    When to use it: Explaining a complex bug origin

  15. We need to profile the application to find the bottleneck.

    When to use it: Suggesting performance analysis

  16. There's a subtle off-by-one error in the pagination logic.

    When to use it: Identifying a tricky indexing bug

  17. The deadlock occurs when two threads acquire locks in opposite order.

    When to use it: Explaining a concurrency deadlock

  18. This is a heisenbug — it disappears when you try to debug it.

    When to use it: Describing a bug that changes with observation

  19. The stack trace points to a null pointer dereference in the auth module.

    When to use it: Analyzing a crash report with stack trace details

  20. This looks like a race condition between the database write and the cache invalidation.

    When to use it: Identifying a concurrency bug during debugging

  21. We need to bisect the commits to find when this regression was introduced.

    When to use it: Using git bisect to identify the commit that caused a regression

  22. The timestamps are displayed incorrectly for users in timezones with half-hour offsets.

    When to use it: Reporting a timezone-related display bug

  23. The user's session token is not being refreshed before it expires, causing 401 errors.

    When to use it: Debugging an authentication edge case with token expiry

  24. The database query is running a full table scan instead of using the index.

    When to use it: Diagnosing a slow query performance issue

  25. I attached the core dump from the production server where the segfault occurred.

    When to use it: Sharing crash analysis artifacts for debugging

  26. There is a deadlock when two threads try to acquire the same locks in different order.

    When to use it: Describing a classic deadlock scenario in concurrent code

  27. The retry logic kicks in but never backs off, flooding the downstream service with requests.

    When to use it: Describing a bug in retry/backoff implementation

  28. The WebSocket connection drops silently without triggering the reconnect handler.

    When to use it: Reporting a network connection bug with no error feedback

  29. The connection pool is exhausted because connections are not being returned after query execution.

    When to use it: Diagnosing a resource exhaustion issue with database connections

  30. The OAuth callback URL is not properly URL-encoded, causing authentication to fail on redirect.

    When to use it: Debugging an auth flow issue with URL encoding

  31. The N+1 query problem is causing the page load time to spike when there are many related records.

    When to use it: Diagnosing a database performance issue

  32. The Stripe webhook is failing silently because we are not validating the event signature.

    When to use it: Identifying a third-party integration failure

  33. We noticed the file descriptors leaking under high load, eventually causing the process to crash.

    When to use it: Reporting resource exhaustion under stress testing

  34. I suspect the bug is in the serialization layer because the data looks fine in the database but is garbled in the API response.

    When to use it: Narrowing down a data corruption issue to a specific layer

  35. We have a deadlock scenario when the background job and the API handler both try to update the same row.

    When to use it: Describing a concurrency deadlock between background jobs and API calls

  36. The slow query log shows this join is taking over 30 seconds when the orders table exceeds one million rows.

    When to use it: Analyzing database performance from slow query logs

  37. Daylight saving time transitions are causing scheduled jobs to either run twice or skip entirely.

    When to use it: Reporting a timezone bug affecting scheduled tasks

  38. The circular dependency between these two services is causing unexpected initialization failures.

    When to use it: Identifying a dependency issue causing bugs

  39. The race condition only manifests under high concurrency with at least 50 simultaneous connections.

    When to use it: Describing conditions needed to reproduce a concurrency bug

  40. The GraphQL resolver is returning null for nested fields because the data loader has a batching issue.

    When to use it: Debugging a data fetching issue in a GraphQL API

  41. The distributed lock is not being released after the operation times out, blocking all subsequent operations.

    When to use it: Diagnosing a locking issue in a distributed system

  42. The heap dump analysis shows thousands of orphaned promise objects that were never resolved or rejected.

    When to use it: Analyzing a memory leak through heap dumps

  43. The two-factor authentication code validation is not constant-time, making it vulnerable to timing attacks.

    When to use it: Reporting a security-related bug in authentication code

  44. The cookie is not being set correctly because the SameSite attribute is too restrictive for cross-origin requests.

    When to use it: Debugging a cookie-related authentication issue

  45. The batch processing job is not idempotent, so rerunning it after a failure creates duplicate entries.

    When to use it: Identifying a data integrity issue with batch jobs

  46. The message queue is backing up because the consumer service cannot keep up with the ingestion rate.

    When to use it: Diagnosing a message queue bottleneck

  47. The data migration left orphaned records in the junction table that are causing foreign key constraint violations.

    When to use it: Reporting data integrity issues after a migration

  48. I've attached the thread dump from the frozen process.

    When to use it: Sharing diagnostic output from a hung application for investigation

  49. The memory leak grows by about 50 MB per hour under load.

    When to use it: Quantifying memory usage growth observed during sustained traffic

  50. The API is returning fields that violate the documented contract.

    When to use it: Reporting that an API response does not match its specification or schema

  51. The data migration script failed on rows with null timestamps.

    When to use it: Reporting a migration error caused by unexpected null values in a database column

  52. We're seeing SSL handshake failures after the certificate rotation.

    When to use it: Reporting connectivity errors that started when certificates were renewed

  53. DNS resolution is intermittently failing for our internal service.

    When to use it: Reporting sporadic DNS lookup failures that affect service-to-service communication

  54. The load balancer is routing traffic to an unhealthy instance.

    When to use it: Reporting that the load balancer's health checks are not working properly

  55. Autoscaling didn't trigger even though CPU usage hit ninety percent.

    When to use it: Reporting that automatic scaling rules failed to activate under high load

  56. The deadlock occurs when two threads acquire the locks in opposite order.

    When to use it: Explaining the root cause of a threading deadlock found via thread dump analysis

  57. The race condition only shows up under heavy concurrent requests.

    When to use it: Explaining that a timing bug is only visible during high concurrency

  58. The migration rolled back because of a foreign key constraint violation.

    When to use it: Explaining why a database migration failed to apply cleanly

  59. The heap dump shows a large number of unclosed database connections.

    When to use it: Analyzing a memory diagnostic to identify the source of a resource leak

  60. Silent push notifications are being throttled by the OS.

    When to use it: Diagnosing why background data pushes are not delivered consistently

  61. The DNS TTL is too long so clients are caching the old IP address.

    When to use it: Explaining why users still connect to a decommissioned server after a DNS change

  62. The health check endpoint returns 200 even when the database is down.

    When to use it: Reporting that health checks do not accurately reflect system status

  63. New instances are starting but they fail to register with the service registry.

    When to use it: Reporting autoscaling instances that come online but cannot serve traffic

  64. The feature flag evaluation is not consistent across microservices.

    When to use it: Reporting that different services see different flag values for the same user

  65. The rollback completed but the database schema is still on the new version.

    When to use it: Reporting a partial rollback where code was reverted but the database was not

  66. The deep link parser does not URL-decode the query parameters.

    When to use it: Reporting that special characters in deep link parameters are not handled correctly

  67. Certificate pinning rejects the valid certificate on the staging server.

    When to use it: Reporting that SSL pinning is too strict and blocks legitimate connections

  68. The load balancer sticky session configuration is causing uneven traffic distribution.

    When to use it: Diagnosing why some servers handle disproportionately more traffic than others

  69. The retry logic creates duplicate transactions when the first request actually succeeded.

    When to use it: Reporting that automatic retries cause idempotency issues in payment processing

  70. The APNS feedback service reports a high number of invalid tokens.

    When to use it: Diagnosing push notification delivery issues through Apple's feedback mechanism

  71. The scale-down policy is too aggressive and terminates instances that are still processing requests.

    When to use it: Reporting that autoscaling removes capacity too quickly under decreasing load

  72. The column type was changed in the migration but existing data was not converted.

    When to use it: Reporting a data migration that altered schema without transforming existing records

  73. The inventory count goes negative when two orders are placed simultaneously.

    When to use it: Reporting a concurrency bug in the stock management business logic

  74. The notification payload exceeds the four-kilobyte limit for APNs.

    When to use it: Diagnosing why some push notifications fail to deliver on iOS

  75. The certificate authority is not trusted by the client's operating system.

    When to use it: Explaining why SSL connections fail on certain devices with specific trust stores

  76. The DNS failover did not activate because the primary server was partially responding.

    When to use it: Explaining why automatic DNS failover did not kick in during a partial outage

  77. The connection draining timeout is too short for long-running WebSocket connections.

    When to use it: Reporting that load balancer connection draining terminates persistent connections prematurely

  78. After the hotfix, we need to verify the fix on canary before rolling out to all pods.

    When to use it: Defining the deployment verification strategy for an emergency fix

  79. The thread dump reveals that all worker threads are blocked waiting for a mutex.

    When to use it: Analyzing a thread dump to understand why the application is unresponsive

  80. The migration has an implicit dependency on a table that was dropped in a previous release.

    When to use it: Identifying why a database migration fails when applied in sequence on a fresh database

  81. The A/B test results are skewed because the feature flag assigned users unevenly.

    When to use it: Reporting that experiment data is unreliable due to biased user segmentation

  82. The postmortem revealed that the root cause was a misconfigured environment variable in the deployment pipeline.

    When to use it: Sharing the conclusion of an incident review meeting about a production outage

Other everyday developer situations

← English for developers

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.

Frequently asked questions

What people ask most about this, answered with the source.

How do you write steps to reproduce a bug?
A numbered list in the imperative: 1. Open the checkout page. 2. Add two items. 3. Tap Pay. Then Expected: … and Actual: ….
How do you say a bug does not happen every time?
It happens intermittently or I can reproduce it about one in five times.
DevlingoLearn tech phrases & speaking
Use without installingGet