Isolate your business logic

Software engineering is full of discussions around principles like Hexagonal Architecture, Domain-Driven Design (DDD), and Clean Code. One common theme among these approaches is isolating business logic in a central place within your application. For a monolithic application, this means having a well-defined, single location. In a microservices architecture or modular monolith, it means having distinct business logic layers for each service or module.

Benefits of Isolating Business Logic

• Decoupling from Technical Layers

Keeping core business logic separate from technical layers (such as HTTP frameworks, databases, or task queues) makes your system more flexible. Changing the database or swapping out a framework won’t directly affect your core logic.

• Ease of Testing

With business logic isolated, it’s easier to test independently. You can inject fake dependencies for technical layers, simplifying your tests.

• Cleaner Code

The business logic is free from external product requirements or quirks of third-party APIs. If a third-party API has a terrible design, it can be transformed into a cleaner, more consistent structure before reaching the core logic.

Principles to Follow

To achieve this isolation, follow these core rules:

1. Avoid External Dependencies

Business logic should never import or use symbols (functions, classes, types, etc.) from outside its own directory — with the exception of trusted external libraries. It should not depend on any other part of the internal codebase.

2. Use Dependency Injection

Interactions with the outside world should be handled via dependency injection. The business logic layer receives what it needs from outside, allowing it to remain focused on core functionality.

3. Consistent Type Boundaries

Business logic should only expose public functions with parameters defined in its own types. This means that external layers must convert their data types to match those used by the business logic, ensuring a consistent and controlled interaction.

Following these principles results in maintainable and robust software. Enforcing these rules through CI checks will help ensure the consistency of your architecture as your application evolves.