Project

Seaway

Seaway is a full-stack architecture project designed to demonstrate modern software engineering practices including clean architecture, event-driven systems and production-ready APIs. The platform combines a scalable Java backend with a modern React frontend and production-oriented deployment patterns.

System architecture

Seaway is designed around a layered architecture inspired by hexagonal architecture principles. The system clearly separates the domain, application logic and infrastructure to maintain explicit boundaries and long-term maintainability.

Domain layer

Contains business entities, domain logic and domain invariants. The domain remains isolated from frameworks and infrastructure dependencies.

Application layer

Implements use cases through command and query handlers. This layer orchestrates domain logic without containing business rules.

Infrastructure layer

Adapters for persistence, messaging and external services including PostgreSQL repositories and Kafka producers/consumers.

API layer

REST controllers exposing validated endpoints with standardized error handling and secure filtering.

Frontend interface

The user interface is implemented with React and Tailwind CSS, providing a lightweight client for interacting with the API. The frontend focuses on clear component boundaries and maintainable UI architecture.

React component architecture
Tailwind CSS for design system consistency
API integration with backend services

System architecture overview

flowchart TD Browser[Client Browser] Frontend[React Frontend] Proxy[Nginx Reverse Proxy] API[Spring Boot API] Kafka[(Kafka)] DB[(PostgreSQL)] Producer[Event Producer] Consumer[Event Consumer] Browser --> Frontend Frontend --> Proxy Proxy --> API API --> DB API --> Producer Producer --> Kafka Kafka --> Consumer Consumer --> DB

Hexagonal architecture

flowchart LR User[API Controller] App[Application Layer] Domain[Domain Layer] Infra[Infrastructure] User --> App App --> Domain Domain --> Infra

Event-driven workflows

The platform uses Kafka to orchestrate asynchronous workflows between system components. Events allow services to remain loosely coupled while ensuring scalability and resilience.

Event publishing

Domain events are published when significant state changes occur, allowing other services to react asynchronously.

Retry strategies

Failed events are retried with backoff strategies before eventually being redirected to dead-letter topics for inspection.

Idempotent consumers

Consumers are designed to safely process events multiple times to ensure system consistency in distributed environments.

Event processing flow

Technical highlights

Hexagonal architecture

Clear separation between domain, application and infrastructure to maintain long-term maintainability and testability.

CQRS design

Separation of commands and queries allowing independent evolution of read models and write operations.

Event-driven workflows

Kafka-based messaging enabling loosely coupled services and resilient distributed processing.

Security practices

DTO validation using Bean Validation
Centralized error handling
Secure pagination and filtering
Secrets externalized via environment variables
OWASP-aware API design

Docker container hardening
Non-root container execution
Read-only filesystem
Reverse proxy with Nginx
Infrastructure-level rate limiting

Architecture

Hexagonal architecture
CQRS pattern
Kafka event processing
PostgreSQL

Stack

Java 21
Spring Boot
Kafka
PostgreSQL
React
Tailwind CSS
Docker
Nginx