Analyzing Loyal Customers with SQL on LeetCode

✅ Solved a SQL problem on LeetCode — Day 46 of my SQL Journey 💪 Customers don’t just buy products… They buy patterns together 🛒 Today’s problem was about finding product categories that are frequently bought together — The logic behind “you might also like.” The approach: • Mapped each user to their purchased categories • Used a self-join to create category pairs • Applied category1 < category2 to avoid duplicates • Counted shared users per pair and filtered meaningful ones What I practised: • Self joins to relate data within the same dataset • Using DISTINCT for accurate counting • Applying GROUP BY with HAVING • Translating real behaviour into SQL logic What stood out — Recommendations aren’t random… They’re built on repeated patterns. When enough users repeat the same combination, It becomes a signal. That’s where the real insight lies. SQL doesn’t just store transactions. It uncovers relationships between them. Consistent learning, one query at a time 🚀 #SQL #LeetCode #DataAnalytics #LearningInPublic #SQLPractice

✅ Solved a SQL problem on LeetCode — Day 49 of my SQL Journey 💪 Consistency isn’t always visible… But patterns reveal it over time 📈 Today’s problem was about identifying users with persistent behaviour — not just active users, but those who show the same action consistently across days. I worked on analysing behaviour patterns to: • Track user actions across consecutive days • Group continuous activity using ROW_NUMBER() logic • Identify streaks by adjusting date gaps • Filter users with meaningful streak length (≥ 5 days) • Select the strongest pattern per user using RANK() What I practised: • Window functions for streak detection • Handling sequential data with date logic • GROUP BY + HAVING for filtering patterns • Translating consistency into measurable conditions What stood out — Activity can be random… Consistency is never random. When actions repeat over time, They stop being noise and become behaviour. That’s where real insights start. SQL doesn’t just analyse data. It uncovers patterns hidden in time. Consistent learning, one query at a time 🚀 #SQL #LeetCode #SQLPractice #DataAnalytics #LearningInPublic

✅ Solved a SQL problem on LeetCode — Day 40 of my SQL Journey 💪 Not every customer leaves suddenly… Some show signs before they churn. ⚠️ Today’s problem was about identifying churn risk customers — users who are still active but showing warning behaviour. I used aggregation and event analysis to: • Track each user’s latest subscription status • Identify downgrade behaviour over time • Compare current spend with historical maximum • Measure total subscription duration • Filter users based on combined risk signals What I practised: • Working with event-based data using GROUP BY • Using CASE WHEN to capture behavioural signals • Extracting latest values with ordered aggregation • Applying multiple conditions to detect patterns What stood out — Churn doesn’t happen instantly… it builds up through small changes. A downgrade here, a drop in spending there. That’s where the real insight lies. SQL isn’t just about analysing what happened. It’s about spotting what might happen next. Consistent learning, one query at a time 🚀 #SQL #LeetCode #SQLPractice #DataAnalytics #LearningInPublic

✅ Solved a SQL problem on LeetCode — Day 42 of my SQL Journey 💪 Reactions look random… but behaviour usually isn’t 🎯 Today’s problem was about identifying emotionally consistent users — people who tend to react the same way across different content, not just react more. The approach: • Counted total reactions per user and per reaction type • Used a window function inside aggregation to get totals in one pass • Calculated the ratio of the dominant reaction to total reactions • Filtered users where the ratio crossed 60% • Used RANK() to identify the most frequent reaction per user What I practised: • Using window functions inside aggregations • Applying RANK() to capture dominant behaviour • Ratio-based filtering instead of just counts • Translating consistency into a measurable SQL condition What stood out — Consistency isn’t about reacting more… it’s about reacting the same way, repeatedly. Once you frame it as a ratio problem, the pattern becomes clearly visible. That’s where the real insight lies. Also noticed — SQL syntax isn’t universal. Things like ::numeric or QUALIFY don’t work in MySQL. Small difference, but important to keep in mind. Consistent learning, one query at a time 🚀 #SQL #LeetCode #SQLPractice #DataAnalytics #WindowFunctions #LearningInPublic

🚀 Day 34/100 – SQL Practice (LeetCode) Today I solved the “Daily Leads and Partners” problem. 🔹 Approach: - Identified that the dataset contains duplicate records - Goal was to calculate unique leads and unique partners for each date_id and make_name - Used GROUP BY to organize data and COUNT(DISTINCT ...) to count only unique values 🔹 SQL Solution: SELECT date_id, make_name, COUNT(DISTINCT lead_id) AS unique_leads, COUNT(DISTINCT partner_id) AS unique_partners FROM DailySales GROUP BY date_id, make_name; 🔹 What I Learned: ✔️ Difference between DISTINCT and COUNT(DISTINCT) ✔️ Handling duplicate data efficiently ✔️ Importance of grouping before aggregation ✔️ Writing cleaner and optimized SQL queries 💡 Key Takeaway: 👉 When dealing with duplicates and you need unique counts, COUNT(DISTINCT column) is your best friend. Consistency + Practice = Growth 📈 #Day34 #100DaysOfCode #SQL #LeetCode #DataAnalytics #LearningJourney

✅ Solved a SQL problem on LeetCode — Day 39 of my SQL Journey 💪 Some customers order anytime… But some follow patterns you can actually measure 📊 Today’s problem: identify “Golden Hour Customers” — people who consistently order during peak hours and leave high ratings. I used a single-pass aggregation query to: • Count total orders per customer • Flag orders placed during peak hours ⏰ • Calculate peak-hour percentage • Compute average rating while handling NULLs • Filter customers across all conditions at once What I practised: • CASE WHEN inside aggregations • Applying multiple conditions with HAVING • Time-based filtering using HOUR() • Combining behavioural and quality metrics in one query What stood out — Good customers aren’t just active… they’re consistent in when and how they engage. That’s where the real insight lies. SQL isn’t just about breaking problems into steps. Sometimes it’s about bringing everything together — cleanly. Consistent learning, one query at a time 🚀 #SQL #LeetCode #SQLPractice #DataAnalytics #LearningInPublic

✅ Solved a SQL problem on LeetCode — Day 48 of my SQL Journey 💪 Not all active users are valuable… Some look busy 👀 Today’s problem was about identifying zombie sessions — users who scroll endlessly but never click, never buy, never engage. Active on paper. Dead in reality. The approach: • Calculated session duration using MIN() and MAX() timestamps • Counted scrolls and clicks with conditional aggregation • Computed click-to-scroll ratio inside HAVING • Filtered sessions: duration > 30 min, scrolls ≥ 5, ratio < 0.20, zero purchases What I practised: • Conditional aggregation using CASE WHEN • Session-level grouping • Ratio logic inside HAVING • Translating behaviour into SQL filters What stood out — Scrolling is passive. Clicking is intent. Buying is a commitment. A session full of scrolls but no clicks It's just a ghost. That’s where the real insight lies. SQL doesn’t just count events. It reads the story behind them. Consistent learning, one query at a time 🚀 #SQL #LeetCode #DataAnalytics #LearningInPublic #SQLPractice

For a while now, I have been writing about APIs—how systems communicate and exchange data. But there is something just as important that often gets less attention: What happens after the data arrives? That’s where SQL comes in. APIs move data. SQL makes sense of it. From simple queries to complex joins, SQL is the language that turns raw data into insight. So for the next couple of posts, I will be diving into SQL: • Writing efficient queries • Understanding database design • Avoiding common mistakes • Real-world use cases If you have been working with APIs but haven’t explored SQL deeply yet, this is your sign. Let's build better systems—end to end.

💡 𝐂𝐓𝐄 𝐦𝐚𝐝𝐞 𝐦𝐲 𝐒𝐐𝐋 𝟏𝟎𝐱 𝐜𝐥𝐞𝐚𝐧𝐞𝐫 Earlier, my SQL queries looked like this: • Nested queries inside nested queries 😵💫 • Hard to read • Even harder to debug Then I discovered CTE (Common Table Expressions)… and everything changed. 👉 Instead of writing one giant messy query, I started breaking it into steps. 𝐋𝐢𝐤𝐞 𝐭𝐡𝐢𝐬: • Step 1: Get base data • Step 2: Apply filters • Step 3: Do aggregations • Step 4: Final output All in a clean, readable flow. 💻 𝐄𝐱𝐚𝐦𝐩𝐥𝐞 𝐦𝐢𝐧𝐝𝐬𝐞𝐭: WITH step1 AS (...), step2 AS (...), step3 AS (...) SELECT * FROM step3; ✨ 𝐖𝐡𝐚𝐭 𝐈 𝐥𝐨𝐯𝐞 𝐚𝐛𝐨𝐮𝐭 𝐂𝐓𝐄: • Makes queries readable • Easy to debug step-by-step • Reusable logic in the same query • Feels like writing code, not chaos 💡 Write SQL in a way that anyone can easily understand. #SQL #DataAnalytics #CTE #DataAnalyst #LearningSQL #TechGrowth 🚀

Stop writing SQL for the database engine. Start writing it for the human who has to maintain it (probably you). We’ve all inherited that query. You know the one: 1,000 lines of monolithic code, nested subqueries seven levels deep, and zero comments. It runs, but modifying it feels like playing Jenga with production data. The engine doesn't care about your messy code, but your team's agility does. The shift every Data Analyst needs to make is toward Modular SQL. Modular code is readable code. Readable code is enhanceable code. Here is the blueprint for SQL that survives schema changes and business logic updates: ✅ DO: 1. Use CTEs (Common Table Expressions) to break complex logic into isolated steps. 2. Select explicit columns, never SELECT * in production. 3. Leverage Window Functions over messy self-joins. 4. Comment on WHY the logic exists, not how it works. ❌ DON'T: 1. Nest subqueries deeper than three levels. (Convert them to CTEs!) 2. Use SELECT * (protect your query from table schema evolution). 3. Perform raw date manipulation in WHERE clauses (isolate it in a CTE). 4. Adopt modular SQL. Save future-you hours of debugging. Less firefighting = More analysis. Check out the cheat sheet below. What’s the worst SQL anti-pattern you've encountered in code review? Share your pain below. 👇 #SQL #DataAnalytics #DataEngineering #CodingBestPractices #Analytics #DataScience #CareerGrowth