Bulletproof Error Handling in Enterprise TypeScript Apps: A Step-by-Step Guide

Learn how to implement robust error handling strategies in your TypeScript applications using Express.js and Sentry for logging, monitoring, and delivering exceptional user experiences.

🚨 Mastering Error Handling in Enterprise-Level TypeScript Apps: A Comprehensive Guide 🔍



Error handling is a crucial aspect of building robust and reliable software applications. In an enterprise-level production environment, proper error handling strategies ensure that your application can gracefully handle and recover from errors, provide meaningful feedback to users, and maintain a stable and secure system. In this blog post, we’ll explore best practices and techniques for error handling in TypeScript applications, with a focus on using Express.js and Sentry for logging and monitoring.

📝 Logging and Monitoring

The first step in effective error handling is to implement comprehensive logging and monitoring. Logging helps you capture and record errors, along with relevant contextual information, for later analysis and debugging. Monitoring, on the other hand, allows you to detect and alert on critical errors or anomalies in real-time.

When logging errors, it’s important to include sufficient details such as:

  • Error message
  • Stack trace
  • Additional metadata that can aid in troubleshooting

A centralized logging system or service, such as Sentry, can greatly simplify the process of collecting and aggregating logs from different parts of your application.

Here’s an example of how you can integrate Sentry into your TypeScript application using Express.js:

import express from "express";
import * as Sentry from "@sentry/node";
import * as Tracing from "@sentry/tracing";

const app = express();

  integrations: [
    new Sentry.Integrations.Http({ tracing: true }),
    new Tracing.Integrations.Express({ app }),
  tracesSampleRate: 1.0,


// Your application routes and middleware


In this example, we initialize Sentry with the appropriate configuration, including the DSN (Data Source Name) and any necessary integrations. We then add Sentry’s request handler and tracing handler middleware to capture errors and performance traces. Finally, we add Sentry’s error handler middleware to handle any uncaught exceptions or unhandled rejections.

🚀 Error Propagation and Handling

When an error occurs, it’s important to propagate it up the call stack until it reaches a level where it can be appropriately handled. This allows for centralized error handling logic and prevents silent failures or swallowed errors.

In TypeScript, you can use a combination of try-catch blocks and error handling middleware to achieve this. Here’s an example of how you can structure your error handling:

import { Request, Response, NextFunction } from "express";

class CustomError extends Error {
  constructor(message: string, public statusCode: number, public cause?: unknown) {

async function getUsers(req: Request, res: Response, next: NextFunction) {
  try {
    const users = await userService.getAll();
  } catch (error) {
    next(new CustomError("Failed to retrieve users", 500, error));

function errorHandler(err: Error, req: Request, res: Response, next: NextFunction) {
  if (err instanceof CustomError) {
    res.status(err.statusCode).json({ error: err.message });
  } else {
    console.error("Unhandled error:", err);
    res.status(500).json({ error: "Internal Server Error" });

app.get("/users", getUsers);

In this example, we define a custom error class CustomError that extends the built-in Error class. It includes additional properties such as statusCode and cause to provide more context about the error.

Inside the getUsers route handler, we wrap the logic in a try-catch block. If an error occurs, we catch it and pass it to the next function, creating a new instance of CustomError with a specific error message and status code. We also include the original error as the cause property.

The errorHandler middleware function is responsible for handling errors that are passed to it. If the error is an instance of CustomError, we send a response with the corresponding status code and error message. If it’s an unhandled error, we log it and send a generic “Internal Server Error” response to the client.

By propagating errors to a centralized error handler, we can ensure consistent error handling throughout the application and avoid duplicating error handling logic in multiple places.

📏 Consistent Error Format

To maintain consistency and ease of debugging, it’s recommended to define a consistent error format or structure across your application. This can be achieved by creating a custom error class or interface that includes relevant details such as:

  • Unique error code
  • Error message
  • Additional metadata

Here’s an example of a custom error interface:

interface CustomError {
  code: string;
  message: string;
  statusCode?: number;
  cause?: unknown;
  // Additional properties as needed

By using a consistent error format, you can standardize error handling and provide type safety throughout your application.

🎯 Differentiate Between Expected and Unexpected Errors

It’s important to distinguish between expected errors (e.g., validation errors, resource not found) and unexpected errors (e.g., database connection failure, internal server error). Expected errors should be handled gracefully by returning meaningful error responses to the client, while unexpected errors should be logged, alerted on, and returned as generic error messages to avoid exposing sensitive information.

Here’s an example of handling expected and unexpected errors:

async function createUser(req: Request, res: Response, next: NextFunction) {
  try {
    const { name, email } = req.body;

    if (!name || !email) {
      throw new CustomError("Invalid request payload", 400);

    const user = await userService.create({ name, email });
  } catch (error) {
    if (error instanceof CustomError) {
    } else {
      next(new CustomError("Internal Server Error", 500));

In this example, we first check for expected errors, such as missing required fields in the request payload. If an expected error occurs, we throw a CustomError with an appropriate error message and status code.

If an unexpected error occurs (e.g., an error thrown by the userService.create method), we capture the error using Sentry and pass a generic “Internal Server Error” to the error handling middleware.

🔒 Avoid Revealing Sensitive Information

When handling errors, it’s crucial to avoid exposing sensitive information, such as:

  • Database connection strings
  • API keys
  • User data

Always sanitize or mask sensitive data before logging or sending error responses to the client.

🧪 Testing and Error Scenarios

To ensure the reliability and correctness of your error handling logic, it’s essential to write comprehensive unit tests and integration tests that cover various error scenarios. Simulate different error conditions and verify that your application handles them as expected.

Additionally, perform load testing and stress testing to identify potential error-prone areas under high traffic or load. This helps you proactively detect and fix issues before they impact your users in production.

🎉 Conclusion

Implementing robust error handling is a vital part of building enterprise-level TypeScript applications. By following best practices such as logging and monitoring, consistent error formatting, differentiation between expected and unexpected errors, and comprehensive testing, you can create a reliable and maintainable system.

Leveraging tools like Express.js for handling HTTP requests and Sentry for error tracking and monitoring can greatly simplify the process of implementing effective error handling strategies.

Remember, the goal of error handling is not only to gracefully handle and recover from errors but also to provide a smooth and intuitive user experience. By investing in proper error handling techniques, you can enhance the stability, security, and user satisfaction of your application.

Happy error handling! 😄