Sai_Prajoth

@kirat_tw @TimescaleDB please the codes for the timescaleDB-Lab below: github.com/saiprajoth/tim…

I’m building a PostgreSQL + TimescaleDB real-time analytics support lab — a database debugging and performance engineering tool. @kirat_tw @TimescaleDB The goal is simple: Build a realistic system that forces me to deal with the kinds of problems that happen when time-series data grows large. The sample domain I’m using is EV charging telemetry, but the patterns apply to IoT metrics, server monitoring, stock ticks, industrial sensors, app analytics, and any high-volume time-series workload. Current architecture: Generated EV charger telemetry → PostgreSQL + TimescaleDB → Hypertable for charger metrics → SQL analytics queries → Go API → Grafana dashboard → Performance cases + support runbooks The project is being built in phases. Phase 1 is the foundation: * npm + Turborepo monorepo * Docker Compose local stack * PostgreSQL + TimescaleDB * Grafana provisioning * Clean database schema * CLI-first setup scripts * One-command local setup * Verification scripts for schema and database state The schema separates metadata from time-series data: * `stations` * `chargers` * `charger_metrics` * `charging_sessions` * `alerts` The important table is `charger_metrics`. That table stores timestamped telemetry like: * power_kw * energy_kwh * voltage_v * current_a * temperature_c * charger status * station_id * charger_id I designed it so it can be converted into a proper TimescaleDB hypertable instead of treating time-series data like a normal relational table forever. The next core piece is scale. Small datasets make database projects look better than they really are. So this lab is designed to support: * small dev seed: ~100k rows * interview/proof seed: 1M+ rows * future stress mode: 5M+ rows For the 1M-row mode, the data model is roughly: 100 chargers × 35 days × readings every 5 minutes = 1,008,000 telemetry rows That creates enough data to make query plans, indexes, chunks, and aggregation strategy actually matter. The real goal is not just to say “I used TimescaleDB.” The goal is to prove: 1. I can model time-series data correctly. 2. I can convert telemetry into a hypertable. 3. I can generate realistic high-volume data. 4. I can write analytical SQL queries. 5. I can inspect query plans with `EXPLAIN ANALYZE`. 6. I can identify slow dashboard queries. 7. I can improve them with indexes and continuous aggregates. 8. I can add compression and retention policies. 9. I can document the debugging process clearly. 10. I can explain the fix like I’m helping a real customer. The project will include performance cases like: “Dashboard is slow after 30 days of data.” Investigation: * inspect the query * run `EXPLAIN ANALYZE` * check whether it scans raw hypertable data * inspect indexes * check chunk usage * compare raw aggregation vs precomputed aggregate Fix: * add the right index * create a continuous aggregate * query the aggregate instead of raw telemetry * measure before/after performance The final output will not just be code. It will include: * reproducible Docker setup * schema files * seed scripts * TimescaleDB hypertable setup * query files * `EXPLAIN ANALYZE` before/after * benchmark results * Grafana dashboard * Go API * architecture docs * support-style runbooks * customer-facing explanations I’m treating this like a serious database support and performance engineering lab. Not just: “I built an app with PostgreSQL.” But: “I built a reproducible environment to debug PostgreSQL/TimescaleDB workloads under realistic time-series data volume.” The most interesting part so far: The schema constraints already caught a bug in my seed generator. I had session `ended_at` sometimes generated before `started_at`. Instead of weakening the schema, I fixed the data generator. That’s exactly the kind of mistake good constraints should catch. This is why I like building projects this way. The database is not just storage. It actively protects correctness. Next milestones: * finish 1M+ seed mode * add basic analytics queries * add first-pass indexes * build Go API * provision Grafana panels * add continuous aggregates * add compression * add retention policies * create the first full slow-query performance case The final benchmark format will be: Problem → Reproduction → Query plan → Root cause → Fix → Before/after result → Support-style explanation That is the level of proof I want from this project. Code is useful. But reproducible debugging evidence is much stronger.

Ather DB update I : theoritical understanding of database working before buidling it. A. Preliminary understanding the db internals - atomicity & durability, why they matter - naive ways -- solutions to it, like for inplace updating (which is not optimal way), atomic renaming, and logs. - necessity of indexing data structures for making queries faster. - database should have - Atomicity & durabilty, concurrency, tables, query execution. B. Query Level - exploring various datastructures to fit for the indexing datastructure. - maps, arrays ,others were considered but B-trees, the n-ary B-trees were considered because of lower no of levels, meaning lower number of reads/lookups , which is optimal. - Log Sum Trees (LSM) were too considered, which use mutli level non-frequent updations to avoid the writing amplification @kirat_tw @Hiteshdotcom

AtherDB update I : A. understanding the db internals - atomicity & durability, why they matter - naive ways -- solutions to it, like for inplace updating (which is not optimal way), atomic renaming, and logs. - necessity of indexing data structures for making queries faster. - database should have - Atomicity & durabilty, concurrency, tables, query execution. B. - exploring various datastructures to fit for the indexing datastructure. - maps, arrays ,others were considered but B-trees, the n-ary B-trees were considered because of lower no of levels, meaning lower number of reads/lookups , which is optimal. - Log Sum Trees (LSM) were too considered, which use mutli level non-frequent updations to avoid the writing amplification @kirat_tw @Hiteshdotcom

@kirat_tw please find the github link for the database code : github.com/saiprajoth/Aet…

I have planned to write the database from scratch. the resource I would be following is of manning publication named : Build Your Own Database From Scratch in Go The plan is to create an MVP and then upgrade it further resource : build-your-own.org/database/ @kirat_tw @SuperteamIN @Hiteshdotcom

I have planned to write the frontend framework from scratch. the resource I would be following is of manning publication named : Building a frontend framework from scratch the plan is to create an MVP and then upgrade it further resource : manning.com/books/build-a-… @kirat_tw @Hiteshdotcom

Building things from scratch is best engineering. attempt to build frontend framework Database Backend Framework Runtime from scratch, would teach a lot more things. building apps on this built stack is the cherry on cake.

SuperBuild update III : works done : 1. component framework architecture done. 2. flexible APIs architecture - by which user can make apis , without explicitly writing any code. pending : 3. API binding with frontend : idea - using action based API block linkages 4. DataBase Integration. [demo of the update will be presented in the next post] @Hiteshdotcom @kirat_tw

also : - all the pages built are responsive. - compatible on all the browsers. - compatible to all screen modes. future plan : - more actions to be integrated to other components. - build flexible APIs. - build Database integrations. - a product that enable user to built an app (web app for now.

I'm working on a project - SuperBuild : A no-code platform for developers which is attempting to address these issues. Right now, I'm aiming for building an MVP first, then would like to polish it well. you'all can track the app progress at github.com/saiprajoth/Sup… @kirat_tw

long time - no see update 03 : superbuild works done : 1. component framework architecture done. 2. flexible APIs architecture - by which user can make apis , without explicitly writing any code. pending : 3. API binding with frontend : idea - using action based API block linkages 4. DataBase Integration. [demo of the update will be presented in the next post] @Hiteshdotcom @kirat_tw

I have been building a platform for developers who actually want to get good at the things that matter. @0xffdevs is an initiative to make you financially free asap! The goal is to share my mistakes and experiences. Here's what you can do there: 📚 Learning pathways - pick a topic (Go, Rust, Solana, Bitcoin, Kafka, system design, FIRE investing, and more) and get a curated path with notes, videos you can watch right there, and the best resources. no random googling. 🤖 AI assistant - there's a chat button on every page. ask it anything - "how do goroutines work?", "explain CAP theorem", "what's a FIRE number?" - it knows the site's content. 🧮 FIRE calculator - plug in your monthly savings and see exactly how many years until you can stop working for money. also has SIP, FD, and capital gains tax calculators. 🎥 Recommended videos - handpicked YouTube videos on backend systems, Web3, and macro finance. watch inline, no tab switching. 💼 Interview experiences - real rounds, real outcomes, no sugarcoating. useful before you apply anywhere. ✉️ Subscribe - drop your email and i'll ping you when new stuff drops. that's it, no spam. All free. No account needed. Connect your MetaMask if you want gated content. You can also book a 1:1 call with me, shared all my socials on the platform! Do check it out: 0xffdevs.com

building real systems at scale will increase the curiosity to learn more about system architectures

This is my assignment for a Hong Kong based startup for Backend Engineer role In the interview we discussed on how to build scalable Multi upload function for large files and how do we generate presigned urls for short time ... Doubled down on building the presigned function and here it is what I built for now it can view presigned urls asset and download those from the bucket, its a really simple implementation of what large video recording system have in their main infrastructure ... built with go, minio, psql and simple html

Migr8 progress update I : 1. made the project setup. 2. defined schemas for the plugins - the format we take inputs, give the outputs and handle validations. 3. written manifest which represent the plugins, and written contract layer for Migr8 plugins (interfaces). 3. tests were written for the schema handling if they are working right, and compatible to the upcoming additions. 4. this changes doesn't algorithmically affect the project, but yeah , these are strong foundations which are compatible for the future additions. codes updated, can find the code in the git repository. @kirat_tw @Hiteshdotcom github.com/saiprajoth/Mig…

@Bro_9012 @kirat_tw @Hiteshdotcom sure sir thanks for this 🙏 I have sent my resume as well, will update when the app completes.

@Sai_Prajoth @kirat_tw @Hiteshdotcom hey, this is good and the path you are upto as well. are you interview-ready right now? would love to get you that, but yeah given you complete this and get the codes.

SuperBuild update II: as part of building SuperBuild, we have a progress check for the app. I have built - multi pagger mode. - integration the edit mode. - improved UI. - action integrations for the components. @kirat_tw @Hiteshdotcom progress till now :

@kirat_tw @Hiteshdotcom also : - all the pages, built are responsive. - compatible on all the browsers. future plan : - more actions to be integrated to other components. - build flexible APIs. - build Database integrations. - a product that enable user to built an app (web app for now.)