An AWS architecture diagram shows how the services in a cloud system fit together — compute, storage, databases, networking, and the traffic that flows between them. It is the standard artifact for designing a deployment, reviewing it for cost and security, and onboarding engineers onto an existing system.
Diagramming AI turns a plain-English description of your stack into an editable PlantUML AWS diagram in seconds. Describe the services you use and how requests flow through them, and the AI generates ready-to-edit diagram code using the official AWS icon set, which you can then refine conversationally.
A typical diagram starts at the edge — users, DNS (Route 53), and a content delivery network (CloudFront) — then passes through a load balancer into compute such as EC2 instances, ECS containers, or Lambda functions. Behind compute sit data stores like RDS, DynamoDB, and S3, often inside a VPC with public and private subnets for isolation.
Grouping matters as much as the icons. Architecture diagrams use boundaries to show what lives inside a VPC, an availability zone, or a subnet, which communicates the security and high-availability design at a glance. Arrows between services show the direction of requests and data flow.
Describe your architecture in plain language: the entry point, the compute layer, the data layer, and how a request travels through them. Mention any VPC, subnet, or availability-zone boundaries you want shown. Diagramming AI converts that into PlantUML using the AWS icon library, placing services inside the right groups.
Then iterate in the chat: "put the database in a private subnet", "add a CloudFront distribution in front of the load balancer", or "show a second availability zone for high availability". Each instruction updates the editable diagram, and you can export it or copy the PlantUML into your design docs.
Scenario: A classic web app: users reach an Elastic Load Balancer that distributes traffic to EC2 instances, which read and write to an RDS database.
Instruction text for AI
Create an AWS architecture diagram for a three-tier web app: users hit an Elastic Load Balancer, which routes to EC2 instances, which connect to an RDS database. Show the request flow.Generated Diagram (PlantUML)
@startuml
!include <awslib/AWSCommon>
!include <awslib/Compute/EC2>
!include <awslib/Database/RDS>
!include <awslib/NetworkingContentDelivery/ElasticLoadBalancing>
actor User
ElasticLoadBalancing(elb, "Load Balancer", "")
EC2(web1, "Web Server 1", "")
EC2(web2, "Web Server 2", "")
RDS(db, "Application DB", "PostgreSQL")
User --> elb : HTTPS
elb --> web1
elb --> web2
web1 --> db
web2 --> db
@endumlScenario: A serverless backend where API Gateway invokes a Lambda function that reads from DynamoDB and stores assets in S3.
Instruction text for AI
Draw an AWS serverless architecture: API Gateway receives requests and triggers a Lambda function, which reads and writes to a DynamoDB table and stores files in an S3 bucket.Generated Diagram (PlantUML)
@startuml
!include <awslib/AWSCommon>
!include <awslib/ApplicationIntegration/APIGateway>
!include <awslib/Compute/Lambda>
!include <awslib/Database/DynamoDB>
!include <awslib/Storage/SimpleStorageService>
actor Client
APIGateway(api, "API Gateway", "REST")
Lambda(fn, "Request Handler", "")
DynamoDB(ddb, "Data Table", "")
SimpleStorageService(s3, "Asset Bucket", "")
Client --> api : HTTPS
api --> fn : invoke
fn --> ddb : read/write
fn --> s3 : put object
@endumlScenario: A network-focused view showing a load balancer in a public subnet and application servers plus a database in a private subnet, all inside a VPC.
Instruction text for AI
Generate an AWS diagram showing a VPC with a public subnet containing a load balancer and a private subnet containing EC2 app servers and an RDS database. Group the resources by subnet.Generated Diagram (PlantUML)
@startuml
!include <awslib/AWSCommon>
!include <awslib/Groups/VPC>
!include <awslib/Groups/PublicSubnet>
!include <awslib/Groups/PrivateSubnet>
!include <awslib/Compute/EC2>
!include <awslib/Database/RDS>
!include <awslib/NetworkingContentDelivery/ElasticLoadBalancing>
actor User
VPC(vpc, "Production VPC", "") {
PublicSubnet(pub, "Public Subnet", "") {
ElasticLoadBalancing(elb, "Load Balancer", "")
}
PrivateSubnet(priv, "Private Subnet", "") {
EC2(app, "App Servers", "")
RDS(db, "Database", "")
}
}
User --> elb : HTTPS
elb --> app
app --> db
@endumlAn AWS architecture diagram documents how the services in a cloud system connect — compute, storage, databases, and networking — and how requests flow between them. Teams use it to design deployments, review them for cost, security, and high availability, and onboard engineers onto an existing system.
Yes. Describe your services and how requests flow through them in plain English, and Diagramming AI generates an editable PlantUML AWS diagram using the official AWS icon set. You can then refine it through follow-up chat instructions and export the result.
You can include the full range of common AWS services — EC2, Lambda, ECS, S3, RDS, DynamoDB, API Gateway, CloudFront, Route 53, Elastic Load Balancing, and many more — along with grouping boundaries such as VPCs, availability zones, and public or private subnets to show your network design.
Yes. The generated PlantUML uses the AWS icon library, so services render with their recognizable official icons. This makes the diagrams suitable for design reviews, documentation, and architecture proposals.
Continue with related guides, browse templates, or start building your own diagram in Diagramming AI.