The Modular Monolith: The Architect's Sweet Spot for 2026 Engineering Teams

src/
├── identity/
│   ├── internal/          ← ONLY importable by identity/ and sub-packages
│   │   ├── repository.go  
│   │   └── hasher.go      
│   ├── api.go             ← PUBLIC interface for identity module
│   └── user.go
├── orders/
│   ├── internal/          ← ONLY importable by orders/ and sub-packages
│   │   └── repository.go
│   └── api.go
└── main.go

// This import FAILS at compile time:
import "github.com/myapp/identity/internal/repository" // from orders/
// Error: use of internal package not allowed

@AnalyzeClasses(packages = "com.myapp")
class ArchitectureTest {
    
    @ArchTest
    static final ArchRule modules_must_not_access_private_internals =
        noClasses()
            .that().resideInAPackage("..orders..")
            .should().accessClassesThat()
            .resideInAPackage("..identity.internal..");
    
    @ArchTest
    static final ArchRule payments_must_not_depend_on_orders_internals =
        noClasses()
            .that().resideInAPackage("..payments..")
            .should().dependOnClassesThat()
            .resideInAPackage("..orders.internal..");
}
// If an Orders class imports from Identity's internal package: BUILD FAILS!

// module-info.java for identity module
module com.myapp.identity {
    exports com.myapp.identity.api;         // Public API — others can import this
    // com.myapp.identity.internal is NOT exported — invisible to other modules
    
    requires com.myapp.shared;              // Can import from shared module
}

// module-info.java for orders module
module com.myapp.orders {
    exports com.myapp.orders.api;
    
    requires com.myapp.identity;            // Can use identity's exported API only
    // com.myapp.identity.internal is inaccessible — JVM enforces this
}

// identity/api/IdentityModule.java — the module's public surface
public interface IdentityModule {
    UserDto findUser(UserId id);
    boolean hasPermission(UserId userId, Permission permission);
    UserSummary getUserSummary(UserId id);
    // Nothing about passwords, tokens, sessions — those are internal
}

// orders/service/OrderService.java — uses only the public facade
public class OrderService {
    private final IdentityModule identity; // ← depends on interface, not internals
    
    public Order createOrder(UserId userId, List<OrderItem> items) {
        if (!identity.hasPermission(userId, Permission.PLACE_ORDER)) {
            throw new InsufficientPermissionException();
        }
        UserSummary user = identity.getUserSummary(userId);
        return Order.create(user, items);
    }
}

// Orders module calls Inventory module synchronously — needs to know stock NOW:
boolean available = inventoryModule.isAvailable(productId, quantity);
if (!available) throw new OutOfStockException();

// Orders module publishes event — Notifications module reacts independently:
public class OrderService {
    private final EventBus eventBus;
    
    public Order placeOrder(...) {
        Order order = createOrderInternal(...);
        // Notify: order placed. Notifications module will send email
        // Orders module doesn't know or care WHO listens:
        eventBus.publish(new OrderPlacedEvent(order.id(), order.userId(), order.total()));
        return order;
    }
}

// Notifications module — subscribes to OrderPlacedEvent:
@EventListener
public class OrderConfirmationEmailHandler {
    public void handle(OrderPlacedEvent event) {
        emailService.sendOrderConfirmation(event.userId(), event.orderId());
    }
}

Shared table names (minimal isolation)    → Use module prefix: id_users, order_items, inv_stock
Separate database schemas (better)        → identity schema, orders schema, inventory schema
Separate DB users with permissions        → Each module's DB user can only access its schema
Separate physical databases (microservice)→ Full isolation, but now you need distributed transactions

-- PostgreSQL schema-per-module approach:
CREATE SCHEMA identity;
CREATE SCHEMA orders;
CREATE SCHEMA inventory;

CREATE TABLE identity.users (...);          -- Orders cannot query this directly
CREATE TABLE orders.order_items (...);      -- Identity cannot query this directly
CREATE TABLE inventory.stock_levels (...);  -- Orders cannot query this directly

-- Database user for orders module:
CREATE USER orders_service ...;
GRANT ALL ON SCHEMA orders TO orders_service;
-- orders_service has NO access to identity or inventory schemas!