When you strip away the noise, four challenges always show up:

• Missing values

• Duplicates

• Data types & formatting

• Outliers

These aren’t just technical hurdles. Each decision whether to impute, drop, cast, trim, or flag shapes the story your dataset tells.

SQL vs Python: Side‑by‑Side Syntax

Here’s a quick reference for tackling the same problems in SQL and Python.

🔹 Missing Values

SQL

-- Find missing values 
SELECT * FROM table WHERE col IS NULL; 

-- Replace missing values 
SELECT COALESCE(col, 0) FROM table;

Python

# Find missing values 
df.isnull().sum() 
df[df[’col’].isna()] 

# Replace missing values 
df[’col’].fillna(0) 
df[’col’].fillna(df[’col’].mean())

🔹 Duplicates

SQL

-- Remove duplicates 
SELECT DISTINCT * FROM table;

Python

# Count duplicates 
df.duplicated().sum() 

# Drop duplicates 
df.drop_duplicates()

🔹 Data Types & Formatting

SQL

-- Convert data type 
 SELECT CAST(col AS INT) FROM table; 

-- Convert date 
SELECT TO_DATE(col, ‘YYYY-MM-DD’) FROM table; 

-- Clean text 
SELECT TRIM(col) FROM table;

Python

# Convert data type
df[’col’].astype(int) 
pd.to_numeric(df[’col’])
 
# Convert date 
pd.to_datetime(df[’col’], format=’%Y-%m-%d’)
 
# Clean text 
df[’col’].str.strip() 
df[’col’].str.lower()

🔹 Outliers (IQR Method)

SQL

WITH q AS ( 
 SELECT 
    PERCENTILE_CONT(0.25) WITHIN GROUP (ORDER BY col) q1, 
    PERCENTILE_CONT(0.75) WITHIN GROUP (ORDER BY col) q3 
 FROM table 
) 
SELECT * FROM table 
WHERE col BETWEEN (q1 - 1.5*(q3 - q1)) 
AND (q3 + 1.5*(q3 - q1));

Python

Q1 = df[’col’].quantile(0.25) 
Q3 = df[’col’].quantile(0.75) 

IQR = Q3 - Q1 

df[(df[’col’] > Q1 - 1.5*IQR) & (df[’col’] < Q3 + 1.5*IQR)]

Why This Matters

Cleaning is not housekeeping. It’s judgment, context, and domain knowledge in action. The insights don’t come after cleaning they emerge through it.

So whether you’re writing SQL queries or chaining Python methods, remember: every choice you make in cleaning is already shaping the analysis.

1. Conversion Rate (CVR)

1. Definition: Conversion Rate measures the percentage of website visitors who complete a purchase.

2. Formula: CVR = (Number of Orders ÷ Number of Sessions) × 100

3. Real-World Example: An ecommerce store gets 10,000 visitors and 200 make a purchase. CVR = (200 ÷ 10,000) × 100 = 2%.

4. Where Analysis Happens: Analysts track CVR using website analytics tools like Google Analytics or ecommerce platforms.

5. Why It Matters: CVR shows how effectively a site turns visitors into buyers, directly impacting revenue.

6. What Impacts CVR: Page load speed, checkout process simplicity, product appeal, trust signals, and marketing quality.

7. How to Improve: Reduce page load time, simplify checkout, add social proof, and A/B test call-to-action buttons.

8. Result/Conclusion: Even a 0.5% increase in CVR can significantly boost revenue without extra ad spend.

9. Interview Tip: Explain CVR with formula, example, and suggest practical improvements.

10. Business Impact: A 0.5% lift in CVR for a brand with 10,000 monthly visitors can mean 50 extra orders and ₹50,000+ additional revenue.

2. Average Order Value (AOV)

1. Definition: AOV is the average amount spent by a customer per order.

2. Formula: AOV = Total Revenue ÷ Number of Orders

3. Real-World Example: If revenue is ₹5,00,000 from 500 orders, AOV = ₹1,000.

4. Where Analysis Happens: Sales and transaction data from ecommerce platforms or payment gateways.

5. Why It Matters: Higher AOV means more revenue from the same number of customers.

6. What Impacts AOV: Product pricing, upselling, cross-selling, discounts, and bundles.

7. How to Improve: Offer product bundles, volume discounts, and personalized recommendations.

8. Result/Conclusion: Increasing AOV by ₹200 across 2,000 orders adds ₹4,00,000 revenue monthly.

9. Interview Tip: Show understanding of how AOV affects revenue and suggest strategies to increase it.

10. Business Impact: Boosting AOV is a cost-effective way to increase revenue without acquiring new customers.

3. Customer Acquisition Cost (CAC)

1. Definition: CAC is the total cost spent to acquire one new customer.

2. Formula: CAC = Total Marketing Spend ÷ Number of New Customers

3. Real-World Example: Spending ₹1,00,000 on ads to get 200 customers means CAC = ₹500.

4. Where Analysis Happens: Marketing spend and customer data from ad platforms and CRM systems.

5. Why It Matters: CAC shows how efficiently a company acquires customers.

6. What Impacts CAC: Ad targeting, campaign quality, channel choice, and brand reputation.

7. How to Improve: Optimize ad campaigns, focus on high-ROI channels, and improve targeting.

8. Result/Conclusion: Lower CAC means more profitable growth.

9. Interview Tip: Emphasize the importance of CAC being lower than customer lifetime value.

10. Business Impact: Healthy brands aim for a 3:1 ratio of LTV to CAC for sustainable growth.

4. Lifetime Value (LTV)

1. Definition: LTV is the total revenue a customer generates during their relationship with a brand.

2. Formula: LTV = AOV × Purchase Frequency × Average Customer Lifespan

3. Real-World Example: If a customer spends ₹1,000 per order, buys 3 times a year, and stays for 1 year, LTV = ₹3,000.

4. Where Analysis Happens: Customer purchase history and retention data.

5. Why It Matters: LTV helps decide how much to spend on acquiring customers.

6. What Impacts LTV: Product quality, customer service, loyalty programs, and engagement.

7. How to Improve: Enhance customer experience, offer loyalty rewards, and encourage repeat purchases.

8. Result/Conclusion: Higher LTV allows higher CAC while maintaining profitability.

9. Interview Tip: Discuss LTV’s role in balancing acquisition cost and profitability.

10. Business Impact: Target LTV/CAC ratio of 3 or more for profitable scaling.

5. Return on Ad Spend (ROAS)

1. Definition: ROAS measures revenue earned for every rupee spent on advertising.

2. Formula: ROAS = Revenue from Ads ÷ Advertising Spend

3. Real-World Example: Spending ₹50,000 on ads generating ₹2,00,000 sales means ROAS = 4x.

4. Where Analysis Happens: Ad platform reports and sales tracking.

5. Why It Matters: ROAS indicates ad campaign effectiveness.

6. What Impacts ROAS: Ad creative, targeting, bidding strategy, and product-market fit.

7. How to Improve: Test ad creatives, refine targeting, and optimize bids.

8. Result/Conclusion: ROAS must be considered with profit margins to assess true profitability.

9. Interview Tip: Explain ROAS and its relation to margins.

10. Business Impact: A 3.3x ROAS is needed to break even if margins are 30%.

6. Churn Rate (CR)

1. Definition: Churn Rate is the percentage of customers who stop buying over a period.

2. Formula: CR = (Number of Lost Customers ÷ Number of Starting Customers) × 100

3. Real-World Example: If 100 customers bought last quarter but only 60 returned, churn = 40%.

4. Where Analysis Happens: Customer purchase and subscription data.

5. Why It Matters: High churn reduces revenue and growth.

6. What Impacts CR: Product satisfaction, competition, pricing, and customer service.

7. How to Improve: Improve product quality, customer support, and engagement.

8. Result/Conclusion: Reducing churn by 5% can increase profits by 25–95%.

9. Interview Tip: Highlight churn’s impact on retention and revenue.

10. Business Impact: Lower churn means higher customer lifetime value.

7. Net Promoter Score (NPS)

1. Definition: NPS measures customer loyalty by asking how likely they are to recommend a brand on a scale of 0–10.

2. Formula: NPS = % Promoters (9–10) – % Detractors (0–6)

3. Real-World Example: If 60% are promoters and 20% detractors, NPS = 40.

4. Where Analysis Happens: Customer surveys and feedback tools.

5. Why It Matters: High NPS drives organic growth through referrals.

6. What Impacts NPS: Product quality, customer experience, and brand reputation.

7. How to Improve: Enhance customer service, address complaints, and engage customers.

8. Result/Conclusion: Good NPS is 50+, excellent 70+, world-class 80+.

9. Interview Tip: Explain NPS and its importance for customer advocacy.

10. Business Impact: High NPS reduces acquisition costs via referrals.

8. Customer Retention Rate (CRR)

1. Definition: CRR measures the percentage of customers who return to buy again.

2. Formula: CRR = ((Number of Customers at End – New Customers) ÷ Number of Customers at Start) × 100

3. Real-World Example: A 70% CRR means 7 out of 10 customers come back.

4. Where Analysis Happens: Purchase history and CRM data.

5. Why It Matters: Retained customers spend more and cost less to serve.

6. What Impacts CRR: Customer satisfaction, loyalty programs, and communication.

7. How to Improve: Personalize marketing, offer rewards, and maintain engagement.

8. Result/Conclusion: Top ecommerce brands maintain 35–65% annual retention.

9. Interview Tip: Discuss retention strategies and their impact on revenue.

10. Business Impact: Higher retention leads to sustainable growth and profitability.

Final Thoughts

Mastering these 8 KPIs—CVR, AOV, CAC, LTV, ROAS, CR, NPS, and CRR—will not only strengthen your ecommerce analytics projects but also make your resume stand out. In interviews, being able to define, calculate, analyze, and suggest improvements for these metrics shows you understand how data translates directly into business impact.

Subscribe now

When analytics professionals or business analysts work with Ecommerce brands, Conversion Rate (CVR) is the KPI that makes or breaks their resume impact. Interviewers love candidates who can:

• Define CVR with a formula

• Show calculations with real numbers

• Provide simple insights (e.g., “CVR improved from 2% → 3%”)

• Suggest practical improvements (checkout flow, page speed, social proof)

• Explain why it matters (e.g., “0.5% CVR lift = ₹10 lakh/month extra revenue”)

This post follows the case study format: definition, formula, calculation, insight, improvement, and why it matters exactly how you should present it in interviews.

What is Conversion Rate (CVR)?

• Definition: CVR measures the percentage of visitors who complete a purchase.

Real-world scenario

An Indian D2C skincare brand drives 10,000 sessions per month through Instagram ads. Of those, 200 customers complete a purchase. Their CVR is 2% right at the industry average. Now imagine improving that to 2.5% without spending a single extra rupee on ads. That translates to 50 more orders, potentially ₹50,000+ in additional monthly revenue.

Example:

• Sessions = 10,000

• Purchases = 200

✅ Formula: CVR = (Orders ÷ Sessions) × 100

✅ Calculation: (200 ÷ 10,000) × 100 = 2%

💡 Simple Insight: Out of every 100 visitors, 2 become paying customers. If CVR improves to 2.5%, that’s 50 extra orders worth ₹50,000+ in additional monthly revenue without spending more on ads.

Industry Benchmark

Let me break down the meaning of what you shared in simple terms:

• Industry Average (1–3%) → Most e‑commerce stores convert about 1–3% of visitors into buyers.

• Top Performers (5%+) → The very best stores achieve 5% or higher conversion rates.

• Your Target (≥ 2.5%) → A realistic goal is to aim for at least 2.5% conversion rate.

Actionable levers (ways to improve CVR):

• Reduce page load time → Every 1‑second delay can drop conversions by up to 7%.

• Simplify checkout flow → Fewer form fields, guest checkout, and multiple payment options make buying easier.

• Add social proof → Reviews, user‑generated photos, and trust badges build credibility and push hesitant buyers to purchase.

• A/B test CTAs → Testing different call‑to‑action buttons (like “Buy Now” vs. “Add to Cart”) can increase conversions.

Why it matters:
Even a 0.5% CVR increase can add ₹10 lakh/month in extra revenue without additional ad spend. That’s why CVR optimization is the highest-ROI activity in Ecommerce.

• Define the funnel clearly

• Apply formulas to calculate drop-offs

• Interpret insights simply

• Suggest improvements that drive measurable business impact

This case study walks through a real-world funnel scenario: definition, formula, calculation, insight, and why it matters.

The calculation

Conversion Rate = (Completed Purchases ÷ Total Visitors) × 100

= (4,000 ÷ 100,000) × 100

= 4%

💡 Insight: This means out of every 100 visitors, 4 end up making a purchase. Beyond the math, interviewers want to see how you interpret the funnel and identify opportunities to improve each stage (visitor → cart → checkout → purchase).

What interviewers actually want to hear

Getting the math right is just the entry ticket. The best candidates go a layer deeper and identify opportunities at each drop-off point:

This is why conversion funnel analysis is one of the most impactful skills in e-commerce analytics. It’s not just about one number, it’s about knowing where you’re losing customers and why. Nail this framing in your interview, and you immediately stand out from candidates who stop at the formula.

📌More is coming. Subscribe to get access to similar analytical projects with 4–5 resume-ready lines and interview explanations you can directly add to your CV.

The Question: "Given a users table, find all duplicate email addresses."

The Solution:

❌ Basic (gets you by):

SELECT email, COUNT(*)

FROM users

GROUP BY email

HAVING COUNT(*) > 1

✅ Better (gets you hired):

SELECT email, COUNT(*) as duplicate_count,

STRING_AGG(user_id, ' , ') as user_ids

FROM users

GROUP BY email

HAVING COUNT(*) > 1

ORDER BY duplicate_count DESC

Why it's better: →Shows which specific users affected

→Prioritizes by severity (most duplicates first)

→Actionable for data clean up team.

Question #2 : Second Highest Salary

The Question: "Find the second highest salary from an employees table. "

Most people get this wrong↓

What happens if two people have the highest salary?

The Solution:

❌ Basic (gets you by):

SELECT MAX(salary)

FROM employees

WHERE salary < (SELECT MAX (salary) FROM employees)

✅ Better (gets you hired):

SELECT salary

FROM( SELECT salary,

DENSE_RANK() OVER

(ORDER BY salary DESC) as rank

FROM employees ) ranked

WHERE rank = 2

Key difference: → DENSE_RANK handles ties properly

→ If two people earn$100K (rank 1), next salary gets rank 2

→ ROW_NUMBER would skip to rank 3

Question #3: Calculate Running Totals

The Question: "Show cumulative sales by date."

What they're testing: Do you understand window functions?

This is where juniors struggle↓ They try to use self-joins instead of window functions

The Solution:

❌ Basic (gets you by):

SELECT o1.order_date,

SUM(o2.amount) AS running_total

FROM orders o1

JOIN orders o2

ON o2.order_date <= o1.order_date

GROUP BY o1.order_date;

✅ Better (gets you hired):

SELECT order_date, daily_sales,

SUM(daily_sales) OVER (ORDER BY order_date) AS running_total

FROM ( SELECT order_date,

SUM(amount) AS daily_sales

FROM orders

GROUP BY order_date

) daily;

Why window functions? → Calculate aggregates without collapsing rows

→Perfect for trends over time (dashboards love this)

→10x more efficient thanself-joins

What to say: "Window functions let me keep row-level detail while computing running calculations—essential for time-series analysis."

Question #4: Customers With No Orders

The Question: “List all customers who haven’t placed any orders.”
What they’re testing: Do you know when to use different joins and how to handle NULLs?

✅ Solution 1: LEFT JOIN

SELECT c.customer_id, c.name

FROM customers c

LEFT JOIN orders o ON c.customer_id = o.customer_id

WHERE o.order_id IS NULL;

• Why it works: The LEFT JOIN keeps all customers, and the WHERE o.order_id IS NULL filters those without matches in orders.

• Performance note: Often faster on large datasets compared to subqueries.

✅ Solution 2: NOT IN

SELECT customer_id, name

FROM customers

WHERE customer_id

NOT IN ( SELECT customer_id FROM orders );

• Caution: If the subquery returns NULL, this can fail. Mentioning this shows real‑world awareness.

✅ Solution 3: NOT EXISTS

SELECT c.customer_id, c.name

FROM customers c

WHERE NOT EXISTS (

SELECT 1

FROM orders o

WHERE o.customer_id = c.customer_id );

• Why it’s solid: Handles NULLs safely and is often more reliable across SQL dialects.

Interview sound bite:
“I’d prefer LEFT JOIN … IS NULL or NOT EXISTS because they handle NULLs correctly and scale better. NOT IN can break if the subquery returns NULLs.”

Question #5: Month‑Over‑Month Growth

The Question: “Show monthly revenue growth percentage.”
What they’re testing: Can you compare time periods using window functions?

✅ Solution

WITH monthly_revenue AS (

SELECT DATE_TRUNC(’month’, order_date) AS month,

SUM(amount) AS revenue

FROM orders

GROUP BY month )

SELECT month, revenue,

LAG(revenue) OVER (ORDER BY month) AS prev_month,

ROUND( ((revenue - LAG(revenue)

OVER (ORDER BY month)) /

LAG(revenue) OVER

(ORDER BY month) * 100), 2 )

AS growth_pct

FROM monthly_revenue;

Why LAG function? →Access previous row values cleanly

→More readable than self-joins

→Essential for any time-based comparison

Business context:
“This shows leadership exactly where growth is accelerating or slowing — a key metric for revenue dashboards and forecasting.”

Subscribe now

MalinisaysLinkedIn

FoodYum is a grocery store chain that is based in the United States.Food Yum sells items such as produce, meat, dairy, baked goods, snacks, and other household food staples.

As food costs rise, FoodYum wants to make sure it keeps stocking products in all categories that cover a range of prices to ensure they have stock for a broad range of customers.

Task 1

Last year (2022) there was a bug in the product system. For some products that were added in that year, the year_added value was not set in the data. As the year the product was added may have an impact on the price of the product, this is important information to have.

Write a query to determine how many products have the year_added value missing. Your output should be a single column, missing_year, with a single row giving the number of missing values.

-- Write your query for task 1 in this cell
SELECT COUNT(*) AS missing_year
FROM products
WHERE year_added IS NULL;

Output: Task 1

Task 2

Given what you know about the year added data, you need to make sure all of the data is clean before you start your analysis. The table below shows what the data should look like.

Write a query to ensure the product data matches the description provided. Do not update the original table.

-- Write your query for task 2 in this cell
SELECT
    product_id,
    COALESCE(product_type, ‘Unknown’) AS product_type,
    COALESCE(NULLIF(REPLACE(brand, ‘-’, ‘’), ‘’), ‘Unknown’) AS brand,
    COALESCE(ROUND(CAST(REGEXP_REPLACE(weight, ‘[^\d.]’, ‘’, ‘g’) AS DECIMAL(10, 2)), 2), ROUND((SELECT PERCENTILE_DISC(0.5) WITHIN GROUP (ORDER BY CAST(REGEXP_REPLACE(weight, ‘[^\d.]’, ‘’, ‘g’) AS DECIMAL(10, 2))) FROM products), 2)) AS weight,

COALESCE(
    TO_CHAR(CAST(price AS DECIMAL(10, 2)), ‘9999999999.99’),
    TO_CHAR(CAST((SELECT PERCENTILE_DISC(0.5) WITHIN GROUP (ORDER BY price) FROM products) AS DECIMAL(10, 2)), ‘9999999999.99’)
) AS price,

    COALESCE(average_units_sold, 0) AS average_units_sold,
    COALESCE(year_added, 2022) AS year_added,
    COALESCE(UPPER(stock_location), ‘Unknown’) AS stock_location
FROM products;

Output: Task 2

Task 3

To find out how the range varies for each product type, your manager has asked you to determine the minimum and maximum values for each product type.

Write a query to return the product_type, min_price and max_price columns.

-- Write your query for task 3 in this cell
SELECT product_type,
    MIN(price) AS min_price,
    MAX(price) AS max_price
FROM products 
GROUP BY product_type;

Output: Task 3

Task 4

The team want to look in more detail at meat and dairy products where the average units sold was greater than ten.

Write a query to return the product_id, price and average_units_sold of the rows of interest to the team.

-- Write your query for task 4 in this cell
SELECT product_id, price, average_units_sold
FROM products 
WHERE product_type IN (’Meat’, ‘Dairy’)
     AND average_units_sold > 10;

Output: Task 4

Mean = average sales

Median = middle value (outliers ignored)

Mode = most frequent product

Range = min → max Standard deviation = how spread out

Excel: =AVERAGE(), =MEDIAN(), =STDEV()

SQL: AVG(), PERCENTILE_CONT()

Python: df.describe()

Pro move: Always report median + mean → shows skew.

2. CORRELATION vs CAUSATION — Don’t get this wrong

Ice cream sales + drownings correlate (r=0.95). But ice cream doesn’t cause drowning — summer does.

Business example: “Revenue + ad spend correlate 0.87”

Check: Did anything else change? Seasonality? Competitors?

Excel: =CORREL() Python: df.corr() + heatmap

Interview goal: “Correlation doesn’t prove causation. I’d check confounding variables.”

3. 4 TYPES OF ANALYTICS — Different questions, different tools

Descriptive: What happened? (Excel/SQL)

Purpose → Summarizes what happened in the past event.

Eg. Monthly sales reports showing total sales made

Diagnostic: Why did it happen? (Drill-down)

Purpose → To identify reasons/cause behind event

Eg. Fig. out why sales dropped in Q1

Predictive: What will happen? (ML/trends)

Purpose → Forecast possible out comes based on past trends

Eg. Predict next quarter sales using past sales data.

Prescriptive: What should we do? (Scenarios)

Purpose → Recommends actions to achieve goals.

Eg. Suggest discounts to boost future sales.

Daily use: 80% descriptive → 15% diagnostic → 5% predictive.

4. DATA QUALITY FRAMEWORK — Garbage in = garbage out

Accuracy: 5000 vs 5000 (format correct?)

Completeness: 20% missing emails? Problem.

Consistency: “Delhi” vs “DL” vs “delhi” — pick one.

Timeliness: Data from 2024? Useless for 2026.

Uniqueness: Duplicate customer IDs? Fix it.

Daily check: df.isna().sum() + df.duplicated().sum()

Pro habit: Document issues → fix upstream.

5. KPI & OKR ALIGNMENT — Analytics without business goals = wasted

Wrong: “Here’s 20 metrics.”

Right: “CEO wants revenue growth → I track 3 revenue KPIs.”

OKR example: Objective: Grow revenue 20%

Key Results: Monthly revenue ₹52L → ₹62L

New customers 1K → 1.5K

Avg order value ₹2K → ₹2.4K

6. COHORT ANALYSIS — Track groups over time

Jan joiners: Month1 = 1000 orders → Month3 = 600 (40% retention)

Feb joiners: Month1 = 1200 → Month3 = 780 (65% retention)

Insight: Feb onboarding worked better → scale it.

Business gold: Retention > Acquisition.

Tools: Excel Pivot + date slicers,

SQL WHERE join_month,

Python groupby([’cohort’,’month’])

7. HYPOTHESIS TESTING (A/B Testing) — Prove your recommendations

H₀ (null): New homepage = same conversion

H₁ (alt): New homepage > old conversion

Test: 5% traffic gets new design

Result: p-value < 0.05 → Reject H₀ → Rollout!

Business impact: “₹15L/month uplift.”

Tools: Excel T.TEST(),

Python scipy.stats.ttest_ind()

Interview answer: “Run A/B test, check p<0.05, calculate business impact.”

8. BUSINESS TRANSLATION — Speak CEO language

Technical: “R²=0.87, p<0.01”

CEO: “Marketing predicts 87% of revenue → ₹5Cr opportunity.”

Technical: “Cohort retention 42%”

CEO: “₹12L/month leaking → Win-back campaign.”

Numbers mean nothing without context. Translate everything

Subscribe now

1️⃣ DDL – Data Definition Language

Used to define and modify structure of database objects.

* CREATE – Create table/schema

* ALTER – Modify table structure

* DROP – Delete table or database

* TRUNCATE – Delete all records (faster, irreversible)

* RENAME – Change table name

2️⃣ DML – Data Manipulation Language

Used to manipulate data inside tables.

* SELECT – Retrieve data

* INSERT – Add data

* UPDATE – Modify existing data

* DELETE – Remove specific rows

3️⃣ DCL – Data Control Language

Used to control access to data.

* GRANT – Give user privileges

* REVOKE – Remove user privileges

4️⃣ TCL – Transaction Control Language

Used to manage transactions in a database.

* COMMIT – Save changes permanently

* ROLLBACK – Undo changes

* SAVEPOINT – Set a point to roll back to

* SET TRANSACTION – Define properties of a transaction

5️⃣ SCL – Session Control Language

Used to manage user sessions.

* ALTER SESSION

* SET ROLE

Subscribe now

Here are a few ways interviewers might ask about LIMIT and OFFSET:

- ‘What’s the difference between LIMIT and OFFSET?’

- ‘How do you fetch the 11th to 20th rows from a table?’

In Day 1 of the 30 Days of SQL series, we cover the absolute foundations:

• What is data and what is a database?

• What is a Database Management System (DBMS)?

• Popular database tools you should know

• SQL vs NoSQL — explained with real-world examples

This series is designed for beginners to intermediate learners who want to build strong fundamentals and become job-ready using practical, real-world explanations.

Subscribe to follow the full 30-day SQL roadmap, with daily lessons, queries, and projects.

SUM is a simple aggregation function. It adds up all the values in a single numeric column.

• Syntax: SUM(Table[Column])

• Use Case: when you already have a column with numeric values you want to total.

• Example : Total_Sales = SUM(SalesData[Sales])

• Adds all values in the Sales column directly

• Performance:
  Very fast and efficient because it works directly on the column.

SUMX is an iterator function. It goes row by row, evaluates an expression for each row, and then sums the results.

• Syntax: SUMX(Table, Expression)

• Use Case: when you need to calculate something for each row before summing.

• Example: Total_Sales2 = SUMX(SalesData, SalesData[Quantity] * SalesData[Unit Price])

• Multiplies Quantity × Unit Price for each row, then adds them up.

• Performance: Slower than SUM for large datasets because it iterates row by row, but essential when you don’t have a pre‑calculated column.

👉 Interview Tip: If asked, you can say:

• “SUM is for direct column totals, SUMX is for row‑by‑row calculations before summing. SUM is faster, SUMX is more flexible.”

  Subscribe now

  ---

  Interviewers often test whether you understand how SUM and SUMX behave differently when used in calculated columns vs measures.

  Calculated Columns

  • Definition: A calculated column is created at the row level. Each row gets a value when the data is loaded or refreshed, and it’s stored in the model.

  • SUM in Calculated Column:
    You normally don’t use SUM directly in a calculated column, because SUM is an aggregation across rows. Calculated columns work in row context, so you’d typically use arithmetic like:

    SalesData[LineTotal] = SalesData[Quantity] * SalesData[Unit Price]

  • 👉 This creates a new column with row‑by‑row totals.

  • SUMX in Calculated Column:
    Rarely used here, because SUMX is also an iterator across a table. In a calculated column, you already have row context, so you don’t need to iterate again.

  Measures

  • Definition: A measure is calculated dynamically at query time, based on filter context. It’s not stored in the model.

  • SUM in Measure: Total_Sales = SUM(SalesData[Sales])

  • 👉 Adds up all values in the Sales column, recalculated depending on filters (e.g., by region, by product).

  • SUMX in Measure:

  Total_Sales2 = SUMX(SalesData, SalesData[Quantity] * SalesData[Unit Price])

  • 👉 Evaluates row by row, then sums. Useful when you don’t have a pre‑calculated “Sales” column, or when you need conditional logic.

  Key Difference in Context

  • Calculated Column:

    • Works at row level.

    • Good for creating new fields (e.g., LineTotal = Quantity × Price).

    • Stored in the model, increases size.

  • Measure:

    • Works at report level.

    • Good for aggregations (SUM, SUMX) that change dynamically with filters.

    • Not stored, recalculated on the fly.

  ---

  Interview‑Ready Answer

  👉 “Calculated columns are row‑based and stored in the model, while measures are dynamic and context‑based. SUM is used in measures when you want to total an existing column, while SUMX is used in measures when you need to calculate row‑by‑row expressions before summing. In calculated columns, you usually just use arithmetic, because row context is already present.”

  Leave a comment

  
  

Even though we write SQL in a certain order, the database engine executes it differently. Here’s the logical flow you should always keep in mind:

1. FROM → Identify the table(s) you’re working with.

2. WHERE → Filter raw rows before grouping.

3. GROUP BY → Group rows with the same values for aggregation.

4. HAVING → Filter groups after aggregation.

5. SELECT → Choose the columns to display.

6. ORDER BY → Sort results in ascending or descending order.

7. LIMIT → Control how many rows are returned.

👉 Tip for interviews: Always explain why you’re using WHERE vs. HAVING. For example:

• Use WHERE when filtering raw data (customer_id > 100).

• Use HAVING when filtering aggregated results (COUNT(*) > 1)

Joins: A join is used to combine rows from two or more tables based on a related column.

Joins are a favorite interview topic because they test your ability to combine data across tables.

• INNER JOIN → Returns rows with matching values in both tables

• LEFT JOIN → Returns all rows from the left table, plus matches from the right.

• RIGHT JOIN → Opposite of LEFT JOIN.

• FULL OUTER JOIN → returns all rows from one table and matched rows from the other.

CASE Statement: Conditional Logic in SQL

The CASE statement lets you create new columns based on existing ones. This is often used in reporting or categorization tasks.

Example: Categorize employees by salary range.

SELECT Name, 
       CASE 
       WHEN Salary > 100000 THEN ‘High’ 
       WHEN Salary BETWEEN 50000 AND 100000 THEN ‘Medium’ 
       ELSE ‘Low’ 
   END AS SalaryCategory 
FROM Employees;

👉 Tip for interviews: Use CASE to show you can transform raw data into business-friendly insights.

Subscribe now

Index : An index is a database object that acts like a lookup table for faster data retrieval. Think of it like the index in a book: instead of scanning every page, you jump directly to the right section.

Types of Indexes

• Unique Index → Ensures all values in a column are distinct.

• Composite Index → Built on multiple columns, useful for queries filtering by more than one field.

• Full-Text Index → Optimized for searching text data (e.g., keywords in articles).

• Clustered Index → Determines the physical order of data in a table. Only one per table.

• Non-Clustered Index → Creates a separate structure pointing to the data. Multiple allowed per table.

How Indexing Improves Performance

• Indexes create quick access paths to data.

• Instead of scanning the entire table (full table scan), the database engine uses the index to jump directly to relevant rows.

• This reduces query execution time, especially for large datasets.

Pros and Cons of Indexing

• Pros:

  • Faster data retrieval.

  • Efficient filtering, sorting, and joins.

  • Essential for performance in large tables.

• Cons:

• Slows down data modification (INSERT, UPDATE, DELETE) because indexes must be updated too.

• Requires extra storage space.

• Poorly chosen indexes can hurt performance instead of helping.

  Share

Most Common Interview Questions and its response :

What is SQL and it is use for ?

- SQL (Structured Query Language) is a standard programming language for managing and manipulating relational databases.

Main uses:

Store structure data; Retrieve exactly what you need like filter, sort, join tables; Update or delete data, generate reports, analytics, insights for business decision; Power web apps: backend systems

What is an index?

- An index is a database object that improves the speed of data retrieval operations on a database table.

What are the different types of indexes?

- Types of indexes include unique indexes, composite indexes, full-text indexes, and clustered and non-clustered indexes.

What is a clustered index?

- A clustered index determines the physical order of data in a table; there can be only one clustered index per table.

What is a non-clustered index?

- A non-clustered index does not alter the physical order of the table and can have multiple instances in a table.

What is indexing and how does it improve query performance?

- Indexing creates a data structure that improves the speed of data retrieval operations by providing quick access paths.

What are the pros and cons of indexing?

- Pros: Faster data retrieval. Cons: Slower data modification (insert/update/delete) and increased storage requirements.

What is the difference between DELETE and TRUNCATE and DROP

- DELETE removes specific rows one at a time based on condition and can be rolled back, also slower as it logs each deletion; TRUNCATE removes all rows in a table without logging individual row deletions and faster than DELETE but usually cant be rolled back; DROP deletes an entire table, index or database object and it permanent , cant be rollback.

What is the difference between WHERE and HAVING clauses?

- WHERE is used to filter records before aggregation, while HAVING is used to filter records after aggregation.

What is the difference between ROLLBACK and COMMIT?

- ROLLBACK undoes changes made in the current transaction, while COMMIT saves all changes made during the transaction.

What is the difference between RANK() and DENSE_RANK()?

- RANK() provides a rank number with gaps for ties, while DENSE_RANK() provides consecutive rank numbers without gaps.

Leave a comment

How to Respond in an Interview

1. Start with logic order: Explain the steps (FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY → LIMIT).

2. Clarify intent: State whether you’re filtering raw rows or aggregated results.

3. Write clean SQL: Use aliases, indentation, and comments.

4. Connect to business impact: Show how the query solves a real-world problem (e.g., finding duplicates saves storage, identifying top salaries helps HR).

5. Stay calm under pressure: Even if you don’t recall exact syntax, explain the logic clearly—that’s what interviewers value most.

Subscribe now