Lightweight Pattern

Overview

The Lightweight tier runs your containers on Fargate Spot at a discount against on-demand Fargate pricing. It suits internal tools, development environments and low-traffic services that tolerate occasional task interruption. Spot capacity can be reclaimed by AWS at two minutes’ notice. Pick Standard instead when the workload must stay up.

Prerequisites

A connected AWS account (fjall connect)
A signed-in CLI session (fjall login)

Create a Lightweight application

fjall create app --type lightweight

The CLI prompts for the application name, whether to include a database, how many services to create, and the Dockerfile path and container port for each service. Full prompt sequence: Create an Application. The scaffold writes fjall/<app>/infrastructure.ts containing:

Resource	Configuration
ECS cluster	Fargate Spot, 1 task, 256 CPU units, 512 MiB
RDS Instance	PostgreSQL on `t4g.small`, single AZ
Load balancer	Application Load Balancer across the VPC’s 2 AZs
VPC	2 AZs, 1 NAT gateway, flow logs off

Architecture

┌─────────────────┐
│      ALB        │ (spans 2 AZs)
└────────┬────────┘
         |
┌────────┴────────┐
│  ECS Fargate    │ (FARGATE_SPOT, 1 task, scales 1-3)
│  Spot           │ (256 CPU, 512 MiB)
└────────┬────────┘
         |
┌────────┴────────┐
│  RDS Instance   │ (single AZ, t4g.small)
└─────────────────┘

The VPC spans two availability zones so the load balancer stays reachable. The database instance itself is single-AZ, which is where most of the saving against Standard comes from.

Generated infrastructure

Scaffolding an application named simple produces:

#!/usr/bin/env node

import {
  App,
  DatabaseFactory,
  ComputeFactory,
  getConfig,
} from "@fjall/components-infrastructure";

const appName = "simple";
const app = App.getApp(appName, {
  network: {
    maxAzs: 2,
    natGateways: { count: 1 },
    flowLogs: false,
  },
});

app.addTags({
  "fjall:costAllocation:owner": "engineering",
});

const simpleDatabase = app.addDatabase(
  DatabaseFactory.build("simple", {
    vpc: app.getVpc(),
    type: "Instance",
    databaseName: "simple",
    instanceType: "t4g.small",
    multiAz: false,
    ...(getConfig().environment === "production"
      ? { alertsTopic: "import:SharedAlarmTopicArn" }
      : {}),
  }),
);

app.addCompute(
  ComputeFactory.build("simple", {
    type: "ecs",
    ecrRepository: app.getDefaultContainerRegistry(),
    services: [
      {
        name: "api",
        capacityProvider: "FARGATE_SPOT",
        containers: [
          {
            port: 3000,
            environment: {
              ENVIRONMENT: getConfig().environment,
              DATABASE_HOST: simpleDatabase.getHostEndpoint(),
              DATABASE_PORT: simpleDatabase.getHostPort(),
              DATABASE_NAME: simpleDatabase.getDatabaseName(),
              DATABASE_SSL: "true",
            },
            secretsImport: {
              DATABASE_USERNAME: simpleDatabase
                .getCredentials()
                .getImport("username"),
              DATABASE_PASSWORD: simpleDatabase
                .getCredentials()
                .getImport("password"),
            },
          },
        ],
        cpu: 256,
        memoryLimitMiB: 512,
        desiredCount: 1,
        scaling: {
          minCapacity: 1,
          maxCapacity: 3,
        },
        connections: [simpleDatabase],
      },
    ],
    ...(getConfig().environment === "production"
      ? { alertsTopic: "import:SharedAlarmTopicArn" }
      : {}),
  }),
);

The database and compute constructs both take the application name as their id. The default service is named api.

Specifications

Compute (ECS on Fargate Spot)

Setting	Value
Capacity provider	`FARGATE_SPOT`
CPU	256 units (0.25 vCPU)
Memory	512 MiB
Desired count	1
Scaling	1 to 3 tasks

Database (RDS Instance)

Setting	Value
Engine	PostgreSQL 17.9
Instance class	`t4g.small`
Storage	100 GiB gp3, autoscaling to 500 GiB
Encryption	Storage encrypted at rest
Backups	14-day retention (construct default)
Multi-AZ	No
AWS Backup vault	Not provisioned at this tier

Networking

Setting	Value
VPC	2 availability zones
Subnets	Public and private
Load balancer	Application Load Balancer
NAT gateways	1
Flow logs	Off

Cost comparison

Tier	Main recurring cost drivers
Tinkerer	EC2, EBS and single-AZ RDS; no NAT or ALB. Free-tier eligibility is account-specific.
Lightweight	One NAT, ALB, Fargate Spot, single-AZ `t4g.small` RDS and 100 GiB storage.
Standard	On-demand Fargate, Multi-AZ RDS, one NAT, ALB and ECR endpoints across three AZs.
Resilient	Three NATs, four tasks, Aurora writer plus two readers, proxy, interface endpoints and backups.
Enterprise	Six larger tasks, Aurora readers/proxy, five interface endpoints per AZ and long-retention backups/logs.

Lightweight is not a ~$35/month stack: NAT gateway hours alone can approach that amount before the database, storage, ALB and tasks. Price the complete configuration in the AWS Pricing Calculator for your region and expected running hours. Include public IPv4, secrets and their keys, logs, backup storage, request/processing charges and transfer. No tier is a billing cap. After deployment, fjall costs --app <name> reports attributed spend; billing data can lag and is not a pre-deploy quote.

When to use it

Good fit:

Internal tools and admin panels
Development and staging environments
Low-traffic websites and simple APIs
Prototypes moving to production
Cost-sensitive projects

Pick another tier when you need:

Guaranteed capacity (Spot tasks can be reclaimed)
Mission-critical uptime
Sustained high traffic
Multi-region deployment

Lightweight compared with Standard

Setting	Lightweight	Standard
Capacity provider	`FARGATE_SPOT`	`FARGATE`
CPU	256	512
Memory	512 MiB	1024 MiB
Desired tasks	1	2
Scaling range	1 to 3	2 to 5
VPC availability zones	2	3
Database instance	`t4g.small`	`t4g.large`
VPC flow logs	Off	On
Interruption risk	Yes (Spot)	No

Customisation

Resize the database

instanceType is a top-level database property, so change it with the CLI:

fjall modify database --app simple --name simple --instanceType t4g.medium

The codemod rewrites infrastructure.ts in place and typechecks the result. See fjall modify.

Switch to on-demand Fargate

capacityProvider sits inside the services array, which the property-flag syntax does not address. Edit infrastructure.ts directly:

services: [
  {
    name: "api",
    capacityProvider: "FARGATE", // was FARGATE_SPOT
    // remaining service settings unchanged
  },
],

Then validate the edit before deploying:

fjall validate --app simple --deep

Monitoring

CloudWatch collects ECS service health, RDS instance metrics, ALB request counts and application logs. Watch the ECS service events for Spot reclamation notices, which appear as task stops with a SpotInterruption reason.

Upgrade path

Target tier	Changes to make
Standard	`FARGATE` capacity, 512 CPU / 1024 MiB, desired count 2, `t4g.large` database
Resilient	Aurora instead of RDS Instance, 3 AZs, customer-managed KMS keys, wider scaling range
Enterprise	Everything in Resilient plus the full compliance and observability feature set

Resilient requires a Pro plan and Enterprise requires an Enterprise plan. The CLI blocks the tier at selection time when the entitlement is missing.

Security

The database sits in private subnets with no route in from the internet
Compute tasks reach the internet through the NAT gateway, never directly
Security groups open only the ports the services declare
Storage is encrypted at rest and connections use TLS
Database credentials live in AWS Secrets Manager and reach containers through secretsImport

Next steps

Deploy an Application

Deploy your Lightweight application to AWS

Standard Pattern

Compare against the on-demand Fargate tier

Add Resources

Add databases, storage and messaging to your application

Compute Factory

Customise services, scaling and container settings

Documentation

Getting started

CLI reference

Patterns

Resources