TimescaleDB vs PostgreSQL native partitioning

TimescaleDB adds automatic chunking, columnstore compression, continuous aggregates and retention jobs, but several of those features need the Timescale License. Plain PostgreSQL partitioning keeps you on the PostgreSQL License with more maintenance you own.

On this page

TimescaleDB vs PostgreSQL native partitioning: when each fits

Choose TimescaleDB when automated chunk management, columnstore compression and retention jobs will save ongoing engineering work on high-volume time-series or event tables. Choose native PostgreSQL declarative partitioning when table volume is modest, your team is comfortable writing and owning maintenance scripts, and keeping the stack under the PostgreSQL License matters more than automation. Consider a team that already runs PostgreSQL and is deciding whether to add the extension to a table that is growing quickly. The decision turns on three things: which features the workload actually needs, which license applies to those features, and who will carry upgrades for both PostgreSQL and the extension.

Start with the feature list, not the brand. Partitioning by time range is available in PostgreSQL itself, so the question is what you would otherwise build by hand: creating future partitions, dropping old ones, rolling up data into summaries and compressing cold history. Continuous aggregates, the columnstore (Hypercore), data retention policies and job scheduling are available only in the TimescaleDB Community Edition, not the Apache 2 Edition. If your need is limited to partition pruning and a cron job that drops old months, plain PostgreSQL may be enough. If you need compression and rollups running unattended, the Community Edition's license becomes the central question. Under the Timescale License you can run it in your own infrastructure for free but cannot offer it as a service, so confirm the license implications with counsel before you build a customer-facing product on it.

Upgrades are where the two options diverge over time. Minor PostgreSQL releases do not change the storage format, but major upgrades need a planned path using pg_dumpall and restore, pg_upgrade, or logical replication, and the extension must also be compatible with each target version. Ask your team who owns each step, how long a restore or replication cutover would take on your data, and whether your maintenance window allows it. Native partitioning adds fewer moving parts to that process. Before deciding, run a short proof of concept on a copy of your largest table, measure the scripts you would need to replace, and write down who will be on call when a retention job fails.

Which workloads favor TimescaleDB and which favor native partitioning

This table matches common team situations to the option that fits better and the condition that decides it. Read each row against your own retention, query shape and licensing position, and check the Community Edition column first if you need continuous aggregates or the columnstore.

ScenarioBetter fitCondition that decides it
One team, modest retention, simple range queriesNative partitioningMonthly or daily partitions with a plain index on the time column are enough, and you do not need compression, rollups or built-in retention jobs. Extra extension upkeep is not justified at this size.
Platform team with many time-series tables and retention needsTimescaleDBAutomatic chunking, retention policies and job scheduling replace scripts you would otherwise maintain for every table. Retention policies are a Community Edition feature, so plan for that build.
Workloads that depend on continuous aggregates or the columnstoreTimescaleDB Community EditionContinuous aggregates, the columnstore (Hypercore) and time_bucket_gapfill are listed only in Community Edition, not the Apache 2 Edition. If you do not need them, the Apache 2 Edition may suffice.
SaaS vendor offering the database as a serviceConfirm with counsel before choosing TimescaleDB Community EditionThe Timescale License allows running Community Edition on your own infrastructure but not offering it as a service. Apache 2 Edition code can be sold as a service, but it lacks the Community Edition features. Native partitioning carries no such restriction because PostgreSQL uses the PostgreSQL License.
Regulated internal team that must keep licensing simpleNative partitioningPostgreSQL is under the PostgreSQL License, similar to BSD or MIT. Adding TimescaleDB introduces a second license with separate file-level terms that your legal and procurement teams must review.
Team that needs time-series rollups and analytics joined with relational dataTimescaleDB Community EditionContinuous aggregates and time_bucket functions keep time-series analysis in SQL alongside your existing tables. Confirm that the Community Edition license fits your deployment model before committing.
Team that wants fewer self-managed maintenance tasksDepends on managed or self-hosted choiceTiger Cloud handles operations in exchange for a subscription, while self-hosted TimescaleDB keeps the extension upgrades and backups with your staff. Compare plan prices and support levels with the operating effort you can staff.
Team with strict upgrade windows across PostgreSQL majorsNative partitioningEvery extension must support each PostgreSQL major you move to, so each major upgrade adds a compatibility check. Confirm extension version support for your target PostgreSQL release before you plan the upgrade.

How hypertables and native partitions are built and operated

Both approaches split a large PostgreSQL table by time, but they differ in who creates the pieces, where the logic lives and what runs on a schedule. The cards below follow one time-series table through each model and name the duties that stay with your team.

Hypertables present one table over many chunks

TimescaleDB presents a hypertable to queries as a single table and creates child chunks behind it as rows arrive. Your application writes to the hypertable name, and the planner excludes chunks outside the time range of a query. Create a hypertable with the tsdb.hypertable table option shown in the quick start, then confirm the chunk interval suits your ingest rate and query windows before loading production data.

Declarative partitions are created and attached by you

Native declarative partitioning splits a table into partitions defined with PARTITION BY and attached to a parent. PostgreSQL does not create new time ranges for you, so each new partition must be created and attached before data arrives for its range. Decide who owns that step, whether a cron job, a migration tool or an application routine, and what happens if it fails.

The extension loads into the same cluster

TimescaleDB is installed as an extension inside an existing PostgreSQL database, so it runs in the same server processes, catalogs and backup scope as your other data. Adding it changes the set of installed packages you must track during every PostgreSQL major upgrade. Confirm that your PostgreSQL version and your extension build are supported together before you plan an upgrade window.

Columnstore sits on top of the hypertable

The columnstore compresses older chunks in a columnar layout, which is an add-on to hypertables rather than a separate table you maintain. Compression is configured per hypertable and applies on a schedule, so you still query one table. Native partitions have no equivalent built in, so teams using them typically compress or archive old partitions with their own tooling. Check which TimescaleDB build provides the columnstore before you commit to a design.

Continuous aggregates and retention run as jobs

Continuous aggregates keep rollup tables current as new data arrives, and retention policies drop or manage expired chunks through the job scheduler. In the native model, rollups are refreshed by your own jobs and old partitions are detached or dropped by scripts you write and monitor. Ask who restarts failed jobs, how you alert on a stalled refresh, and where the schedule is recorded.

Operator duties in each model

With native partitioning, your team owns partition creation, retention, compression, rollup refresh and their monitoring as custom code. With TimescaleDB, most of those duties move into extension policies and jobs, but you still own the extension version, its license scope and the scheduler's health. Write down each recurring task, its owner and its failure alert before choosing a model.

Which time-series features TimescaleDB adds over native partitioning

This table sets the features TimescaleDB adds to a PostgreSQL database against what native declarative partitioning and your own scripts provide. Rows marked as TimescaleDB-only depend on the Community Edition under the Timescale License, while native PostgreSQL rows describe general capabilities you should confirm for your PostgreSQL version. The main takeaway is that the extension adds automation and time-series functions, but it also adds a license and upgrade dependency you need to plan for.

CapabilityTimescaleDBNative PostgreSQL partitioning
Automatic chunkingHypertables create and manage time-based chunks automatically as data arrivesPartitions are declared and created by you, or by scripts you maintain
Columnstore compressionColumnstore (Hypercore) is available only in Community Edition, not the Apache 2 EditionNo built-in columnar compression for partitions; confirm current options for your version
Continuous aggregatesAvailable only in Community Edition, not the Apache 2 EditionNot built in; typically handled with materialized views refreshed by your own jobs
Data retention policiesAvailable only in Community Edition, not the Apache 2 EditionDropping old partitions is done by your own scripts or scheduler
Job schedulingBuilt-in job scheduling is available only in Community EditionRequires an external scheduler such as cron or pg_cron, which you operate
time_bucket_gapfillAvailable only in Community Edition, not the Apache 2 EditionNot provided; gap filling is written as custom SQL
PostgreSQL licenseApache 2.0 for code outside the tsl directory; Timescale License for Community Edition codePostgreSQL License, a liberal license similar to BSD or MIT
Apache 2 Edition availabilityAvailable under Apache 2.0, and it can be sold as a serviceNot applicable; PostgreSQL itself carries no extension license split
Replication and high availabilityInherits PostgreSQL streaming and logical replication; confirm extension support for your setupHot standby, synchronous and asynchronous replication; automatic failover needs external tools
Authentication methodsUses the PostgreSQL client authentication methods, including SCRAM, certificate and OAuthPassword, GSSAPI, SSPI, LDAP, RADIUS, certificate, PAM and OAuth
Major version upgradesConfirm extension version compatibility with each PostgreSQL major version before upgradingpg_upgrade, pg_dumpall with restore, or logical replication between major versions

What the licenses allow when you add the extension

PostgreSQL is released under the PostgreSQL License, a liberal open-source license similar to the BSD or MIT licenses. The license covers the core server, and it does not attach a paid edition to that software. What you pay for is the work around it: hosting, staff, backup tooling, monitoring and any support contract you choose to buy from a third party. Support is time-bound by major version, which affects how long your partitioned tables can stay on a given release.

  • Free to use and modify: the license places no paid tier on the core server, so you can run it on premises, in your cloud account or on an air-gapped network.
  • Native partitioning is included: declarative partitioning and the maintenance you script yourself are part of the core product, with no extension to license.
  • Support windows by major version: per the PostgreSQL versioning policy, 14 is supported until November 12, 2026, 15 until November 11, 2027, 16 until November 9, 2028, 17 until November 8, 2029 and 18 until November 14, 2030.
  • Vendor support is a separate purchase: the license does not include a support contract, so any commercial support, hardened distribution or extended maintenance is priced by the provider you choose.

Check which major version you will be running when your planned retention window ends, and confirm with your support provider what they cover for that version.

What drives the running cost of each option

The running cost of either path is set less by the license than by who carries the recurring work. With plain PostgreSQL, the license costs nothing, and the spend is infrastructure for the primary and standbys, the engineering time to script and monitor partition creation, detachment and retention, and the upgrade work. PostgreSQL is released under the PostgreSQL License, and it ships a new major version about once a year, supported for five years. PostgreSQL 14 is supported until November 12, 2026, so a team running it has a near-term major upgrade on its calendar. Major upgrades use pg_dumpall and restore, pg_upgrade, or logical replication, and each choice has a different outage profile. One-time costs are the partition design, the migration of existing data and initial tuning. Recurring costs are the partition maintenance jobs, monitoring, on-call and the yearly upgrade cycle.

With TimescaleDB, you add the cost of the extension itself. The Apache 2 Edition is free to use, but continuous aggregates, the columnstore, retention policies and job scheduling are only in the Community Edition under the Timescale License. That license lets you run Community Edition for free in your own infrastructure, but not offer it as a service, so an internal platform team usually pays nothing for the license, while a company selling a service on it needs to read the terms carefully. Upgrades now cover two components: PostgreSQL and the extension, with TimescaleDB 2.30.2 published September 29, 2026. Tiger Cloud is the other route. Its published Performance plan starts at $30 per month and Scale at $36 per month (Tiger Data pricing page), with a free 30-day trial of Performance. Those figures are starting prices that exclude your own time, and Enterprise is custom priced.

Self-hosted costs depend on your environment, including your cloud or data center rates, storage volume, replica count and staffing, so confirm them against your own numbers. Before asking for a quote from DeployOpen or any provider, request a written scope that states who runs high availability, including whether automatic failover tooling is included, since PostgreSQL does not detect primary failure on its own. Ask what backups cover (base backups, WAL archiving and point-in-time recovery testing), who performs and verifies PostgreSQL and extension upgrades, and how often they occur. For Tiger Cloud, ask which support level applies, as developer email support is included on all plans, while 24x7 production support is a paid add-on and is included in Enterprise with a 1-hour response time for Sev 1 issues. Ask both sides to state the one-time and recurring items separately.

Moving a native partitioned table to TimescaleDB, or back

This sequence shows how an existing PostgreSQL database with partitioned time-series tables moves onto the TimescaleDB extension, and how to reverse the change if the extension is later dropped. It ends with a cutover decision your team can verify.

  1. Confirm the PostgreSQL major version and extension build

    Your database administrator records the running PostgreSQL major version and checks it against the TimescaleDB release notes and compatibility matrix before anything else changes. The output is a written pairing of PostgreSQL major version, TimescaleDB version and the chosen build, either the Apache 2 Edition or the Community Edition under the Timescale License. Confirm this pairing with the vendor if the versions are not in the supported list for your environment.

  2. Choose the upgrade path for the cluster

    Pick how the cluster itself will move if the PostgreSQL version also changes, using pg_dumpall and restore, pg_upgrade, or logical replication. The PostgreSQL upgrading documentation covers each option, and logical replication works between different major versions. Your team owns this decision, and the output is a documented runbook with a named rollback point.

  3. Install the extension and test on a copy

    Install the chosen TimescaleDB build on a restored copy of production, then load it with the extension enabled in a test cluster. Your team checks that the extension loads without errors and that existing partitioned tables are still readable. The output is a test log showing the extension version and a clean load.

  4. Convert partitioned tables to hypertables

    Convert each time-partitioned table into a hypertable, which replaces manual child-partition creation with automatic chunking on the time column. Your engineers run the conversion in the test copy first and confirm row counts, indexes and the time column match the source. The output is a per-table conversion record with those checks passed.

  5. Rebuild retention, compression and aggregate jobs

    Recreate retention policies, compression settings and continuous aggregates on the hypertables, because your old partition-dropping scripts and maintenance jobs do not carry over. Confirm which of these features your build includes, since continuous aggregates, the columnstore and retention policies are Community Edition features. The output is a job inventory that matches the old scripts, with each job scheduled and visible.

  6. Verify queries, roles and backups before cutover

    Run your application's SQL against the converted copy, confirm that roles, grants and authentication settings still apply, and test a restore from your backup set. Confirm that the queries you depend on are supported on hypertables, and document any that need rewriting. The output is a signed-off test report and a tested restore.

  7. Plan the reverse path if the extension is dropped

    Document how hypertables would convert back to plain partitioned tables, including exporting data, recreating partition scripts and removing extension-specific jobs. Confirm the reverse steps on a test copy so you know the cost before you commit. The output is a tested rollback procedure that your team can run if the license, support or operating model changes.

Where TimescaleDB and native partitioning projects usually run long

Native partitioning projects usually run long on the operating work around the tables, not on the `CREATE TABLE ... PARTITION BY RANGE` statement itself. Your team owns the partition creation script that runs ahead of each time window, the retention script that detaches and drops old partitions, the monitoring that proves both jobs ran, and the failure handling for a missed run. Each of those pieces is code your engineers write, test, schedule and maintain. The schema work is usually quick. The scripts, their alerting and their runbooks take the time, and they recur for the life of the system. TimescaleDB projects run long on different decisions. Installing the extension is simple, but you must pin the TimescaleDB version to a PostgreSQL major version and plan each upgrade of both. Before the first install, decide between the Apache 2 Edition and the Timescale License Community Edition, because continuous aggregates, the columnstore, retention policies and job scheduling sit only in the Community Edition. If you plan to offer the database as a service to others, confirm the license position with Tiger Data and your counsel before build starts.

Whichever path you choose, PostgreSQL does not provide automatic failover on its own, so you need external tooling for high availability. PostgreSQL detects no primary failure and notifies no standby, so your HA design, whether built on a consensus-based tool or a managed arrangement, is a separate workstream that applies to both options. Test it with a planned failover and a failed-primary drill before go-live. Untested major upgrades are the most common late surprise: confirm which PostgreSQL major version you will run, whether pg_upgrade or logical replication fits your downtime limit, and how the extension is upgraded in the same window. In a fixed-scope written plan, ask for explicit answers to four questions: the written retention rules per table, the edition and license position for your use, the named HA and backup tooling with its test evidence, and the upgrade plan for both PostgreSQL and the extension. Each open answer is a common source of schedule slip, so resolve them before the statement of work is signed.

Questions buyers ask before adding TimescaleDB to PostgreSQL

Is native partitioning enough for our time-series volume and retention window?

Native partitioning is often enough when write volume is moderate, queries mostly filter on the partition key, and retention is a simple drop of old partitions. The deciding drivers are the number of partitions you will create, how often queries span many of them, and whether you need compression or pre-computed rollups. Measure your own ingest rate, query shapes and partition count against a staging copy before deciding. Adding TimescaleDB makes most sense when chunk management, columnstore compression, continuous aggregates and retention jobs would otherwise become scripts your team must write, test and keep running. The TimescaleDB editions page lists which of these features sit in the Community Edition, which affects the comparison directly.

Can our own team migrate from native partitioning to TimescaleDB?

A capable PostgreSQL team can usually run a small migration with the documentation, provided it has a tested rollback path and a clear owner for query changes. The work depends on table count, whether partitions are already in place, the size of existing data, and how much application SQL must change. Teams that lack a staging environment, have strict change windows, or run many dependent objects tend to need outside help for planning and testing. DeployOpen can plan, implement and document that work under a fixed-scope agreement, with scope and deliverables agreed in writing before anything starts. Ask your team to inventory partitions, indexes, triggers and downstream reports first.

How much extra effort does an extension upgrade add next to a PostgreSQL major upgrade?

Each PostgreSQL major upgrade is a separate event that requires checking the extension against the new server version, then upgrading the extension itself. The PostgreSQL documentation describes major upgrades through pg_dumpall and restore, pg_upgrade, or logical replication, and minor releases only replace executables and restart. Logical replication works between different major versions and can keep downtime to several seconds, but the extension must still be supported on both sides during the transition. Ask the vendor which PostgreSQL versions each TimescaleDB release supports before you commit to a version path, and include the extension in your upgrade test plan rather than treating it as a footnote.

Does the Timescale License block our internal use of Community Edition?

The Timescale License permits you to install TimescaleDB Community Edition in your own on-premises or cloud infrastructure and run it for free. The restriction that matters is that you cannot offer it as a service, which is why the Apache 2 Edition is the option for resale. Internal analytics, internal tools and most enterprise workloads fall on the permitted side, but counsel should confirm how your specific use fits the license text. Read the TimescaleDB license file yourself, since it separates Apache-licensed code outside the tsl directory from Timescale-licensed code inside it.

Can a SaaS product that we sell to customers run on Community Edition?

Probably not without a licensing decision, because the Timescale License prohibits offering TimescaleDB Community Edition as a service. A product that exposes time-series storage to customers through a hosted offering may be treated as offering the software as a service, while a product where the database stays hidden inside your own application is a different question. The Apache 2 Edition is licensed for that use, but it lacks continuous aggregates, the columnstore, retention policies and job scheduling. Have legal review the exact deployment model, and compare the feature gap with your product requirements before choosing a build.

How long does a fixed-scope TimescaleDB implementation take and what drives it?

Duration depends on the number of hypertables to design, the volume of data to move, how many queries and dashboards must be rewritten, and the number of environments that need validation. Retention and compression policies add testing time because each must be checked against real query patterns and recovery procedures. DeployOpen does not publish fixed durations, and most engagements are scoped in writing before work starts, so the timeline follows from that agreed scope. Ask for a written breakdown of design, migration, testing, documentation and handover, with the assumptions behind each phase.

What does the work need from our client team?

The work needs a named technical owner who can make schema decisions, a database administrator who knows your backup and recovery process, and application engineers who can change queries. Security or compliance staff should review access controls, encryption, and how the extension fits your change management process. Someone must also approve test data, maintenance windows and cutover criteria. Confirm these time commitments during scoping, because a team that cannot release people for testing usually extends the schedule more than any technical issue does.

What does a retainer cover after go-live?

A retainer is an ongoing arrangement for support, upgrades and continuous testing after the initial implementation. For TimescaleDB, the practical items include planning extension upgrades alongside PostgreSQL major versions, reviewing retention and compression jobs, checking backups and point-in-time recovery, and handling incidents. The exact coverage, response expectations and included work are defined in the written agreement, so ask for those terms rather than assuming them. If you also buy managed hosting from the vendor, check which support tier applies, since the published support options differ by plan.

How DeployOpen helps choose, implement or migrate

DeployOpen helps teams decide whether a time-series table needs TimescaleDB or plain PostgreSQL partitioning, then implements the chosen design inside your own infrastructure. The work covers the schema, the retention and maintenance jobs, the upgrade path for both PostgreSQL and the extension, and the documentation your operators need afterward.

How we scope

  • Engagements are fixed-scope, with the schema, data volumes, query patterns and retention needs agreed in writing first.
  • The written scope states which TimescaleDB edition, if any, is in play, and which license terms apply to your internal use.
  • Scope names the PostgreSQL major version, hosting location and whether maintenance scripts stay or move into the extension.

How we build

  • We build a test copy of your time-series tables and run representative queries against both partitioned and extension-based designs.
  • We implement chunking, compression, aggregates and retention jobs only where the scope confirms they are needed and licensed.
  • We test restore, upgrade and failover behavior on your own environment before anything reaches production.

How we hand over

  • Handover includes runbooks for partition creation, retention, extension upgrades and PostgreSQL minor and major updates.
  • Documentation records the license position for the edition chosen, so your legal and procurement teams can review it.
  • Operators receive a walkthrough of monitoring, job failures and the steps to roll back a schema change.

How we support

  • Ongoing support, upgrades and continuous testing are available as retainers once the platform is live.
  • A retainer can cover extension version reviews against PostgreSQL support windows, so upgrades are planned rather than reactive.
  • Support scope, response expectations and review cadence are confirmed in writing before the retainer starts.

Sources and further reading

Talk to our team.

Tell us what you're working on, whether it's a deployment, an audit, a security test or a cyber range. You'll speak with an engineer who can help you scope it.

  • 30-minute call: free, with no obligation.
  • NDA on request: we can sign before you share details.
  • Clear next steps: a scope and plan after the call.