01
Your application
Send events
Your application sends authenticated HTTP requests containing one event or a batch. You do not need to build a collection pipeline or define a destination table first.
Event analytics for 1–10 person teams
From application events to useful analytics.
Send JSON over HTTP. Postcone creates and manages analytical tables as event shapes evolve, preserves every source event, semantically interprets the resulting data, and gives you SQL plus visualizations suggested from that understanding.
One event or a batch · No upfront table definition
send-event.sh
curl -X POST \
"https://api.postcone.com/v1/tables/analytics.agent_runs/events" \
-H "Authorization: Bearer pcone_..." \
-H "Content-Type: application/json" \
-d '{
"run_id": "run_8f3a",
"agent": "research-bot",
"duration_ms": 1850,
"status": "success"
}' Table
analytics.agent_runs
Created automatically
Schema
Managed as events evolve
Full source JSON retained
Understand
Semantic views + SQL
Meaning inferred from data
Ingest
Single events or batches
Manage
Tables + evolving schemas
Interpret
Semantic column analysis
Understand
Generated views + SQL
The problem
You already have the data. You should not need a data platform team to use it.
Event analytics often starts with one endpoint and becomes a queue, schema system, storage pipeline, table catalog, query engine, cache, and visualization layer. Postcone manages that path as one service so a solo developer or small product team can stay focused on the application.
Build the stack
Ingestion APIQueueSchema jobsObject storageParquetCatalogQuery engineCacheCharts
Use Postcone
One workspace-scoped API
Send the event. Keep building your product.
How it works
Send one request. Postcone handles the layers between event and insight.
Your application emits ordinary JSON. Postcone takes responsibility for the ingestion, storage, schema, and interpretation work that normally turns event analytics into a platform project.
02
Managed infrastructure
Postcone runs the data path
Postcone handles authenticated ingestion, buffering, analytical file creation, table storage, and publication. Your product team does not have to operate those systems.
03
Evolving schema
Event shapes become managed schemas
Incoming events are examined to determine the table's columns and types. As new fields appear, Postcone evolves its schema understanding additively while retaining the complete source JSON and keeping older events available.
04
Semantic analysis
Postcone infers what the data means
Postcone combines column names, physical types, statistics, and sample values to infer
semantic roles. For example, duration_ms: long can be recognized as a latency measurement rather than a currency amount, status code, or
general number field.
05
Understanding
Relevant analysis is ready to explore
Postcone uses its semantic understanding to generate relevant suggested visualizations, such as latency percentiles over time. The underlying event tables remain directly queryable with SQL whenever you need to go deeper.
Derive insights through SQL and visualizations
From an evolving schema to analysis that fits the data.
Postcone maintains structural understanding as event shapes change, then analyzes column names, types, statistics, and sample values to infer what those columns represent. That semantic model drives useful visualization suggestions while the underlying events remain directly queryable with SQL.
query.sql Read-only SQL
SELECT
agent,
count(*) AS runs,
percentile_cont(0.95)
WITHIN GROUP (ORDER BY duration_ms) AS p95_ms
FROM analytics.agent_runs
GROUP BY agent
ORDER BY runs DESC;
duration_ms as a latency field. Events become available
for analysis after asynchronous processing.Why Postcone
Keep the data. Skip the platform project.
Skip the data warehouse infrastructure
Go from an HTTP request to managed analytical storage without operating a custom pipeline.
Let event shapes evolve
Postcone manages inferred columns and types as fields appear while preserving every source event.
Use familiar SQL
Analyze event tables instead of learning a proprietary event-query language.
Start with semantically relevant views
Get visualization suggestions based on inferred meaning, not only physical column types.
Use cases
What is normally sent to the Cone?
Send ordinary JSON shaped around your application's own data model. Postcone automatically adapts the managed schema and analytical infrastructure as your events evolve.
API activity and latency
Track requests, response times, status families, endpoints, and domain-specific outcomes.
Background operations
Understand job duration, retries, completion, failures, and the quality of generated output.
Product and business events
Explore searches, recommendations, transactions, conversions, marketplaces, and custom workflows.
Agent and model runs
Analyze tools, tokens, duration, outcomes, model versions, and application-specific quality signals.
Compare approaches
Different tools optimize for different jobs.
There are good reasons to choose every option below. Compare where each approach is strongest, the tradeoffs it introduces, and where Postcone's narrower managed path may or may not fit.
Compare Postcone with:
Option: Build it yourself
Maximum control over the complete stack
An open, self-managed stack can be shaped precisely around your workload, security model, infrastructure, and performance requirements.
Why teams choose it
- Choose every storage, compute, and query component
- Tune performance and reliability for a unique workload
- Keep infrastructure and operational control in-house
Tradeoffs to consider
- Build and integrate ingestion, buffering, storage, querying, and visualization
- Own upgrades, recovery, observability, and on-call responsibility
- Invest more engineering time before the first useful analysis
Best fit
Control, customization, compliance, or specialized performance outweigh the engineering cost.
With Postcone
Use the managed event-to-understanding path
Postcone is narrower and more opinionated: events arrive through one API, while table creation, evolving schema management, semantic analysis, and SQL access are handled in one service.
- 1 Send a JSON object or batch over HTTP
- 2 Let Postcone run the ingestion and analytical storage infrastructure
- 3 Keep the table schema aligned as event shapes evolve
- 4 Infer what columns represent through semantic analysis
- 5 Query with SQL and start from semantically relevant visualizations
Where Postcone fits
A good fit when reducing event-to-analysis setup matters more than assembling or customizing every layer yourself.
Postcone tradeoff
Postcone provides less control over component choices, deployment topology, and low-level performance tuning.
Option: Data warehouse
A broad analytical home for the whole organization
A general-purpose warehouse is a mature foundation for joining many data sources, serving many teams, and supporting a large analytics ecosystem.
Why teams choose it
- Combine application events with company-wide data
- Use mature governance, connector, transformation, and BI ecosystems
- Support a wide range of analytical and data-science workloads
Tradeoffs to consider
- Add or configure an application-event ingestion path
- Manage destination schemas and changing event shapes
- Connect separate exploration and visualization tooling
Best fit
Application events belong in a broader, organization-wide data platform.
With Postcone
Use the managed event-to-understanding path
Postcone is narrower and more opinionated: events arrive through one API, while table creation, evolving schema management, semantic analysis, and SQL access are handled in one service.
- 1 Send a JSON object or batch over HTTP
- 2 Let Postcone run the ingestion and analytical storage infrastructure
- 3 Keep the table schema aligned as event shapes evolve
- 4 Infer what columns represent through semantic analysis
- 5 Query with SQL and start from semantically relevant visualizations
Where Postcone fits
A good fit when reducing event-to-analysis setup matters more than assembling or customizing every layer yourself.
Postcone tradeoff
Postcone has a much narrower connector, transformation, governance, and BI ecosystem than an established warehouse stack.
Option: Product analytics
Polished answers to common product questions
Product analytics suites make funnels, retention, cohorts, experiments, and user behavior accessible without requiring everyone to write SQL.
Why teams choose it
- Use ready-made product analysis workflows
- Give product teams approachable, purpose-built interfaces
- Benefit from mature SDKs, identity models, and product integrations
Tradeoffs to consider
- Map domain data into a more opinionated event and user model
- Use a separate path for unusual operational or backend events
- Work within product-specific querying and data-access conventions
Best fit
Packaged funnels, retention, experiments, and session workflows are the primary job.
With Postcone
Use the managed event-to-understanding path
Postcone is narrower and more opinionated: events arrive through one API, while table creation, evolving schema management, semantic analysis, and SQL access are handled in one service.
- 1 Send a JSON object or batch over HTTP
- 2 Let Postcone run the ingestion and analytical storage infrastructure
- 3 Keep the table schema aligned as event shapes evolve
- 4 Infer what columns represent through semantic analysis
- 5 Query with SQL and start from semantically relevant visualizations
Where Postcone fits
A good fit when reducing event-to-analysis setup matters more than assembling or customizing every layer yourself.
Postcone tradeoff
Postcone does not currently provide the packaged funnels, cohorts, experiments, feature flags, or session-replay workflows of a product analytics suite.
Option: Analytics database
High-performance infrastructure for custom data products
Real-time analytical databases and API platforms are strong foundations for demanding query workloads and customer-facing analytical applications.
Why teams choose it
- Optimize for low-latency and high-volume workloads
- Control schemas, ordering, partitions, and query behavior
- Build custom APIs and analytical product experiences
Tradeoffs to consider
- Design the table and ingestion architecture
- Write and optimize the analytical queries or APIs
- Build or connect the end-user exploration experience
Best fit
Query performance, scale, control, or customer-facing APIs are the primary requirements.
With Postcone
Use the managed event-to-understanding path
Postcone is narrower and more opinionated: events arrive through one API, while table creation, evolving schema management, semantic analysis, and SQL access are handled in one service.
- 1 Send a JSON object or batch over HTTP
- 2 Let Postcone run the ingestion and analytical storage infrastructure
- 3 Keep the table schema aligned as event shapes evolve
- 4 Infer what columns represent through semantic analysis
- 5 Query with SQL and start from semantically relevant visualizations
Where Postcone fits
A good fit when reducing event-to-analysis setup matters more than assembling or customizing every layer yourself.
Postcone tradeoff
Postcone offers less performance control, fewer integrations, and a less mature story for large-scale or sub-second customer-facing analytics.
Option: Collector + warehouse + BI
Combine mature best-of-breed products
A composed stack lets each layer specialize, with broad connectors, established workflows, and the ability to replace individual components.
Why teams choose it
- Choose a mature specialist for each layer
- Access broad source, destination, modeling, and BI ecosystems
- Evolve or replace components independently
Tradeoffs to consider
- Integrate identity, schemas, permissions, and operations across products
- Monitor data delivery and failures at each boundary
- Manage several pricing models and vendor relationships
Best fit
Connector breadth and mature specialized workflows justify the integration work.
With Postcone
Use the managed event-to-understanding path
Postcone is narrower and more opinionated: events arrive through one API, while table creation, evolving schema management, semantic analysis, and SQL access are handled in one service.
- 1 Send a JSON object or batch over HTTP
- 2 Let Postcone run the ingestion and analytical storage infrastructure
- 3 Keep the table schema aligned as event shapes evolve
- 4 Infer what columns represent through semantic analysis
- 5 Query with SQL and start from semantically relevant visualizations
Where Postcone fits
A good fit when reducing event-to-analysis setup matters more than assembling or customizing every layer yourself.
Postcone tradeoff
Postcone has fewer connectors, less component choice, and fewer mature enterprise workflows than a best-of-breed stack.
Pricing
Start small. Pay for what you use.
A simple monthly base gives your workspace access to Postcone. Infrastructure usage scales with your workload.
Common event-pricing benchmark
~$0.50/ 1 million events
Many event platforms quote pricing this way. At current rates, Postcone is approximately $0.50 per million events for a typical workload; actual billing follows the infrastructure units shown here.
Base access
One workspace, one monthly base
$10/month
Plus usage
Compute
$0.10
per compute hour
Billed to the millisecond
Storage
$0.023
per GB-month
Egress bandwidth
$0.01
per GB of egress
Storage operations
Class A
$0.05
per 10k ops
Class B
$0.005
per 10k ops
Usage is metered from underlying infrastructure consumption. Actual cost depends on event size, retention, query activity, and workload.
Your first event is enough to start
Go from JSON to a queryable analytical table in minutes.
Create a workspace, choose a table path, and send the application event you already have.