Your First Architecture

In this guide, you'll design your first architecture from start to finish, then analyze it and share it with your team.

Choose Your Starting Point

Approach 1: AI-Assisted Design (Recommended for Beginners)

Architect AI helps you transform natural language into a complete architecture.

Approach 2: Pattern Library

Start with a proven architectural pattern and customize it to your needs.

Approach 3: Code Import

Import existing Terraform/CloudFormation and let Architecto visualize it.

Let's walk through each approach.

Approach 1: AI-Assisted Design

Step 1: Describe Your Infrastructure

1. From your dashboard, click "Create Architecture" → "Describe with AI"
2. In the dialog, describe your infrastructure in natural language:

E-commerce platform selling handmade goods
- 10,000 concurrent users at peak
- Global audience (US, EU, Asia)
- Real-time inventory tracking
- Payment processing (Stripe)
- Recommendation engine (ML)
- Mobile app + web app

3. Click "Generate" and wait for AI to analyze your request

Step 2: Review Generated Options

Architecto generates 3-5 architecture options. Each shows:

• Topology diagram — Visual representation of components and connections
• Cost estimate — Monthly cost at your target scale
• Complexity rating — Implementation difficulty
• Best for — When to use this approach
• Pros & cons — Trade-offs vs. other options

Review each option and think about:

• Does it match your performance requirements?
• Is the cost acceptable?
• Can your team implement this?
• Are there any missing components?

Step 3: Select Your Architecture

Click "Select" on your preferred option. The topology loads in the visual canvas.

Working with the Canvas

The canvas is where you visually design and edit your architecture.

Canvas Controls

Editing Nodes

When you select a node (server, database, load balancer, etc.):

1. Properties Panel opens on the right showing:

   • Node Type — What service this is
   • Configuration — Specs (instance size, storage, etc.)
   • Provider — AWS, GCP, Azure, etc.
   • Availability — Single AZ or multi-AZ
   • Scaling — Min/max replicas for horizontal scaling

2. Make changes and see immediate updates in analysis

Connecting Services

Data flows between services via:

• Synchronous — REST API, gRPC (solid lines)
• Asynchronous — Message queues, event streams (dashed lines)
• Database — Read/write operations (dotted lines)

Click the flow to edit:

• Protocol — HTTP, gRPC, TCP, UDP
• Encryption — TLS, KMS keys
• Authentication — API key, OAuth, mTLS
• Rate Limiting — Requests/second
• Retry Policy — Exponential backoff, max retries

Common Architecture Patterns

E-Commerce (Your Example)

Load Balancer
├─ Web Servers (auto-scaled)
├─ API Servers (auto-scaled)
├─ Cache Layer (Redis)
├─ Primary Database (PostgreSQL)
├─ Read Replicas
├─ Object Storage (Images, PDFs)
├─ Message Queue (for async tasks)
├─ ML Service (recommendations)
├─ Search Engine (Elasticsearch)
└─ CDN (for static assets)

Microservices

API Gateway
├─ Auth Service
├─ User Service
├─ Product Service
├─ Order Service
├─ Payment Service
├─ Notification Service
├─ Search Service
└─ Analytics Service

Shared:
- Message Bus (for inter-service communication)
- Distributed Cache
- Logging/Monitoring Stack

Serverless

API Gateway (triggers)
├─ Lambda for Auth
├─ Lambda for API handlers
├─ Lambda for background jobs
├─ DynamoDB
├─ S3 for storage
├─ CloudFront CDN
├─ SQS queues
└─ EventBridge for event routing

Running Analysis

With your architecture designed, analyze it before implementation.

Run Cost Analysis

1. Click "Analyze" → "Cost Estimator"
2. Enter your assumptions:
   • Target Users — 1,000 / 10,000 / 100,000 / 1,000,000
   • Usage Profile — Conservative / Moderate / Aggressive
   • Region — US / EU / Asia-Pacific
3. Architecto calculates:
   • Total Monthly Cost at each scale
   • Cost Breakdown by component
   • Cost Inflection Points — Where cost jumps
   • Recommendations — How to reduce cost

Check Scalability

1. Click "Analyze" → "Scalability Analyzer"
2. Review findings:
   • Bottlenecks — Components that limit throughput
   • Scaling Limits — Maximum users this architecture can support
   • Scaling Strategy — Horizontal vs. vertical recommendations
3. Example: "Database is bottleneck at 50k users. Add read replicas and enable connection pooling."

Review Security

1. Click "Analyze" → "Threat Modeler"
2. See identified threats:
   • STRIDE Analysis — Spoofing, Tampering, Repudiation, Info Disclosure, Denial of Service, Elevation of Privilege
   • Attack Paths — How threats could happen
   • Mitigations — How to prevent each threat
3. Example threats:
   • "Spoofing: Attackers impersonate users. Mitigation: Enable MFA on user accounts."
   • "Tampering: Man-in-middle on API calls. Mitigation: Enforce TLS 1.3 on all endpoints."

Customizing Your Architecture

Add Monitoring & Logging

Every production architecture needs visibility. Add:

1. Monitoring — CloudWatch, Datadog, Prometheus
2. Logging — CloudWatch Logs, ELK Stack, Splunk
3. Tracing — X-Ray, Jaeger (for microservices)
4. Alerting — PagerDuty, Opsgenie (for on-call teams)

Add Disaster Recovery

Plan for failures:

1. Multi-Region Setup — Active/active or active/passive
2. Backup Strategy — Daily automated backups, point-in-time recovery
3. Failover Automation — Route 53 health checks, automatic failover
4. Testing — Chaos engineering to validate resilience

Add Security Layers

Go beyond basic authentication:

1. Network Security — VPCs, Security Groups, NACLs
2. Encryption — At-rest (AWS KMS) and in-transit (TLS)
3. Access Control — IAM policies, RBAC, ABAC
4. DDoS Protection — CloudFront, Shield, WAF

Generating Documentation

Convert your architecture to professional documentation:

Create an RFC

1. Click "Document" → "Create RFC"
2. Architecto auto-fills:
   • Problem Statement — Why we need this
   • Proposed Solution — Your architecture
   • Alternatives Considered — Other options and why we rejected them
   • Cost Analysis — Monthly costs and ROI
   • Security Review — Threats and mitigations
   • Scaling Analysis — How it handles growth
3. Edit sections to refine messaging
4. Share with team for review

Export the Diagram

1. Click "Export"
2. Choose format:
   • PNG/SVG — For slides and documentation
   • PDF — For printing and archival
   • PPT — For presentations with custom branding
3. Customize appearance:
   • Colors for different component types
   • Company logo placement
   • Font and text styling
   • Background and accents
4. Download ready-to-use file

Sharing Your Architecture

Share with Team

1. Click "Share"
2. Generate token link (expires in 7 days by default)
3. Copy and send to team members
4. They view in browser (no account required)
5. They can add comments:
   • Click any component to comment
   • Attach files and screenshots
   • Tag team members with @mentions
   • You get real-time notifications

Collect Feedback

1. Team members add comments
2. You see count on components with feedback
3. Address comments:
   • Update architecture and re-share link
   • Reply to comment thread
   • Mark as resolved
4. Final architecture reflects team input

Next Steps

• Learn About Analysis Modules → Understanding Analysis
• Explore More Features → Features Guide
• Master Best Practices → Architecture Patterns

Tips for Success:

• Start simple, then add complexity
• Review cost and security before implementation
• Get team feedback early in the design
• Document your decisions for future reference