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.
| Scenario | Better fit | Condition that decides it |
|---|---|---|
| One team, modest retention, simple range queries | Native partitioning | Monthly 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 needs | TimescaleDB | Automatic 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 columnstore | TimescaleDB Community Edition | Continuous 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 service | Confirm with counsel before choosing TimescaleDB Community Edition | The 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 simple | Native partitioning | PostgreSQL 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 data | TimescaleDB Community Edition | Continuous 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 tasks | Depends on managed or self-hosted choice | Tiger 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 majors | Native partitioning | Every 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.
| Capability | TimescaleDB | Native PostgreSQL partitioning |
|---|---|---|
| Automatic chunking | Hypertables create and manage time-based chunks automatically as data arrives | Partitions are declared and created by you, or by scripts you maintain |
| Columnstore compression | Columnstore (Hypercore) is available only in Community Edition, not the Apache 2 Edition | No built-in columnar compression for partitions; confirm current options for your version |
| Continuous aggregates | Available only in Community Edition, not the Apache 2 Edition | Not built in; typically handled with materialized views refreshed by your own jobs |
| Data retention policies | Available only in Community Edition, not the Apache 2 Edition | Dropping old partitions is done by your own scripts or scheduler |
| Job scheduling | Built-in job scheduling is available only in Community Edition | Requires an external scheduler such as cron or pg_cron, which you operate |
| time_bucket_gapfill | Available only in Community Edition, not the Apache 2 Edition | Not provided; gap filling is written as custom SQL |
| PostgreSQL license | Apache 2.0 for code outside the tsl directory; Timescale License for Community Edition code | PostgreSQL License, a liberal license similar to BSD or MIT |
| Apache 2 Edition availability | Available under Apache 2.0, and it can be sold as a service | Not applicable; PostgreSQL itself carries no extension license split |
| Replication and high availability | Inherits PostgreSQL streaming and logical replication; confirm extension support for your setup | Hot standby, synchronous and asynchronous replication; automatic failover needs external tools |
| Authentication methods | Uses the PostgreSQL client authentication methods, including SCRAM, certificate and OAuth | Password, GSSAPI, SSPI, LDAP, RADIUS, certificate, PAM and OAuth |
| Major version upgrades | Confirm extension version compatibility with each PostgreSQL major version before upgrading | pg_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.
Source code outside the tsl directory of the TimescaleDB repository is licensed under the Apache License 2.0. The Apache 2 Edition is the build that leaves out the Timescale License code, so it is the build to consider if you want Apache terms across what you ship. It does not include the automation features that the Community Edition adds for time-series tables.
- Apache 2.0 for the included code: the permissive terms let you use, modify and redistribute that code, subject to the notice and attribution conditions of the license.
- Can be offered as a service: according to Tiger Data's editions page, the Apache 2 Edition can be sold as a service, which the Community Edition cannot.
- No columnstore, continuous aggregates or retention jobs: the same editions page lists continuous aggregates, the columnstore, data retention policies, job scheduling and
time_bucket_gapfillas Community Edition only. - Maintenance moves to your scripts: without those features, compression, rollups and expiry of old partitions are handled by native PostgreSQL partitioning plus jobs your team writes and runs.
Before you choose this build, compare the Community Edition feature list against your workload, because the license is the easier decision and the feature gap is the harder one.
Shared object files with -tsl in their names, along with code inside the tsl directory, are licensed under the Timescale License. The Community Edition is the build that carries those features. Under these terms you can install it on your own on-premises or cloud infrastructure and run it for free. You cannot offer it as a service, according to Tiger Data's editions page and the TimescaleDB LICENSE file.
- Free self-run use: running the Community Edition on infrastructure you control carries no license fee under the terms described in the supplied licensing sources.
- Feature set included: continuous aggregates, the columnstore, data retention policies, job scheduling and
time_bucket_gapfillcome in this build, so they are not sold as separate add-ons. - Service restriction: you cannot offer the Community Edition as a service to third parties, so a hosted product or a managed offering for customers falls outside these terms.
- Internal use is the usual fit: running it for your own applications and staff is the scenario the free self-run permission describes, but the boundary between internal use and a service offering is the point to confirm.
Write down each customer-facing use case and check it against the service restriction before you commit the architecture, and ask counsel to confirm the terms for your situation.
Tiger Cloud is Tiger Data's managed service, and its plans are priced separately from the license terms above. Running the Community Edition yourself does not include a Tiger Cloud subscription, and the managed plans carry their own terms and support levels. The published starting prices are listed on Tiger Data's pricing page, and a free 30-day trial of the Performance plan is available.
- Performance plan: starting at $30 per month, according to Tiger Data's pricing page.
- Scale plan: starting at $36 per month, per the same page.
- Enterprise plan: custom pricing, which includes 24x7 production support with a 1-hour response time for Sev 1 issues.
- Developer support: email support is included on all plans, with 24x7 production support sold as a paid add-on outside the Enterprise plan.
Ask Tiger Data in writing which plan and terms apply to your planned use, and confirm whether the service meets your data location and residency requirements before you rely on it.
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.
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.
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.
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.
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.
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.
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.
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.

