dataonaws
— Stack · Streaming

Data Firehose

A managed pipe from a stream to a destination, with no code to run. You point producers at a Firehose stream; it buffers, can transform and reformat, and delivers to S3, a warehouse, a search cluster or an HTTP endpoint. You pay per GB ingested. It moves and lands data; it does not do stateful stream processing.

How it fits

Producers write in. Firehose buffers, shapes, and delivers out.

YOUR SOURCESAMAZON DATA FIREHOSEOPTIONAL, PER GBDESTINATIONSDirect PUTSDK, agent, LambdaVended logsCloudWatch, WAF, VPCKinesisan existing streamAmazon MSKa Kafka topicBuffersize + intervalfill to N MB, orwait up to 15 minthen GZip / Snappyback up to S3As isno extra chargeTransformyour LambdaFormat convertJSON to Parquet/ORCDynamic partitionkeys to S3 prefixesDeliverat-least-onceAmazon S3files, ParquetIceberg tablesincl. S3 TablesRedshiftvia S3 then COPYOpenSearchService or ServerlessSnowflake, SplunkHTTP: Datadog, New Relicformat conversion to Parquet/ORC needs a table schema in the AWS Glue Data Catalog · Redshift loads through an S3 staging bucket

Sources: Direct PUT (SDK, Lambda, Kinesis Agent, Fluent Bit, and vended logs from CloudWatch Logs, WAF, VPC Flow Logs and others), an existing Kinesis Data Stream, or an Amazon MSK topic. Destinations include Amazon S3, Apache Iceberg tables (including S3 Tables), Redshift, OpenSearch Service and Serverless, Snowflake, Splunk, and any HTTP endpoint, with built-in integrations for Datadog, New Relic, MongoDB, Dynatrace, Elastic and others. Delivery is at-least-once, so sinks should tolerate duplicates.

What it does on the way

Buffer, reshape, and land, with knobs for each.

Batch

Buffer size and interval

Firehose holds records until a buffer fills (size in MB) or an interval passes (up to 15 minutes), then writes one object. Bigger buffers mean fewer, larger files and higher latency; smaller buffers mean fresher data and more objects.

Reshape

Transform with Lambda

A Lambda function can filter, enrich or correct each batch before delivery. You own the function; Firehose invokes it and can back the untransformed source up to a second S3 bucket.

Columnar

Format conversion

Convert JSON to Parquet or ORC in flight, using a table schema from the Glue Data Catalog. This makes the landed data cheaper to scan with Athena, Redshift Spectrum and EMR.

Layout

Dynamic partitioning

Route records to S3 prefixes by a key read from the record (a JQ expression or your Lambda), so a lake lands already partitioned by date, tenant or type, ready to query.

The three choices that matter

A few settings set the latency, the file layout, and the bill.

01

Buffer size vs delivery latency

A larger buffer produces fewer, bigger objects that are cheaper and faster to query later, at the cost of up to 15 minutes of delay. Small buffers deliver sooner but scatter many small files across S3.

02

Which source, which billing shape

Direct PUT and KDS ingestion rounds each record up to the next 5 KB, so many tiny records cost more than their raw bytes. MSK and vended logs bill on actual GB. All three are tiered: the per-GB rate drops past 500 TB a month.

03

Which extras you turn on

Base ingestion has no extra delivery charge. Format conversion adds a per-GB rate. Dynamic partitioning adds a per-GB and a per-object charge, plus a per-hour charge if you use the JQ parser. Delivery into a VPC adds per-GB and per-AZ-hour charges.

Bar lengths are illustrative of the latency-vs-file-size trade-off, not measured figures.

What you pay

A Firehose bill, in one line.

Ingestion
per GB, tiered
Direct PUT and Kinesis Data Streams: per GB, each record rounded up to 5 KB; the rate drops past 500 TB a month
+
Source shape
PUT vs MSK vs logs
MSK and vended-logs ingestion bill on actual GB with no 5 KB rounding, at their own rates
+
Format conversion
per GB
Optional JSON to Parquet/ORC, billed per GB ingested in 5 KB increments
+
Dynamic partitioning
per GB + per object
Per GB delivered, per 1,000 S3 objects, and per hour of JQ parsing if used
+
VPC delivery
per GB + per AZ-hour
When the destination sits in a VPC; each partial hour billed as a full hour
What we see in production
Reached for Firehose to do stateful processing.It buffers and delivers; it does not window, join or aggregate across records. For that use Managed Service for Apache Flink.
Many tiny Direct PUT records, a surprising bill.Each record rounds up to 5 KB; batch small events in the producer so you pay closer to raw bytes.
A short buffer that scatters thousands of small files.Small objects make later Athena and Spark scans slow and costly; size the buffer for larger files or compact downstream.
Format conversion enabled without a matching Glue schema.Conversion reads the table schema from the Glue Data Catalog; a stale or missing schema drops or mis-types columns.
Delivery failures assumed to be data loss.Firehose retries and writes failed records to an S3 error prefix; alarm on the DeliveryToS3 and delivery-failure metrics and reprocess from there.
A sink that cannot tolerate duplicates.Delivery is at-least-once, so design idempotent writes or dedupe downstream rather than assuming exactly-once.
How we help

Industrial-grade data pipelines

Use cases in production, not POCs: tests, CI/CD, lineage, on-call that sleeps at night.

Read the approach →
PDF · coming soon

The one-page Data Firehose field guide.

Best practices, cost traps and performance checks, in the order you should run them. Printable, no fluff.

One email when the PDF is ready. Nothing else unless you tick the box.