Fjall Docs — deploy AWS infrastructure into your own account

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	Monthly cost	Shape
Tinkerer	$0*	2-AZ VPC, no NAT, ECS on EC2, single-AZ `t4g.micro` RDS
Lightweight	~$35	2-AZ VPC, Fargate Spot, single-AZ `t4g.small` RDS
Standard	~$340	3-AZ VPC, on-demand Fargate, Multi-AZ `t4g.large` RDS
Resilient	$200-600+	3 NAT Gateways, Aurora with 2 readers, RDS Proxy, CMK keys
Enterprise	$300-800+	Everything Resilient has, plus VPC endpoints and 35-day backup

* Tinkerer is $0 only within AWS free-tier limits. Data transfer and over-limit usage incur charges. Figures are estimates and exclude data transfer and request charges. Actual cost varies by region, traffic and database load. Each tier page carries the itemised breakdown behind its figure, and fjall costs --app <name> reports what a deployed application actually spends.

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

Factory Patterns

Application Patterns

Architecture Patterns

Lightweight Pattern

Overview

Prerequisites

Create a Lightweight application

Architecture

Generated infrastructure

Specifications

Compute (ECS on Fargate Spot)

Database (RDS Instance)

Networking

Cost comparison

When to use it

Lightweight compared with Standard

Customisation

Resize the database

Switch to on-demand Fargate

Monitoring

Upgrade path

Security

Next Steps

Deploy an Application

Standard Pattern

Add Resources

Compute Factory

​Overview

​Prerequisites

​Create a Lightweight application

​Architecture

​Generated infrastructure

​Specifications

​Compute (ECS on Fargate Spot)

​Database (RDS Instance)

​Networking

​Cost comparison

​When to use it

​Lightweight compared with Standard

​Customisation

​Resize the database

​Switch to on-demand Fargate

​Monitoring

​Upgrade path

​Security

​Next Steps

Deploy an Application

Standard Pattern

Add Resources

Compute Factory

Overview

Prerequisites

Create a Lightweight application

Architecture

Generated infrastructure

Specifications

Compute (ECS on Fargate Spot)

Database (RDS Instance)

Networking

Cost comparison

When to use it

Lightweight compared with Standard

Customisation

Resize the database

Switch to on-demand Fargate

Monitoring

Upgrade path

Security

Next Steps