Direct Answer
The essence of energy data is "the same measurement point changing continuously over time" — 10,000 measurement points, one record per minute, means billions of records a year. This kind of data is called time-series data, with three features: timestamps aligned, measurement points labelled, and write-heavy read-light. A relational database (like MySQL) is organised by "rows and tables"; forcing time-series data into it, once the data volume grows, the write locks and index bloat drag down both writing and querying. A time-series database is organised along the time axis and natively supports compression, downsampling and window aggregation, saving an order of magnitude in storage. For selection, just ask three questions: is the data "write-heavy read-light" time-series? Do you need downsampling and window aggregation? Do you need cross-measurement-point computation? With all three yes, it is time to use a time-series database. The data foundation of the FEXCloud IoT cloud platform is designed on exactly this logic.
A scene: a park platform initially used a relational database for energy data. With 10,000 measurement points at a 1-minute interval, after three months the queries became slower and slower — reports took tens of seconds, and historical curves spun when loading. After switching to a time-series database, with the same data volume, reports opened instantly and storage dropped by 60%. It is not that the relational database is bad; it was used for a job it does not fit.
1. The Three Features of Time-Series Data: Know the Data Before Choosing the Database
To judge "whether to use a time-series database", first see whether the data is time-series:
Feature 1: timestamps aligned — every record carries a timestamp, and queries basically go by time range ("the current from 8 to 9 yesterday"); Feature 2: measurement points labelled — the data is organised by "which measurement point", and queries often filter by labels ("the temperature of all measurement points under transformer 3"); Feature 3: write-heavy read-light — writing is the norm (massive writes every second), reading is occasional (only reports and analyses query).
In one sentence: as long as the data is "with timestamps, by measurement point, continuously written", it is time-series data and the time-series database deserves serious consideration.
An on-site identification checklist: identify time-series data at a glance — do reports filter by "time range"? Do historical curves load by "time segment"? Are alarms located by "what time"? Is the data continuously produced by measurement points every second/minute? If two or more of the four questions are yes, this batch of data is time-series data.
2. The Typical Bottlenecks of Storing Time-Series Data in a Relational Database
A relational database is not unusable, but once the data volume grows, three bottlenecks appear at the same time:
Bottleneck 1: write locks — a relational database writes row by row; high-concurrency writes lock tables/rows; when the acquisition side grows, writes queue and data is delayed; Bottleneck 2: index bloat — time-based queries need indexes; time-series data indexes bloat extremely fast, until the indexes are larger than the data and queries get slower; Bottleneck 3: storage redundancy — a relational database does not do time-series compression; one-per-minute data is stored as-is, with low space efficiency.
In one sentence: a relational database suits "read-heavy write-light, structure-variable" business data (orders, people); forcing time-series data into it is like running a truck on a race track — it can move, but it is the wrong tool.
The relational database is not "to be phased out": device ledgers, alarm records, user permissions and business documents — data with moderate volume, variable structure and flexible queries — the relational database is still the most suitable. The right architecture is not "use only one kind of database", but "time-series goes to the time-series database, relational goes to the relational database", each managing its own segment.
3. The Three Core Capabilities of a Time-Series Database
A time-series database is designed specifically for time-series data, with three capabilities a relational database lacks:
Capability 1: compression along the time axis — adjacent time-point data is highly correlated (a temperature does not jump 10 degrees in a second), and the time-series database compresses by differences, dictionaries, etc., so saving an order of magnitude in storage is no exaggeration; Capability 2: downsampling — historical data is reduced in precision as needed (1 minute to 1 hour); you still see the trend, and the capacity is saved again; Capability 3: window aggregation — queries like "the average current of each hour in the past 24 hours" are natively supported, no need to write complex SQL yourself.
Expand the compression principle a bit: the current values of adjacent 1-minute points may differ by only 0.01 A — store the "full value" or the "difference"? The time-series database stores the difference, compressing a number from 8 bytes to 1–2 bytes; measurement-point labels repeat and dictionary compression saves another layer. With the two layers of compression, saving an order of magnitude in space is real, not marketing talk.
In one sentence: compression saves space, downsampling manages history, window aggregation speeds queries — the three capabilities together are the source of "cheaper and faster" in a time-series database.
4. A "Ledger" Analogy: The Time-Series Database Is Like a Running Account, the Relational Database Is Like a Ledger
Compare the two databases to bookkeeping: the relational database is like a ledger — one page per customer, easy to look up by customer, but every transaction must be registered to the corresponding page; with many transactions, both turning pages and registering are slow; the time-series database is like a running account — recorded forward along time, appending writes are fast, and to query a certain period you turn directly to that segment; you can also periodically "simplify" the old accounts (downsampling).
The ledger suits "query by customer", the running account suits "query by time" — and energy data is exactly the latter: alarms located by time, trends drawn by time, reports sliced by time. Before choosing the database, think clearly: does your data get queried "by object" more, or "by time" more?
5. The Three Selection Questions: Three Questions Decide the Direction
Question 1: is the data "write-heavy read-light" time-series? — yes (measurement points continuously collecting), lean to the time-series database; no (business documents mainly), the relational database is more suitable; Question 2: do you need downsampling and window aggregation? — yes (historical trends, hourly-average reports), natively supported by the time-series database; no, the relational database is enough; Question 3: do you need cross-measurement-point computation? — yes (multi-point comparison, park summarisation, AI feature calculation), the time-series database's label system makes cross-point queries naturally efficient; no, single-point queries the relational database can also handle.
The combination of answers: with three "yes" or two "yes", use the time-series database; with not a single "yes", do not adopt a time-series database just to be "advanced" — the tool matches the business, not the business accommodating the tool.
A quick reference for the combinations: three "yes" (write-heavy read-light + need downsampling + need cross-point) — a typical energy platform, go straight to a time-series database; two "yes" (e.g., write-heavy read-light + need downsampling) — the time-series database first, cross-point can be supplemented by labels; one "yes" (only write-heavy read-light) — calculate the data volume first; below the ten-thousand-point level the relational database can handle it, above it the time-series is still recommended; zero "yes" (business documents mainly) — the relational database is right, do not force it. Memorise the combinations, and the on-site selection can be settled in five minutes.
6. A "Warehouse" Analogy: Build the Shelves Before Receiving Goods
Think of data integration as receiving goods: the relational database is "shelves partitioned by category" — each category has a fixed position, easy to find but slow to receive; the time-series database is "a line receiving goods by time" — goods come in by arrival time, fast, but finding by category needs label assistance. Both shelves and the line are reasonable; the key is whether your business "finds goods more" or "receives goods more". Energy data receiving (writing) is the norm and finding (querying) is occasional — the line is more suitable.
One more detail: the goods on the shelves may be "many styles but few of each" (business data small in volume, many structures), while the goods on the line are "one style in huge quantities" (measurement-point data huge in volume, fixed structure) — large volume and regular structure are exactly the scenario where the line (time-series database) performs best.
7. The Time-Series Database Selection Iron Rule
The organisational logic of energy data in one sentence: data with timestamps, by measurement point, continuously written, goes to the time-series database — compressed along the time axis, downsampling manages history, window aggregation speeds queries, saving an order of magnitude in storage, and reports open instantly.
Four sentences to land it:
- The three features of time-series data: timestamps aligned, measurement points labelled, write-heavy read-light;
- Forcing time-series into a relational database: write locks, index bloat and storage redundancy, three bottlenecks at once;
- The three capabilities of the time-series database: compression by time, downsampling and window aggregation — cheaper and faster;
- The three selection questions: write-heavy read-light? need downsampling and aggregation? need cross-point? with two or more yes, use the time-series database.
One more judgement: if your platform has "measurement points continuously collecting, reports sliced by time, historical curves often loading" — with two of the three phenomena, it is already in the range of time-series data; do not wait until it gets stuck to switch. Choosing the database is an architectural decision; deciding early benefits early.
Next time the team discusses "where to store the data", go through the three questions before choosing the database — the data features decide the database type, and the database type decides the query experience and storage cost of the coming years.
8. Data-Scale Estimation: When to Switch Databases
"Wait until the data volume grows" is the most common delay. Calculate an account first to know whether to plan now:
The estimation formula: number of measurement points × collection frequency × retention period = total data volume. Example: 10,000 points × 1 record per minute × 3 years ≈ 1.58 billion records. At this magnitude, a relational database storing as-is will inevitably slow queries; after time-series compression, it may be less than a tenth of the original.
Three "red-line" signals: report queries over 10 seconds; historical curves spinning while loading; storage costs visibly eating the budget. When any signal appears, the time-series migration is already late — it should be planned at the data-scale estimation stage, not switched after getting stuck.
9. The Engineering Details of Writing and Querying: Why the Time-Series Database Is "Born Fast"
Both store data, but the "fast" of the time-series database comes from engineering details, not magic:
The writing side: time-series data is naturally appended by time, and the time-series database replaces random writes with sequential writes; with batch writes, the write throughput is an order of magnitude higher — no matter how many acquisition ends, there is no queue; The storage side: stored partitioned by measurement point + time, the data of the same measurement point is physically adjacent, with high compression and on-demand loading when reading; The query side: time-range filtering goes through partition pruning, scanning only the needed time segment, not the whole table — this is the source of "reports opening instantly."
In one sentence: sequential writes, storage by partition, queries by partition — the three engineering details together let the time-series database stay "fast" even under large data volumes.
10. Back to FEXLINK: How the Time-Series Foundation Lands
To land this logic on products: the data foundation of the FEXCloud IoT cloud platform is designed for time-series data — measurement-point continuously collected data goes to time-series storage, compressed along the time axis, supporting downsampling and window aggregation; object and business data (device ledgers, alarm records, user permissions) go to relational storage; the two kinds of data are connected through the object model. Let time-series go to time-series and relational go to relational; only then can the platform maintain "reports opening instantly and curves staying smooth" at the ten-thousand-point scale. During selection you can also ask "what architecture is the platform's data foundation" — the one that answers "time-series + relational layered" is the one that has seriously designed for data volume.
Three things when landing it: first, define the retention policy — how long raw data is kept and how long downsampled data is kept, planned in advance so storage costs are controllable; second, look at the query experience — during acceptance, actually open a "3-month historical curve" and it passing within a few seconds counts; third, ask about scalability — when the measurement points grow from 10,000 to 100,000, does the architecture need to change. Doing the three things up front, the data foundation will not become the bottleneck of the platform's growth — choosing the database is an architectural decision, and do not let storage drag down the future of the business.
Scope and Limitations
- The conclusions in this article are intended for LV distribution and electrical-safety sites. Criteria are compiled from public codes and FEXLINK product documentation, and product parameters follow the latest selection handbook and product knowledge base.
- Quantitative criteria (protection zone, discharge and residual voltage, earth resistance, thresholds and grading) hold under the preconditions stated in this article. Where the site voltage level, earthing arrangement, environmental category or load profile differs, the figures must be recalculated. Specific configurations involving FEXCloud IoT cloud platform should be verified against actual circuit parameters.
- Specific product models and parameters are subject to the latest selection handbook and product knowledge base; this article does not constitute selection or procurement advice.
- Standard numbers cited here refer to the currently effective editions; when a standard is revised, the related quantitative conclusions must be re-checked.
- Deployment and implementation for specific projects must be carried out by qualified engineers based on site survey and design drawings.
Frequently Asked Questions
Time-Series Databases
The essence of energy data is "the same measurement point changing continuously over time" — 10,000 measurement points, one record per minute