Architectures

Compose something substantial.

The modules are intentionally small. Root modules combine them into complete platforms, keeping application decisions in one place and infrastructure concerns reusable.

Composition blueprints

Use these as starting points, not rigid templates. Add only the capabilities your product needs.

platform-web

Production web platform

A secure, multi-region web application with an SSR frontend, managed identity, and a GraphQL API.

Typical flow

GitHub Actions → OIDC → Terraform Cloud → SSR + Cognito + AppSync → DynamoDB

OIDCTFC WorkspaceServerless SSRCognito AuthGraphQL APIDynamoDB Global Table

Start with the delivery and identity layers, then pass authentication and data outputs into the application modules. The root module owns composition; each child module owns one infrastructure concern.

platform-events

Event-driven services

A decoupled service foundation where events move through a shared bus, durable queues, and independently deployed consumers.

Typical flow

GitHub Actions → OIDC → Terraform Cloud → EventBridge → SQS → Lambda → DynamoDB

OIDCTFC WorkspaceEvent BusEvent ConsumerDynamoDB Global Table

The bus is the shared foundation. Each consumer gets its own queue, retry policy, and optional processor, allowing teams to scale and deploy services independently.

platform-saas

Multi-region SaaS foundation

A resilient baseline for tenant-facing products with regional failover, user authentication, APIs, and durable data.

Typical flow

Delivery → Edge → Identity → API → Global data + events

OIDCTFC WorkspaceServerless SSRCognito AuthGraphQL APIDynamoDB Global TableEvent Bus

Use a root module as the product boundary. It wires provider aliases, shared naming, environments, and outputs while the reusable modules stay independently versioned.

The root module pattern

One boundary. Many building blocks.

A root module is the composition layer for a product or platform. It chooses versions, names resources, configures providers, and connects outputs. Child modules remain focused, portable, and easy to replace.

platform/main.tf

module "identity" {
  source = "pomo-studio/cognito-auth/aws"
}

 module "data" {
   source     = "pomo-studio/dynamodb-global-table/aws"
   name       = "my-app-users"
   hash_key   = "id"
   attributes = [{ name = "id", type = "S" }]
 }

 module "api" {
   source                = "pomo-studio/appsync/aws"
   name                  = "my-app-api"
   schema                = file("${path.module}/schema.graphql")
   cognito_user_pool_arn = module.identity.user_pool_arn
   dynamodb_data_sources = {
     users = {
       table_name = module.data.table_name_primary
       table_arn  = module.data.table_arn_primary
     }
   }
 }

platform/providers.tf

provider "aws" {
  alias  = "primary"
  region = "us-east-1"
}

provider "aws" {
  alias  = "dr"
  region = "us-west-2"
}

module "events" {
  source = "pomo-studio/event-bus/aws"
  providers = {
    aws.primary = aws.primary
    aws.dr      = aws.dr
  }
  enable_dr = true
}