30 minutos

• O problemaPor que arquitetar na AWS ainda dói em 2026.
• O que é OpenArchFlowPWA open source, local-first, dual-AI, zero backend.
• Demo ao vivoDo prompt ao diagrama, ao custo, ao Terraform — em 12 minutos.
• Como funciona por dentroGemini + WebLLM + MCP + IaC abstraction.
• Quando usar (e quando não)+ roadmap, contribuição e Q&A.

Desenhar arquitetura AWS é
caro, lento e desconectado.

Resultado: a documentação envelhece em horas, o custo é surpresa, e o IaC vira o "trabalho real" depois da reunião.

E se o diagrama fosse a fonte da verdade?

Um único artefato — editável, versionável, exportável — que carrega desenho, custo e infraestrutura como código na mesma fonte.

OpenArchFlow em uma frase.

Um PWA open source que transforma descrições em linguagem natural em diagramas AWS interativos — com custo estimado e Terraform exportável.

4 escolhas que mudam tudo.

Hora de ver
funcionando.

// 12 minutos · 7 funcionalidades · 1 arquitetura real

O que vamos ver, na ordem.

Geração com IA

Do prompt ao diagrama em segundos.

API serverless de processamento
de pedidos com:

- API Gateway na borda
- Lambda de validação
- DynamoDB de pedidos
- SQS para fanout
- Lambda worker
- S3 para anexos
- Tudo numa VPC com 2 AZs

Edição visual

Quando a IA acerta 80%, você refina os 20%.

Custo em tempo real

Antes do apply, depois do desenho.

RESOURCE              QTY   USAGE         USD/MO
─────────────────────────────────────────────────
API Gateway HTTP       1    1M req/mo      $1.00
Lambda (validate)      1    1M @ 256MB     $0.83
Lambda (worker)        1    1M @ 512MB     $1.67
DynamoDB On-Demand     1    50GB + 1M wr   $14.20
SQS Standard           1    1M msg         $0.40
S3 Standard            1    100GB          $2.30
─────────────────────────────────────────────────
TOTAL ESTIMADO                            $20.40 /mo

Simulação de tráfego & falhas

O diagrama vira um laboratório.

Templates como Serverless Circuit Breaker e ECS + App Mesh já vêm com falhas configuradas para você ver o circuito abrindo na hora.

Export Terraform

Do diagrama para .tf em um clique.

terraform {
  required_providers {
    aws = { source = "hashicorp/aws", version = "~> 5.0" }
  }
}

provider "aws" {
  region = var.aws_region
}

resource "aws_lambda_function" "validate_order" {
  function_name = "validate-order"
  role          = aws_iam_role.lambda_exec.arn
  handler       = "index.handler"
  runtime       = "nodejs20.x"
  memory_size   = 256
}

resource "aws_dynamodb_table" "orders" {
  name         = "orders"
  billing_mode = "PAY_PER_REQUEST"
  hash_key     = "order_id"
  attribute { name = "order_id"; type = "S" }
}

resource "aws_sqs_queue" "fanout" {
  name = "order-fanout"
}

# depends_on inferido a partir das edges do diagrama

resource "aws_apigatewayv2_route" "post_orders" {
  api_id    = aws_apigatewayv2_api.http.id
  route_key = "POST /orders"
  target    = "integrations/${aws_apigatewayv2_integration.lambda.id}"
  depends_on = [aws_lambda_function.validate_order]
}

Não é template-string. É schema-aware.

Per-node IaC config: sobrescreva o tipo de recurso e o nome direto no Properties Panel — o que aparece como aws_lambda_function.validate_order no HCL.

Colaboração P2P em tempo real

Sem servidor central. Zero-knowledge.

MiniStack — Deploy Local

Do diagrama ao AWS emulado em localhost.

docker run -p 4566:4566 \
  ministackorg/ministack

Como isso
funciona?

// stack, fluxo de dados e a abstração que torna tudo plugável

Backend? Quase nenhum.

A abstração IaCGenerator.

// src/lib/iac/types.ts
export interface IaCGenerator {
  readonly name: string;          // "terraform" | "cdk" | "pulumi"
  readonly fileExtension: string; // ".tf" | ".ts" | ".py"

  generate(
    nodes: AppNode[],
    edges: AppEdge[],
    options?: IaCGenerationOptions
  ): Promise<IaCFileSet>;

  supportsResource(awsServiceType: string): boolean;
}

// src/lib/iac/terraform/generator.ts
export class TerraformGenerator implements IaCGenerator {
  name = "terraform";
  fileExtension = ".tf";

  async generate(nodes, edges) {
    const resources    = nodes.map(n => mapToResource(n));
    const dependencies = inferDependsOn(edges);
    return {
      "main.tf":      renderMain(resources, dependencies),
      "variables.tf": renderVariables(resources),
      "outputs.tf":   renderOutputs(resources)
    };
  }
}

Adicionar Pulumi amanhã = uma nova classe. A UI não muda.

O fluxo end-to-end.

De fevereiro a maio, 8 releases.

Quando
usar (e quando não).

Onde brilha. Onde ainda não.

A regra: OpenArchFlow é o cartão de visita da arquitetura. Não substitui pipelines de IaC maduros — acelera o caminho até eles.

Roadmap aberto — e contribuível.

Quatro formas de contribuir hoje.

// Built by Rafael Sales · MIT License · construído por arquitetos para arquitetos

Obrigado.
Perguntas?

↑ ↓ ← → para navegar · S para speaker notes · F para fullscreen · ? para todos os atalhos