Skip to main content
Intent Architect is a non-prescriptive, integrated architecture-design platform that combines the power of visual modeling, code management, and pattern reuse to help software development teams build enterprise-grade, scalable applications at lightning speed.

The Problem Intent Architect Solves

Modern software development faces several challenges:
  • Repetitive boilerplate code that takes time to write and maintain
  • Inconsistencies across the codebase as teams grow
  • Technical debt accumulating from copy-paste coding
  • Synchronization issues between documentation, models, and code
  • Knowledge silos where patterns exist only in senior developers’ minds
  • Slow onboarding for new team members learning the codebase
Intent Architect addresses these challenges through model-driven development combined with intelligent code generation.

How Intent Architect Works

Intent Architect uses a three-phase approach:
1

Visual Modeling

Design your application using visual designers:
  • Domain Designer: Model your domain entities, relationships, and aggregates
  • Services Designer: Design your API contracts, commands, queries, and DTOs
  • Eventing Designer: Model event-driven integrations
  • Database Designer: Design database schemas and stored procedures
2

Pattern Application

Install modules that contain reusable patterns:
  • Each module provides templates for generating specific code artifacts
  • Modules understand your models and generate appropriate code
  • Module settings customize the generated code to your needs
3

Code Generation

The Software Factory generates production-ready code:
  • Code is generated from your models using installed modules
  • Generated code follows best practices and your team’s standards
  • Updates flow bidirectionally - changes to models regenerate code
  • Custom code is preserved in protected regions

Key Concepts

Models, Not Scaffolding

Intent Architect doesn’t just scaffold code once. Your models remain the single source of truth throughout the application lifecycle.
When you update your model:
  • Code is regenerated to reflect changes
  • New patterns are automatically applied
  • Relationships are maintained consistently
  • Validation and constraints are enforced
This is fundamentally different from traditional scaffolding, which generates code once and then abandons the model.

Modules: Packaged Patterns

A module is a packaged collection of:
  • Templates: Code generation templates for specific artifacts
  • Factory Extensions: Hooks into the generation pipeline
  • Modelers: Visual designer extensions
  • Metadata: Stereotypes and additional modeling capabilities
<!-- Example: Intent.Application.MediatR module spec -->
<package>
  <id>Intent.Application.MediatR</id>
  <version>4.5.4</version>
  <summary>Provides the MediatR middleware</summary>
  <templates>
    <template id="Intent.Application.MediatR.CommandHandler">
      <role>Application.Command.Handler</role>
    </template>
    <template id="Intent.Application.MediatR.QueryHandler">
      <role>Application.Query.Handler</role>
    </template>
  </templates>
  <dependencies>
    <dependency id="Intent.Common.CSharp" version="3.9.4" />
    <dependency id="Intent.Modelers.Services.CQRS" version="4.1.1" />
  </dependencies>
</package>

The Software Factory

The Software Factory is Intent Architect’s code generation engine. It:
  1. Reads your models from visual designers
  2. Loads installed modules and their templates
  3. Executes templates against your models
  4. Manages generated files and preserves custom code
  5. Integrates with your version control system

Code Management

Intent Architect uses Roslyn Weaver for intelligent code management:
  • Generated regions: Completely managed by Intent Architect
  • Protected regions: For your custom code that won’t be overwritten
  • Partial classes: Extend generated classes without modification
  • Extension methods: Add functionality without touching generated code
// Generated by Intent Architect
public partial class Customer
{
    public Guid Id { get; set; }
    
    public string Name { get; set; }
    
    public string Email { get; set; }
}

// Your custom code in a separate file
public partial class Customer
{
    public string GetDisplayName()
    {
        return $"{Name} ({Email})";
    }
}

Architecture Patterns Supported

Intent Architect .NET Modules support modern architectural patterns:

Clean Architecture

Domain Layer

  • Entities
  • Value Objects
  • Domain Events
  • Domain Services
  • Aggregates

Application Layer

  • Use Cases (Commands/Queries)
  • Handlers
  • DTOs
  • Validation
  • Interfaces

Infrastructure Layer

  • Database Context
  • Repositories
  • External Service Clients
  • Message Publishers
  • File Storage

Presentation Layer

  • Controllers
  • GraphQL Resolvers
  • Azure Functions
  • Blazor Components

CQRS (Command Query Responsibility Segregation)

Using modules like Intent.Application.MediatR:
// Command - represents an action
public class CreateOrderCommand : IRequest<Guid>
{
    public Guid CustomerId { get; set; }
    public List<OrderItemDto> Items { get; set; }
}

// Command Handler - executes the action
public class CreateOrderCommandHandler : IRequestHandler<CreateOrderCommand, Guid>
{
    private readonly IRepository<Order> _orderRepository;
    
    public async Task<Guid> Handle(CreateOrderCommand request, CancellationToken cancellationToken)
    {
        // Business logic here
    }
}

// Query - retrieves data
public class GetOrderByIdQuery : IRequest<OrderDto>
{
    public Guid OrderId { get; set; }
}

// Query Handler - retrieves the data
public class GetOrderByIdQueryHandler : IRequestHandler<GetOrderByIdQuery, OrderDto>
{
    // Query logic here
}

Domain-Driven Design (DDD)

The Domain Designer supports DDD concepts:
  • Entities with identity
  • Value Objects without identity
  • Aggregates as consistency boundaries
  • Domain Events for communication
  • Domain Services for complex operations
  • Repositories for aggregate persistence

Event-Driven Architecture

Using eventing modules for asynchronous communication:
  • Message Publishing: Intent.Eventing.MassTransit, Intent.Eventing.AzureServiceBus
  • Message Handling: Automatic subscriber generation
  • Saga Orchestration: Long-running business processes
  • Outbox Pattern: Reliable message delivery

Benefits

Accelerated Development

Generate 60-80% of your codebase automatically, focusing on business logic instead of infrastructure

Consistency

Ensure consistent patterns, naming conventions, and best practices across your entire codebase

Maintainability

Update patterns once in modules, regenerate code everywhere. Models stay synchronized with code

Quality

Generated code follows best practices, includes proper error handling, and is fully tested

Documentation

Models serve as living documentation that’s always in sync with your implementation

Onboarding

New team members understand the architecture through visual models and consistent patterns

What Intent Architect Is Not

Intent Architect is not a low-code or no-code platform. You still write code, but you write the interesting parts - the business logic that makes your application unique.
  • Not a black box: All generated code is visible, readable, and maintainable
  • Not prescriptive: Choose your architecture, patterns, and technologies
  • Not a framework: Uses standard .NET libraries and frameworks
  • Not a vendor lock-in: Generated code has no runtime dependency on Intent Architect

Integration with Development Workflow

Intent Architect integrates seamlessly with your existing tools:
  • Version Control: Generated code commits to Git like any other code
  • Visual Studio / Rider: Edit generated and custom code side-by-side
  • CI/CD: Build pipelines work unchanged
  • Team Collaboration: Models can be shared and merged
  • Code Reviews: Review generated code changes in pull requests

Real-World Usage

Intent Architect is used by teams building:
  • Enterprise web applications
  • Microservices architectures
  • Event-driven systems
  • Serverless applications
  • Mobile backends
  • IoT platforms
  • Financial services applications
  • Healthcare systems

Next Steps

Ready to try Intent Architect?

Install Intent Architect

Download and set up Intent Architect on your machine

Build Your First App

Follow the quickstart to create a working application in minutes

Learn More

Build docs developers (and LLMs) love