Skip to content

Architect Quickstart

This quickstart helps architects get oriented with ConnectSoft's architecture, Factory capabilities, and design patterns. It is written for architects, technical leads, and senior engineers responsible for system design and architecture decisions.

As an architect at ConnectSoft, you'll work with the AI Factory to generate services, define bounded contexts, review generated code, and ensure architectural consistency across projects.

Your Goals as an Architect Here

  • Design Bounded Contexts - Define domain boundaries and service boundaries
  • Review Factory Outputs - Ensure generated code meets architectural standards
  • Define Integration Patterns - Establish patterns for service-to-service communication
  • Maintain Consistency - Ensure all services follow ConnectSoft patterns
  • Make Architecture Decisions - Document decisions using ADRs

Top 5 Docs to Read First

  1. Factory Overview - Understand what the Factory is and how it works
  2. Architecture & Engineering Overview - Core architecture principles (AI-First, Modularization, Clean Architecture, Event-Driven, Cloud-Native, Observability)
  3. Agent Microservice Standard Blueprint - Standard structure for generated microservices
  4. Business Models - Understand code ownership, Factory licensing, platform models
  5. Decision Records Process - How to create and manage ADRs/BDRs

Typical Tasks and Where to Start

Design New Bounded Context

Task: Define a new bounded context for a product feature.

Start Here: 1. Review Modularization for bounded context guidance 2. Review Clean Architecture & DDD for domain modeling 3. Define entities, aggregates, and domain events 4. Document in ADR (see Decision Records Process)

Evaluate Factory Outputs

Task: Review code generated by the Factory.

Start Here: 1. Review Agent Microservice Standard Blueprint 2. Check generated code structure matches blueprint 3. Verify domain logic is in correct layers 4. Review ADRs generated by Factory

Define Integration Patterns

Task: Establish patterns for service-to-service communication.

Start Here: 1. Review Event-Driven Mindset for event patterns 2. Review Cloud-Native Mindset for API patterns 3. Define event contracts and API contracts 4. Document in ADR

Approve Factory Run

Task: Approve a Factory run before code is committed.

Start Here: 1. Review Getting Started with Factory for run process 2. Check generated ADRs for architectural decisions 3. Verify bounded context boundaries are correct 4. Review integration points and event contracts

Checklists

Checklist: Defining a New Service

  • Bounded Context Defined
  • Domain boundaries clear
  • Entities and aggregates identified

  • Relationships with other contexts defined

  • Domain Model Documented

  • Entities and aggregates documented
  • Domain events identified

  • Business rules captured

  • Integration Points Identified

  • APIs defined (REST/gRPC)
  • Events defined (domain events, integration events)

  • External integrations identified

  • Non-Functional Requirements

  • Multi-tenant requirements
  • Performance requirements

  • Security requirements

  • ADR Created

  • Architecture decision documented
  • Alternatives considered
  • Consequences documented

Checklist: Approving a Factory Run

  • Structure Review
  • Project structure matches blueprint
  • Layers are correctly separated

  • Dependencies flow correctly (Domain → Application → Infrastructure)

  • Domain Logic Review

  • Domain logic is in Domain layer
  • Business rules are implemented correctly

  • Domain events are properly defined

  • Integration Review

  • APIs are correctly defined
  • Events are properly structured

  • External integrations are correct

  • Quality Review

  • Tests are present and passing
  • CI/CD pipelines are configured

  • Documentation is complete

  • ADR Review

  • Generated ADRs are reviewed
  • Decisions are appropriate
  • Alternatives were considered