Error Handling and Logging Best Practices for Robust Web Applications

As a developer, I've learned that code will fail. Whether it's a third-party API timeout, a database connection issue, or unexpected user input, errors are inevitable. The difference between a fragile application and a robust one lies in how those errors are handled and logged.

In this guide, I'll share the best practices I use when building scalable Shopify apps and custom web solutions for clients.

Why Error Handling Matters

Effective error handling isn't just about preventing crashes; it's about User Experience (UX) and Security.

1. UX Protection: A user should never see a raw stack trace. Instead, they should see a friendly message explaining that something went wrong, while the system quietly alerts the developers.
2. Security: Stack traces can reveal sensitive information about your server structure, database versions, or file paths. Hiding these is a security imperative.
3. Maintainability: Proper handling allows your code to fail gracefully and recover, or at least exit cleanly, without corrupting data.

Best Practices for Error Handling

1. Fail Gracefully, Not Silently

Never swallow errors with an empty catch block. If you can't recover from an error, rethrow it or log it explicitly.

Bad:

try {
  saveToDatabase(data);
} catch (e) {
  // Do nothing
}

Good:

try {
  await saveToDatabase(data);
} catch (error) {
  logger.error('Database save failed', { error, data });
  throw new DatabaseError('Unable to save record');
}

2. Use Custom Error Classes

In languages like TypeScript/JavaScript or Python, creating custom error classes helps you identify what went wrong. For a Shopify app, you might have ShopifyAPIError, PaymentGatewayError, or ValidationError. This allows you to handle specific scenarios differently.

3. Validate Input Early

The best error handling is prevention. Validate user inputs at the API boundary using libraries like Zod (for TS) or Pydantic (for Python). Rejecting invalid data immediately saves processing time and reduces the complexity of deep logic errors.

Mastering Logging

Logging is your eyes and ears when the application is running in production. Without logs, you are debugging in the dark.

1. Use Structured Logging

Gone are the days of console.log('Error: ' + err). Modern observability platforms (like Datadog, CloudWatch, or Sentry) thrive on structured logging—usually in JSON format.

Why? You can query structured logs. You can ask, "Show me all errors where paymentMethod was stripe and statusCode was 500."

{
  "level": "error",
  "message": "Payment processing failed",
  "context": {
    "userId": "12345",
    "cartId": "abc-987",
    "error": "Insufficient funds"
  },
  "timestamp": "2023-10-27T10:00:00Z"
}

2. Use Appropriate Log Levels

• DEBUG: Detailed information for flow tracing. (Disable in production unless necessary).
• INFO: High-level events (e.g., "User logged in", "Job started").
• WARN: Something unexpected happened, but the app can continue (e.g., "API rate limit approaching").
• ERROR: Operation failed. Immediate attention might be needed.
• FATAL: The application crashed.

3. Include Context, Not Just Messages

Logging "Database error" is useless. Logging "Database error while updating Order #1024 for Shop 'my-store.myshopify.com'" provides immediate context. Always attach relevant metadata like Request IDs, User IDs, or Shop domains.

Tools I Recommend

• Sentry: Excellent for error tracking and performance monitoring. It captures stack traces and breadcrumbs automatically.
• Winston / Pino (Node.js): Great libraries for structured logging.
• CloudWatch / Datadog: For aggregating logs from serverless functions or containers.

Conclusion

Building resilient systems is a core part of professional software engineering. By implementing structured logging and graceful error handling, you reduce downtime and make your own life easier when things inevitably go wrong. Start treating your logs as a first-class feature of your application today.