Pipeline Pattern: A Simple Real-World Example

Combining several processes for a single request into a single, huge function may soon make the code difficult to comprehend and maintain.

A straightforward solution to this issue is the Pipeline Pattern. It divides the process into smaller parts, each of which is in charge of a certain task.

An online payment API is a suitable real-world example.

Imagine a customer makes a payment. Before the payment can be completed, the application may need to go through several checks and actions:

1. Validate the payment request.
2. Check if the customer is allowed to make the payment.
3. Check the account balance.
4. Run fraud checks.
5. Process the payment.
6. Save the transaction details.
7. Send a notification to the customer.

Instead of putting all this logic into one controller or service method, we can create a pipeline and give each step its own responsibility.

Creating the Pipeline Step Interface

public interface IPipelineStep<T>
{
    int Order { get; }
    Task<T> ExecuteAsync(T context);
}

Each step implements the interface:

public class ValidatePaymentStep : IPipelineStep<PaymentContext>
{
    public int Order => 1;

    public Task<PaymentContext> ExecuteAsync(PaymentContext context)
    {
        Console.WriteLine("1. Validating payment...");

        if (string.IsNullOrWhiteSpace(context.CustomerId))
            throw new ArgumentException("CustomerId is required.");

        if (context.Amount <= 0)
            throw new ArgumentException("Payment amount must be greater than zero.");

        if (string.IsNullOrWhiteSpace(context.Currency))
            throw new ArgumentException("Currency is required.");

        return Task.FromResult(context);
    }
}

The pipeline executes these steps in sequence:

Payment Request
      |
      v
[Validate]
      |
      v
[Authorization]
      |
      v
[Fraud Check]
      |
      v
[Process Payment]
      |
      v
[Save Transaction]
      |
      v
[Send Notification]

This makes the code easier to understand, test, and maintain. It also makes it easier to add, remove, or change individual steps without affecting the rest of the process.

This approach works especially well in .NET because dependency injection makes it easy to register and connect different pipeline steps.

One of the main benefits is separation of concerns. Each step has a clear responsibility. For example, if we later need to add a customer credit-limit check, we can simply add a new pipeline step without changing the existing payment logic.

The Pipeline Pattern can be useful in many scenarios, such as payment processing, order processing, message processing, validation workflows, and API request processing.

Instead of creating one large service that handles everything, we can break the process into small and focused steps:

Request → Validate → Authorize → Process → Save → Notify

This keeps the code simple and makes the application easier to test, change, and maintain.

5 Essential Things to Consider in a Sequential Pipeline

Enforce Sequential Execution

Use foreach + await so the next step starts only after the current step completes.

foreach (var step in steps.OrderBy(x => x.Order))
{
    context = await step.ExecuteAsync(context);
}

Define Explicit Step Ordering

Don’t depend only on DI registration order. Give each step an explicit Order so the business flow is clear and predictable.

Understand Step Dependencies

If Step 2 depends on the result of Step 1, the pipeline must remain sequential. Avoid Task.WhenAll for dependent operations.

Handle Failures and Side Effects

Decide what happens when a step fails. For database updates, payments, or messaging, consider retry, rollback/compensation, and idempotency.

Keep Steps Small and Testable

Each step should have one responsibility. This makes individual steps easier to test, replace, and extend without changing the entire pipeline.

Note

The most important design decision in a pipeline is not how many steps you have—it is understanding the dependency between those steps. When one step depends on the previous step, use explicit ordering and sequential await execution. Parallel execution should only be introduced when the operations are genuinely independent*.*

Conclusion

The Pipeline Pattern is a simple and clean way to break a complex business process into smaller steps. Each step focuses on one specific task, which makes the code easier to understand and maintain.

When one step depends on the previous step, we can run the pipeline sequentially using proper ordering and await. This helps ensure that each step finishes before the next one starts.

As the application grows, we can easily add or change individual steps without affecting the entire workflow. We also need to think about error handling, dependencies, side effects, and testing when designing the pipeline.

With .NET and dependency injection, building this type of pipeline becomes straightforward, flexible, and easy to extend as business requirements change.

Happy Coding!

Best ASP.NET Core 10.0 Hosting

The feature and reliability are the most important things when choosing a good ASP.NET Core 10.0 hosting. HostForLIFE is the leading provider of Windows hosting and affordable ASP.NET Core , their servers are optimized for PHP web applications such as the latest ASP.NET Core 10.0 version. The performance and the uptime of the ASP.NET Core  hosting service are excellent, and the features of the web hosting plan are even greater than what many hosting providers ask you to pay for. At HostForLIFE.eu, customers can also experience fast ASP.NET Core hosting. The company invested a lot of money to ensure the best and fastest performance of the datacenters, servers, network and other facilities. Its data centers are equipped with top equipment like cooling system, fire detection, high-speed Internet connection, and so on. That is why HostForLIFE.eu guarantees 99.9% uptime for ASP.NET Core . And the engineers do regular maintenance and monitoring works to assure its ASP.NET Core  hosting are security and always up.