u/Realistic-Peach5438

For the longest time I thought my bad sleep was just from stress or spending too much time at my desk. I’d wake up with a stiff neck and sore shoulders almost every morning even after getting a full night of sleep.
A few weeks ago I switched pillows after reading a bunch of discussions online and honestly the difference has been bigger than I expected. I ended up trying PlutoPillow and it feels way more supportive than the generic memory foam pillow I had before.
I’m sleeping more consistently now and not waking up constantly trying to readjust my position. Still kind of surprised a pillow could actually make that much difference.
Curious if anyone else here noticed a major improvement just from changing their pillow?

I was getting enough sleep every night but still waking up with neck stiffness and sore shoulders almost every morning. I blamed stress and bad posture for months before realizing my pillow might’ve been the actual problem.

Recently tried a PlutoPillow after seeing people mention customized pillows online and it’s honestly been way more comfortable than the old memory foam one I had before. I don’t wake up tossing around nearly as much now and my neck feels noticeably better in the mornings.

Still curious if anyone else here has had a similar experience because I never thought a pillow could make this much difference.

Hey everyone! Here is the shift-wise score analysis for MHT-CET 2026 PCB, based on data collected through CETLens. This covers 44 students across all 11 out of 12 PCB shifts from 21–26 April.

Here's the summary:

All 44 individual total scores, shift-wise:

• 21 Apr Morning: 48, 59, 70, 102, 103
• 21 Apr Evening: 51, 85
• 22 Apr Morning: 51, 52, 103, 112
• 22 Apr Evening: 59
• 23 Apr Morning: 52, 58, 59, 73, 75, 140
• 23 Apr Evening: 52, 72, 117
• 24 Apr Morning: 60, 62, 159
• 24 Apr Evening: 69, 74, 88, 92, 92, 138
• 25 Apr Morning: 56, 57, 60, 63
• 25 Apr Evening: 48, 59, 60, 111
• 26 Apr Morning: 59, 60, 64, 65, 75, 118

This data is collected entirely from students who submitted their response sheets on CETLens, so it's a self-selected sample, not a random one. Take the averages as directional, not definitive.

Will upload the same for PCM once the answer keys are out. Hoping to receive a good number of responses from PCM students.

Since CET CELL has released the notification of answer key for PCB, I'm assuming PCM will also be released very soon

Here's the link to the website — CETLens

What it does:

• Calculates your total marks (PCB/PCM both supported)
• Subject wise breakdown
• Question wise review
• Shows your position and shift averages from live community data
• Export as pdf report or shareable score card

Works with html, pdf, without any credentials shared

For knowing how to download your response sheet Please refer to this video

Let me know if you face any issues

> ⚠️ Preferably use the site on a laptop. If you're on mobile, enable Desktop Site mode in your browser for a smoother experience.

making a proper thread for this because most of the posts i can find are old as hell and the AU market seems completely different now.

customs got way tighter through 2025-2026, a bunch of vendors people used to recommend either vanished or apparently fell off quality-wise, and even the whole lab testing/transparency thing feels different compared to a year or two ago.

i’m mainly trying to stick to domestic now because i’m over dealing with customs stress. what matters to me most is:

- recent batch testing

- decent consistency over time

- actual long-term experiences, not just “my first order landed”

curious if anyone here has been using the same source for like 12+ months and still feels confident in them now. would rather hear from people actively buying currently instead of outdated recommendations from older threads.

I have a web application that collects user data payloads and provides them with real-time comparative analytics (relative rankings, averages, and multi-dimensional comparisons). Currently, I am using Firebase Realtime Database (RTDB) with a serverless architecture where the vanilla JS client handles the data processing.

I am expecting a high-traffic burst of 10k+ users per day for the next 15-20 days, and I have realized my current Firebase architecture will face severe scalability limitations. I am planning to migrate to Supabase (Postgres) to resolve this, but I would appreciate some community input on the transition.

Here is an overview of my current backend/database flow on Firebase:

1. Duplicate Prevention (Hashing & Reads) When a user uploads their payload, the client generates a SHA-256 hash. Before writing, it reads a hashes/ node to check if this hash already exists, rejecting it if found to prevent duplicate entries.

2. Client-Side Aggregation (Firebase Transactions) To minimize storage, I do not store raw individual records. Everything is aggregated on write. The client runs a Firebase Transaction on a stats/ node specific to the user's cohort. This transaction updates:

• Total count and sums (to calculate means later)
• Highest and lowest values recorded
• A frequency map of values (e.g., { "150": 12, "145": 8 })
• Dimensional metric sums for granular analysis

3. Global Counters (Multi-path Updates) After the transaction succeeds, the client performs a simultaneous multi-path update to increment global platform counters and record the payload hash with a server timestamp.

4. Fetching Analytics (Reads) The client fetches the aggregated stats/ node, iterates over the frequency map locally, and calculates the user's relative rank, segment averages, and builds distribution histograms and radar charts entirely in the browser.

5. Client-Side Caching To optimize Firebase bandwidth, I implemented a custom 15-minute in-memory cache on the frontend so users navigating between dashboard tabs do not trigger redundant RTDB reads.

Why I am migrating to Supabase: With an expected load of 10k daily concurrent users, relying on Firebase RTDB for this setup presents significant risks. I am primarily concerned about transaction bottlenecks—multiple users attempting to write to the exact same aggregated stats/ node simultaneously will cause severe client-side retry loops and potential write failures. Additionally, downloading massive frequency maps to the client to calculate dashboards will quickly exhaust bandwidth limits and degrade performance.

My plan with Supabase is to store the raw user payloads in a PostgreSQL table and utilize SQL (via materialized views or RPCs) to calculate ranks, distributions, and averages natively on the server. This shifts the computational burden to the backend, resolves client-side concurrency conflicts, and minimizes network payload sizes.

Questions for the Community:

1. Has anyone executed a similar migration from NoSQL client-side aggregations to relational server-side processing at this scale?
2. Are there any specific performance bottlenecks, indexing strategies, or architectural considerations I should be aware of when moving these analytical workloads to PostgreSQL/RPCs?

I have a web application that collects user data payloads and provides them with real-time comparative analytics (relative rankings, averages, and multi-dimensional comparisons). Currently, I am using Firebase Realtime Database (RTDB) with a serverless architecture where the vanilla JS client does all the heavy lifting.

I'm wondering if I should migrate to Supabase (Postgres). Here is exactly what my backend/database flow currently looks like:

1. Duplicate Prevention (Hashing & Reads) When a user uploads their payload, the client generates a SHA-256 hash of their specific data points. Before writing anything, it does a quick read to a hashes/ node to check if this hash already exists. If it does, it rejects the payload to prevent duplicate entries from skewing the global analytics.

2. Client-Side Aggregation (Firebase Transactions) To save on storage and read costs, I do not store raw individual user records. Instead, everything is pre-aggregated on write. The client runs a Firebase Transaction on a stats/ node specific to the user's data segment. This transaction securely reads the current state and updates:

• Total count of payloads received
• Sum of the primary numerical metrics (to calculate means/averages later)
• The highest and lowest values recorded in that segment
• A frequency map of the values (e.g., { "150": 12, "145": 8 })
• Dimensional metric sums (e.g., total values collected for Attribute A, Attribute B, etc.) for granular analysis.

3. Global Counters (Multi-path Updates) After the transaction succeeds, the client performs a simultaneous multi-path update to increment global platform counters and record the user's payload hash with a server timestamp.

4. Fetching Analytics (Reads)

• Brief Dashboard: The client fetches the single aggregated stats/ node for the user's specific segment. It iterates over the frequency map to instantly calculate their relative rank (counting how many users have higher values), the segment average, and distribution standing.
• Deep Analytics: For the full analytics screen, the client pulls down the aggregated data for all segments within a cohort. It then processes this locally to generate complex visual analytics: distribution histograms (bucketing the metrics), radar charts for attribute comparisons (User vs. Average), median calculations, and segment-to-segment comparisons.

5. Client-Side Caching Because Firebase reads cost money/bandwidth, I implemented a custom 15-minute in-memory cache on the frontend. If a user flips between their dashboard and the deep analytics screen, it reads from memory rather than hitting the RTDB again.

My dilemma: Right now, this NoSQL approach works, but it requires the client to do a lot of transaction logic and frequency map handling. If I move to Supabase, I could presumably store the raw payloads in a Postgres table and use SQL (or materialized views/RPCs) to calculate ranks, distributions, averages, and dimensional stats natively on the server.

For context on scale: I am expecting around 10k users per day on my website for the next 15-20 days.

Has anyone made a similar jump from Firebase RTDB aggregated nodes to Supabase/Postgres? Is the SQL computation overhead better/cheaper than managing NoSQL transactions on the client at this scale?