Clean Architecture

Understands clean architecture in Go: separating packages by layers, interface-driven design.

Follows layered Spring project architecture: controllers contain no business logic, services work through interfaces. Understands Dependency Injection via Spring IoC. Doesn't mix JPA entities with REST DTOs.

Understands clean architecture for Node.js: layer separation (controllers, services, repositories). Organizes code by modules.

Follows the project's layered architecture: controllers don't contain business logic, services work through repository interfaces. Understands dependency direction. Doesn't mix infrastructure code with domain code.

Understands layer separation (presentation, business, data). Knows why abstraction is needed. Follows project structure. Separates business logic and infrastructure.

Understands clean architecture in Rust: domain/infrastructure separation, dependency inversion through traits. Organizes modules by layers.

Understands basic architectural concepts of Clean Architecture. Follows team architectural decisions. Understands fundamental patterns.

Understands Clean Architecture principles in the iOS context: separation into Presentation, Domain, and Data layers. Creates simple Use Cases for business logic, separates UI logic from data operations. Follows the dependency rule — inner layers are unaware of outer ones, uses protocols for dependency inversion between iOS application layers.

Follows clean architecture principles in React Native projects — separating UI and logic through custom hooks. Does not place business logic in components. Understands layer dependencies — screens depend on hooks, hooks on services, services on API client. Follows naming conventions.

Understands basic Clean Architecture principles: separation into layers (entities, use cases, interface adapters, frameworks). Knows the dependency rule and dependency inversion. Can document layered application structure.

Applies clean architecture: hexagonal architecture, dependency injection, port/adapter pattern in Go.

Applies Clean Architecture in Java: extracts Use Cases, separates Domain and Infrastructure through Ports & Adapters. Inverts dependencies via Spring interfaces. Writes domain code without Spring/JPA coupling.

Applies clean architecture: hexagonal architecture with NestJS modules, dependency injection, port/adapter pattern. Isolates business logic.

Applies Clean Architecture in PHP: extracts Use Cases, separates Domain and Infrastructure layers. Inverts dependencies through interfaces. Organizes code by features, not by file types. Writes domain code without framework dependency.

Applies Clean Architecture in Python projects. Uses dependency injection. Creates use cases and entities. Separates domain and infrastructure. Tests business logic independently.

Applies clean architecture: hexagonal architecture with Rust traits, port/adapter pattern, domain-driven module organization. Isolates side effects.

Applies Clean Architecture in Flutter/Dart projects with proper separation of presentation, domain, and data layers. Uses BLoC/Riverpod patterns to keep business logic widget-agnostic. Understands trade-offs of layer isolation.

Implements Clean Architecture in iOS projects: Use Cases for business operations, Repository pattern for data source abstraction. Configures dependency injection via protocols, organizes project into SPM modules by layers. Implements mapping between Entity, DTO, and ViewModel models, ensuring Domain layer independence from UIKit/SwiftUI and networking frameworks.

Applies Clean Architecture in React Native — Domain layer (entities, use cases), Data layer (repositories, API), Presentation layer (screens, components). Implements Dependency Inversion through service abstractions. Isolates platform-specific code via adapters for testability.

Applies Clean Architecture when designing components and enforces dependency rules across the team. Reviews code for architectural conformance and participates in discussions about layer boundaries and inversion of control.

Documents Clean Architecture projects: describes purpose of each layer, dependency rules, code examples. Creates architecture decision records explaining Clean Architecture choices. Helps developers understand architectural boundaries.

Designs clean architecture: domain-driven Go packages, Wire for DI, modular structure.

Designs Java applications following Hexagonal Architecture: ports for business logic, adapters for JPA/Kafka/REST. Refactors legacy Spring monolith to clean architecture. Defines anti-corruption layers between bounded contexts.

Designs clean architecture: NestJS modular architecture, domain-driven design, bounded contexts. Defines architectural boundaries.

Designs PHP applications using Clean/Hexagonal Architecture: Ports & Adapters for integrations, Domain Events for bounded context communication. Refactors legacy to clean architecture without stopping development. Defines anti-corruption layers.

Designs Clean Architecture for microservices. Applies Hexagonal Architecture. Creates ports and adapters. Designs domain events. Refactors monolith into clean architecture.

Designs clean architecture for Rust: trait-based abstractions, compile-time dependency injection, modular crate structure. Defines architectural boundaries.

Designs Flutter application architecture with Clean Architecture, establishing clear boundaries between presentation, domain, and data layers. Selects state management patterns (BLoC/Riverpod) and makes ADR decisions for widget-agnostic business logic.

Architects Clean Architecture for complex iOS applications: modular Use Cases with composition, Repository with caching and fallback strategies. Defines module boundaries through SPM with strict dependency control, configures separate module compilation for speedup. Implements CQRS for read/write operation separation, designs Domain Events for inter-module communication.

Architects Clean Architecture for large-scale React Native applications. Defines module boundaries and inter-layer contracts. Implements the Use Case pattern for business logic. Ensures domain layer independence from the React Native framework. Designs a DI container for dependency management.

Designs enterprise system architecture with Clean Architecture and technology-agnostic domain modeling. Defines bounded contexts and system integration patterns. Makes architectural decisions (ADR) and evaluates non-functional requirements at system level.

Designs system architecture with Clean Architecture and enforces dependency rules through architecture tests and automated checks. Establishes ADR processes in the team, ensures proper layer separation, and evaluates non-functional requirements.

Creates comprehensive Clean Architecture documentation for complex systems: mapping between business capabilities and architecture layers, testing strategies per layer, dependency injection configuration. Reviews code for compliance with architectural descriptions.

Defines architectural standards: package organization, dependency rules, architecture reviews.

Defines architectural standards: module structure, dependency rules, ArchUnit tests for architecture control. Balances architecture cleanliness with delivery speed. Conducts architectural reviews.

Defines architectural standards: clean architecture guidelines, NestJS conventions, dependency rules. Conducts architecture reviews.

Defines team architectural standards: module structure, dependency rules between layers, PHPStan rules for architecture enforcement. Conducts architectural reviews. Balances architecture purity with delivery speed.

Defines architecture standards for the organization. Implements architectural fitness functions. Conducts architecture reviews. Standardizes approaches.

Defines architectural standards: clean architecture guidelines, module organization, dependency rules. Conducts architecture reviews.

Defines architectural strategy for Flutter products based on Clean Architecture. Establishes guidelines for presentation/domain/data layer separation and BLoC/Riverpod usage patterns. Conducts architecture reviews ensuring widget-agnostic business logic.

Defines Clean Architecture standards for the iOS team: module templates, dependency rules, and architecture conformance tests. Adapts principles for SwiftUI: Presentation via ViewModels with @Observable, Domain with async/await Use Cases. Implements automatic boilerplate generation via Sourcery, conducts architectural reviews, and trains the team on SOLID principles in Swift.

Defines Clean Architecture standards for mobile projects. Establishes guidelines — module structure, dependency rules, architectural tests (ArchUnit). Reviews architectural boundary compliance. Mentors the team on applying Clean Architecture in the React Native context.

Defines product architectural strategy with Clean Architecture across enterprise systems. Establishes guidelines for bounded contexts, technology-agnostic domain modeling, and integration patterns. Conducts architecture reviews at organizational level.

Defines the product's architectural strategy with Clean Architecture. Establishes architecture guidelines. Conducts architecture reviews.

Standardizes approaches to documenting Clean Architecture in the organization. Creates reference implementations with detailed documentation. Ensures architecture documentation consistency when scaling teams.

Shapes architectural strategy: clean architecture for Go platform, module design governance.

Shapes architectural culture: reference architecture for Java services, domain/application/infrastructure layers. Designs shared kernel between services. Determines when clean architecture is justified.

Shapes architectural strategy: clean architecture principles for Node.js platform, modular design governance, architecture evolution.

Shapes organizational architecture culture. Defines reference architecture for PHP services: Domain Layer, Application Layer, Infrastructure Layer. Designs shared kernel between services. Evaluates when clean architecture is justified and when it's excessive.

Shapes architecture strategy. Evaluates approaches for different contexts. Defines reference architectures. Mentors lead architects.

Shapes architectural strategy: clean architecture principles for Rust platform, crate ecosystem design, architectural governance.

Defines the organization's architectural strategy for Flutter/Dart platforms based on Clean Architecture. Designs reference architectures with presentation/domain/data layer patterns. Establishes architecture governance and cross-team consistency standards.

Develops Clean Architecture strategy for the entire iOS platform: modularization standards, reusable Domain modules across applications. Defines architectural evolution path: gradual legacy code migration, strangler fig strategy for major refactorings. Implements architectural metrics: coupling, cohesion, and instability for codebase health monitoring.

Shapes enterprise Clean Architecture standards for mobile development. Defines reference architecture for React Native applications with clean layers, reusable domain and data layers. Designs architectural fitness functions for automated architectural rule enforcement.

Defines the organization's architectural strategy based on Clean Architecture with enterprise-wide bounded contexts and reference architectures. Establishes architecture governance for technology-agnostic domain modeling and system integration patterns.

Defines the organization's architectural strategy enforcing Clean Architecture principles across all teams. Designs reference architectures with dependency rules and architecture testing frameworks. Establishes governance through ADR processes and review standards.

Shapes corporate standards for documenting architectural patterns, including Clean Architecture. Defines how architecture documentation evolves with the system, ensuring traceability from business requirements to implementation details.