Clean Architecture, ports & adapters, Domain-Driven Design, CQRS

A Python-based project demonstrating the principles of Hexagonal Architecture (Ports and Adapters) and Domain-Driven Design (DDD). This repository showcases how to design clean, maintainable, and scalable applications by emphasizing domain logic, decoupling dependencies, and enabling testability.

Generate well architected monorepo libraries based on Effect and Nx monorepos. Based on design architectures like Repository, Infrastructure Domain Driven Design, Contract, Adapter, and Feature library patterns.

A reference architecture using ports and adapters, domain-driven design (DDD), command query responsibility segregation (CQRS) and event sourcing (ES).

A production-ready Spring Boot multi-module project template built with Kotlin. It follows Hexagonal Architecture (Ports and Adapters) principles and Domain-Driven Design (DDD) patterns to ensure maintainability, testability, and scalability. The project includes a complete OpenTelemetry-based observability stack for unified monitoring, distributed

🏗️ Complete Symfony Maker bundle for generating Hexagonal Architecture (Ports & Adapters) with CQRS, pure domain entities, and YAML mapping

A demo Spring Boot application using Domain Driven Design & Hexagonal Architecture with REST API and GraphQL API adapters

HexaGlue is a compile-time architecture engine that analyzes your domain, builds a semantic graph, and generates infrastructure adapters with full architectural awareness - no boilerplate, no guessing.

Real-world Java Spring Boot project using Hexagonal Architecture (Ports & Adapters), DDD-style domain modeling and clean separation of business logic and infrastructure.

A production-ready Go project template using Hexagonal Architecture (Ports & Adapters). Use this repo to kick-start new Go services without spending time on project structure, layering, or wiring—focus on your domain and features.

DDD + Clean Architecture template for Nuxt 4 — Bounded Contexts, CQRS, Saga, Ports & Adapters, Domain Events, Onion layers

Android application that portrays in memory-network caching technique, using a repository class to provide a clean app architecture, and illustrating the use of the WorkManger API to run tasks on the background, in order to ensure users limited resources(space, battery etc) are utilized efficiently. To relate the techniques above, this an image gallery app that displays images of GitHub users obtained from https://api.github.com/users. The JSON objects are fetched from the API, and parsed as Kotlin objects with the use of Retrofit and MOSHI library, the network data is then cached into a structured in-memory database, and the app loads the cached data into a domain class where the repository, view and view-models can make use of it. The users' avatars are loaded into an image view using Glide library, and the images are shown on the app through a ListView Adapter. An onClick listener is implemented on the RecyclerView to navigate to a detail fragment where the user avatar and login name is then displayed.

Prototype for a Flask web application applying Hexagonal Architecture principles, ensuring a clear separation between domain logic and external adapters to achieve flexibility, scalability, maintainability, and testability.

The Hexagonal Architecture (Ports and Adapters) for the Electronics Service Spring Boot project. At its core, the Application Layer (Core Domain) encapsulates the business logic for managing ElectronicsCategory

Flexible domain adaptation architecture for applying breakthrough methodologies across different fields. Enables rapid knowledge transfer and cross-pollination of ideas.

Demo project showcasing a Hexagonal Architecture (aka Ports and Adapters) and Domain Driven Design.

Abordagem arquitetural dos princípios do Domain-Driven Design (DDD) com o padrão arquitetural do Hexagonal Architecture (Ports and Adapters).

A hotel reservation and payment management system built with Go, demonstrating Domain-Driven Design (DDD) and Hexagonal Architecture (Ports & Adapters) patterns.

A RESTful API built with Go implementing Hexagonal Architecture (Ports and Adapters) pattern with MongoDB integration. Features clean architecture separation with domain-driven design principles. 🏗️ **Architecture**: Hexagonal Architecture (Clean Architecture) 🔧 **Language**: Go 1.24+ 🗄️ **Database**: MongoDB 🌐 **Framework**: Fiber v2

Users and Car Sales Management System built with .NET 8, following Hexagonal Architecture (Ports & Adapters). Strong domain isolation with decoupled infrastructure using EF Core and PostgreSQL, and a RESTful Web API adapter.

A clean, domain-driven order management microservice implemented using Hexagonal Architecture (Ports & Adapters) with interchangeable persistence adapters (JPA & MongoDB) and MySQL integration. Demonstrates separation of concerns, testability, and adaptability to infrastructure changes.

This project is a exemple of a backend service developed using Spring Boot, following the principles of Domain-Driven Design (DDD) and Port-Adapter Architecture.

A practical Clean Architecture + Domain-Driven Design (DDD) starter with Axum 0.8 (Hyper 1.x, Tower). The goal is to keep Domain and Use Cases independent from HTTP and DB via the Ports & Adapters pattern.

A production-ready NestJS boilerplate with Domain-Driven Design (DDD), Hexagonal Architecture (Ports & Adapters), Prisma ORM, and Docker support — built for teams who care about scalability, maintainability, and code quality.

This application turns your Linux laptop into a Wi-Fi repeater/hotspot using a single Wi-Fi adapter. It follows Clean Architecture principles with domain, use-case, infrastructure, and UI layers.

A full-stack Order Management System demonstrating Domain-Driven Design (DDD) and Hexagonal Architecture (Ports & Adapters) with an event-driven Spring Boot backend and a modular Angular Nx frontend sharing centralized OpenAPI contracts.

bisslog-aws-py is a lightweight Python library for integrating AWS services while preserving hexagonal architecture. It helps decouple domain logic from infrastructure by providing clean adapters for components like S3, SQS, Lambda, and more.

A modular NestJS API demonstrating clean architecture and engineering rigor. Implemented a replaceable in-memory database with idempotent seeders, a well-typed Users domain (DTOs, entities, controller/service separation), and comprehensive unit + e2e tests to ensure maintainability and safe adapter swaps.

This Spring Boot project showcases advanced software engineering with DDD, CQRS, Hexagonal Architecture, and TDD. Business logic is isolated via rich entities, domain events, and ports/adapters. It includes validation, testing, error handling, observability, Docker/PostgreSQL portability, Swagger docs, and performance optimizations.

A lightweight Todo API in NestJS illustrating Clean Architecture: domain entities + value objects in a core layer, use-case services as the application ring, and adapters—REST controllers & Prisma persistence—on the outer ring. A concise, self-contained demo for Clean-Arch practice.