+1 (726) 227-3497
RougeWarehouse

Getting Started with Amazon Redshift Serverless (2026)

Redshift Serverless is the fastest way to get a working Amazon Redshift environment, and in 2026 it is where most new Redshift projects start. There is no cluster to size and no node type to pick. You create a namespace (database objects, users, encryption key) and a workgroup (compute, network, limits), and you pay per RPU-hour while queries run.

This guide takes you from an empty AWS account to a queryable warehouse with a spending cap, in about 30 minutes. Commands use the AWS CLI v2; everything can also be done in the console.

1. Create the namespace and workgroup

A namespace holds your data; a workgroup provides the compute that queries it. One namespace can have one workgroup attached at a time, but you can create several namespaces (for example dev, test, prod) in one account.

aws redshift-serverless create-namespace \
  --namespace-name analytics-dev \
  --db-name dev \
  --admin-username admin \
  --manage-admin-password

aws redshift-serverless create-workgroup \
  --workgroup-name analytics-dev-wg \
  --namespace-name analytics-dev \
  --base-capacity 8 \
  --publicly-accessible false \
  --subnet-ids subnet-0123456789abcdef0 subnet-0123456789abcdef1 subnet-0123456789abcdef2 \
  --security-group-ids sg-0123456789abcdef0

Notes on the choices:

  • --manage-admin-password stores the admin credential in AWS Secrets Manager instead of you passing one on the command line. Use it.
  • --base-capacity 8 is the smallest base RPU setting, which is fine for a first environment. The default is larger; starting small and raising it is cheaper than the reverse.
  • You need at least three subnets in different Availability Zones. Keep --publicly-accessible false and connect through Query Editor v2 or a VPN/bastion.

The workgroup takes a few minutes to become AVAILABLE:

aws redshift-serverless get-workgroup --workgroup-name analytics-dev-wg \
  --query 'workgroup.status'

2. Set a usage limit before you load anything

Do this before step 3, not after. A usage limit caps RPU-hours per day, week or month, and can log, alert or stop queries when it is hit.

aws redshift-serverless create-usage-limit \
  --resource-arn arn:aws:redshift-serverless:us-east-1:123456789012:workgroup/analytics-dev-wg \
  --usage-type serverless-compute \
  --amount 100 \
  --period monthly \
  --breach-action deactivate

--amount is in RPU-hours. At the published Serverless rate for your region, 100 RPU-hours is a small, known number of dollars, which is exactly the point. deactivate stops the workgroup from accepting queries when the limit is reached; use log or emit-metric (which publishes a CloudWatch metric you can alarm on) for production workgroups where stopping is worse than overspending.

You can also set query limits in the workgroup configuration, for example a maximum runtime or maximum scanned rows per query, to catch a runaway join early.

3. Connect with Query Editor v2

Open Amazon Redshift in the console, choose Query editor v2, and pick the analytics-dev-wg workgroup. Authenticate with the admin credential from Secrets Manager or with federated IAM. Query Editor v2 is a full SQL client: tabs, saved queries, charts, scheduling and an Amazon Q generative SQL panel. No driver installation is needed.

4. Load the sample data

Redshift's documentation ships a tickit dataset in a public bucket. Create the tables, then load them with COPY using the workgroup's default IAM role.

CREATE TABLE users (
  userid INTEGER NOT NULL,
  username CHAR(8),
  firstname VARCHAR(30),
  lastname VARCHAR(30),
  city VARCHAR(30),
  state CHAR(2),
  email VARCHAR(100),
  phone CHAR(14),
  likesports BOOLEAN,
  liketheatre BOOLEAN,
  likeconcerts BOOLEAN,
  likejazz BOOLEAN,
  likeclassical BOOLEAN,
  likeopera BOOLEAN,
  likerock BOOLEAN,
  likevegas BOOLEAN,
  likebroadway BOOLEAN,
  likemusicals BOOLEAN
);

CREATE TABLE sales (
  salesid INTEGER NOT NULL,
  listid INTEGER NOT NULL,
  sellerid INTEGER NOT NULL,
  buyerid INTEGER NOT NULL,
  eventid INTEGER NOT NULL,
  dateid SMALLINT NOT NULL,
  qtysold SMALLINT NOT NULL,
  pricepaid DECIMAL(8,2),
  commission DECIMAL(8,2),
  saletime TIMESTAMP
);

COPY users FROM 's3://redshift-downloads/tickit/allusers_pipe.txt'
  IAM_ROLE default
  DELIMITER '|' REGION 'us-east-1';

COPY sales FROM 's3://redshift-downloads/tickit/sales_tab.txt'
  IAM_ROLE default
  DELIMITER '\t' TIMEFORMAT 'MM/DD/YYYY HH:MI:SS' REGION 'us-east-1';

Notice what is missing: no DISTKEY, no SORTKEY, no ENCODE. Redshift defaults to DISTSTYLE AUTO, SORTKEY AUTO and AZ64/ZSTD encodings, and Automatic Table Optimization will adjust distribution and sort keys from the query pattern. For a new project, leave it alone until you have evidence it needs help (see our sort and distribution keys guide).

Check the load:

SELECT table_name, status, lines_scanned, data_size, duration
FROM SYS_LOAD_HISTORY
ORDER BY start_time DESC
LIMIT 5;

5. Run your first queries

-- Revenue by state, top 10
SELECT u.state, SUM(s.pricepaid) AS revenue, COUNT(*) AS tickets
FROM sales s
JOIN users u ON u.userid = s.buyerid
GROUP BY u.state
ORDER BY revenue DESC
LIMIT 10;

Run it twice. The second run returns from the result cache and does not consume RPU time, which is one of the reasons Serverless dashboards are cheaper than their query count suggests.

To see what a query cost in compute:

SELECT query_id, status, elapsed_time / 1000000.0 AS seconds,
       compute_type, returned_rows
FROM SYS_QUERY_HISTORY
WHERE user_id = current_user_id
ORDER BY start_time DESC
LIMIT 10;

6. Check what you are spending

Serverless billing is visible in two places. SYS_SERVERLESS_USAGE in the database shows RPU consumption per 30-second interval; the ComputeSeconds and ComputeCapacity CloudWatch metrics show the same at the workgroup level.

SELECT DATE_TRUNC('hour', start_time) AS hour,
       SUM(charged_seconds) / 3600.0 AS rpu_hours
FROM SYS_SERVERLESS_USAGE
GROUP BY 1
ORDER BY 1 DESC
LIMIT 24;

Multiply rpu_hours by your region's per-RPU-hour rate and you have the compute line of the bill. Storage (Redshift Managed Storage) is billed separately per GB-month.

7. Clean up, or keep going

If this was an experiment, delete the workgroup and then the namespace (with --no-final-snapshot if you really do not want the data). If it is the start of a project, the next steps are:

  • Raise or lower base capacity based on the first week of SYS_SERVERLESS_USAGE and query latency
  • Replace the manual COPY with an auto-copy job or a zero-ETL integration
  • Put the usage limit into production mode (emit-metric with a CloudWatch alarm to the on-call channel)

If you want an experienced team to do the sizing and the migration from an existing cluster, see our Redshift Serverless Migration & Right-Sizing service.