FC Barcelona Sierra Leone

𝗦𝗤𝗟 𝗕𝗨𝗦𝗜𝗡𝗘𝗦𝗦 𝗖𝗛𝗔𝗟𝗟𝗘𝗡𝗚𝗘 #𝟬𝟮 💼

Let’s make this one a little harder.

Imagine you have an employees table with:

* employee_id
* employee_name
* department
* salary

Management does not want the highest-paid employee.

They want the second-highest salary in each department.

The catch?

Two employees can have the same salary.

So before you start coding, think carefully:

Do you want the second employee after sorting, or the second distinct salary?

Those are not always the same thing.

For example, if salaries in Engineering are:

120000, 120000, 110000, 95000

then the second-highest distinct salary is:

110000

not 120000.

Your challenge

Write ONE SQL query that returns the employee or employees earning the second-highest distinct salary in each department.

Bonus

Return:

1. Department
2. Employee Name
3. Salary
4. Salary Rank within Department

Rules

❌ Don’t hard-code department names
❌ Don’t write separate queries for each department
❌ Don’t simply use MAX(salary)
✅ Your query should handle salary ties correctly
✅ It should continue working as the table grows

🤖 AI era rule:

Try solving it yourself first.

Then give your solution to AI and ask:

“Does this correctly handle duplicate salaries and ties?”

That is a much better use of AI than asking it to solve the challenge before you think.

Use AI as your reviewer, not your replacement.

💬 Drop your SQL solution in the comments.

I’ll share the solution and explain the logic after people have had time to try it.

🌐 More practical SQL, Python, Data Analytics, Machine Learning, and AI resources:

EverydayDataScience.com

Follow AI & Data With Ibrahim

Learn • Build • Share • Inspire

𝗦𝗤𝗟 𝗕𝗨𝗦𝗜𝗡𝗘𝗦𝗦 𝗖𝗛𝗔𝗟𝗟𝗘𝗡𝗚𝗘 #𝟬𝟭 🏥

Let’s see how you think about SQL—not just how much syntax you remember.

Imagine a healthcare organization wants to identify the highest-cost patient in each age group.

Sounds simple.

But each patient can have multiple claims.

So this:

MAX(claim_amount)

does not necessarily answer the question.

It finds the largest individual claim.

Management wants something different:

Which patient has the highest combined claim amount within each age group?

That means you need to think about the problem in stages:

→ What should be aggregated first?
→ What should you group by?
→ How will you compare patients within the same age group?
→ How will you handle ties?

🎯 𝗬𝗢𝗨𝗥 𝗖𝗛𝗔𝗟𝗟𝗘𝗡𝗚𝗘

Write ONE SQL query that returns the patient with the highest total claim amount in each age group.

⭐ 𝗕𝗢𝗡𝗨𝗦

Return:

1. Age Group
2. Patient ID
3. Total Claim Amount
4. Rank within Age Group

𝗥𝗨𝗟𝗘𝗦:

❌ Don’t hard-code patient IDs
❌ Don’t write separate queries for each age group
❌ Don’t simply use MAX(claim_amount)
✅ Your query should continue working as new records are added

🤖 𝗢𝗡𝗘 𝗠𝗢𝗥𝗘 𝗥𝗨𝗟𝗘…

Try it yourself before asking AI.

Then give your solution to AI and ask it to critique your logic, identify edge cases, and suggest improvements.

Use AI as your reviewer, not your replacement.

Because in a real SQL interview, writing syntax is only part of the challenge.

You also need to understand what the business is actually asking.

💬 Drop your SQL solution in the comments.

I’ll share the solution and explain the logic after people have had a chance to try it.

📌 Save this challenge and send it to someone learning SQL.

🌐 More practical SQL, Python, Data Analytics, Machine Learning, and AI resources:

EverydayDataScience.com

Follow AI & Data With Ibrahim

Learn • Build • Share • Inspire

𝗔𝗜 𝗱𝗼𝗲𝘀𝗻’𝘁 𝗳𝗶𝘅 𝗯𝗮𝗱 𝗱𝗮𝘁𝗮.

It can actually help you make bad decisions faster.

We talk a lot about becoming AI-first.

But before adding AI to a data workflow, I think there is a more important question:

Can we trust the data feeding it?

Because if your data contains:

→ Missing values handled incorrectly
→ Duplicate records
→ Inconsistent definitions
→ Broken joins
→ Unclear ownership
→ Poor data lineage
→ Conflicting business metrics

AI does not magically make those problems disappear.

It can scale them.

Think about it this way:

❌ Bad Data × AI = Faster Bad Decisions

✅ Trusted Data × AI = Faster Better Decisions

That is why strong AI systems still need strong data foundations.

𝗕𝗲𝗳𝗼𝗿𝗲 𝘀𝗰𝗮𝗹𝗶𝗻𝗴 𝘄𝗶𝘁𝗵 𝗔𝗜, 𝗴𝗲𝘁 𝘁𝗵𝗲 𝗯𝗮𝘀𝗶𝗰𝘀 𝗿𝗶𝗴𝗵𝘁:

1️⃣ Validated data
Are the values complete, accurate, and reasonable?

2️⃣ Consistent definitions
Does “active customer,” “revenue,” or “high risk” mean the same thing across teams?

3️⃣ Clear ownership
Who is responsible when the data is wrong?

4️⃣ Documented lineage
Where did the data come from, and what happened to it along the way?

5️⃣ Reliable pipelines
Can we trust the process that moves and transforms the data?

6️⃣ Trusted metrics
Are people making decisions from the same definitions?

7️⃣ Continuous quality checks
Because yesterday’s clean dataset can become tomorrow’s broken pipeline.

🤖 𝗔𝗜 𝗰𝗮𝗻 𝗵𝗲𝗹𝗽.

It can:

• Detect anomalies
• Generate SQL
• Clean and transform data
• Automate quality checks
• Build pipelines
• Summarize results

But someone still has to decide:

• What does “correct” mean?
• Which source should we trust?
• Is this missing value actually a problem?
• Is this metric defined correctly?
• Is the output reasonable?
• What decision should follow?

That is why I don’t think AI makes data fundamentals less important.

It makes them more important.

The faster we automate, the more expensive bad assumptions can become.

𝗔𝗜 𝗴𝗶𝘃𝗲𝘀 𝘆𝗼𝘂 𝘀𝗰𝗮𝗹𝗲.

𝗬𝗼𝘂𝗿 𝗱𝗮𝘁𝗮 𝗱𝗲𝘁𝗲𝗿𝗺𝗶𝗻𝗲𝘀 𝘄𝗵𝗮𝘁 𝘆𝗼𝘂 𝗮𝗿𝗲 𝘀𝗰𝗮𝗹𝗶𝗻𝗴.

💬 What do you think organizations should fix first before calling themselves “AI-first”?

📌 Save this for your next data or AI project.

🌐 More practical tutorials and cheat sheets:

EverydayDataScience.com

Follow AI & Data With Ibrahim for practical lessons on SQL, Python, Data Analytics, Data Engineering, Machine Learning, and AI.

Learn • Build • Share • Inspire

𝗠𝗢𝗡𝗗𝗔𝗬 𝗗𝗔𝗧𝗔 𝗙𝗨𝗡𝗗𝗔𝗠𝗘𝗡𝗧𝗔𝗟𝗦

Before you analyze healthcare data, ask one simple question:

𝗪𝗵𝗮𝘁 𝗱𝗼𝗲𝘀 𝗢𝗡𝗘 𝗿𝗼𝘄 𝗿𝗲𝗽𝗿𝗲𝘀𝗲𝗻𝘁?

This sounds basic.

But misunderstanding it can quietly ruin an entire analysis.

Imagine you have a Patients table:

1 row = 1 patient

Patient 101 has an annual healthcare cost of $24,000.

Now you have a Claims table:

1 row = 1 claim

Patient 101 has 5 claims.

You join the two tables.

Now Patient 101 appears five times.

If you carelessly sum the patient’s annual healthcare cost after that join:

$24,000 × 5 = $120,000 ❌

The query ran successfully.

The join worked.

There was no error message.

𝗕𝘂𝘁 𝘁𝗵𝗲 𝗮𝗻𝗮𝗹𝘆𝘀𝗶𝘀 𝗶𝘀 𝘄𝗿𝗼𝗻𝗴.

Why?

Because the grain changed.

Before the join:

1 row = 1 patient

After the join:

1 row = 1 claim

This becomes especially important in healthcare data because you may be working with:

• Patient-level data
• Encounters
• Claims
• Diagnoses
• Procedures
• Medications

And these tables do not necessarily represent data at the same level.

Before joining or aggregating healthcare data, I like to ask:

1️⃣ What does one row represent?

2️⃣ What uniquely identifies that row?

3️⃣ Is this relationship one-to-one, one-to-many, or many-to-many?

4️⃣ At what grain should my metric actually be calculated?

5️⃣ Did my row count change unexpectedly after the join?

🤖 𝗔𝗻𝗱 𝘁𝗵𝗶𝘀 𝗺𝗮𝘁𝘁𝗲𝗿𝘀 𝗲𝘃𝗲𝗻 𝗺𝗼𝗿𝗲 𝗶𝗻 𝘁𝗵𝗲 𝗮𝗴𝗲 𝗼𝗳 𝗔𝗜.

AI can write the SQL.

AI can generate the Pandas merge.

AI can calculate the aggregation.

But if you don’t understand the grain of your data, AI can help you produce a perfectly executed wrong answer.

𝗧𝗵𝗲 𝗽𝗿𝗼𝗯𝗹𝗲𝗺 𝘄𝗮𝘀𝗻’𝘁 𝘁𝗵𝗲 𝗦𝗤𝗟.

𝗧𝗵𝗲 𝗽𝗿𝗼𝗯𝗹𝗲𝗺 𝘄𝗮𝘀 𝘁𝗵𝗲 𝗴𝗿𝗮𝗶𝗻.

Before asking what the numbers say, understand what one row means.

💬 Have you ever had a join unexpectedly multiply your rows?

📌 Save this for your next SQL, healthcare, or data-engineering project.

🌐 More practical tutorials and cheat sheets:

EverydayDataScience.com

Follow AI & Data With Ibrahim for practical lessons on SQL, Python, Data Analytics, Data Engineering, Machine Learning, and AI.

Learn • Build • Share • Inspire

𝗔 𝗡𝗨𝗟𝗟, 𝗮 𝘇𝗲𝗿𝗼, 𝗮𝗻𝗱 𝗮 𝗯𝗹𝗮𝗻𝗸 𝗮𝗿𝗲 𝗻𝗼𝘁 𝘁𝗵𝗲 𝘀𝗮𝗺𝗲 𝘁𝗵𝗶𝗻𝗴.

But treating them as if they are can quietly change your analysis.

Imagine a discount column:

Customer A → 10%
Customer B → 0%
Customer C → NULL

Those last two values mean very different things.

0% can mean:

We know the customer received no discount.

NULL can mean:

We don’t know the discount.

Maybe it wasn’t recorded.

Maybe it wasn’t available.

Maybe the field didn’t apply.

And then there is a blank string ('').

That might look empty to you, but depending on the system, it can still be an actual stored value rather than NULL.

Why does this matter?

Because your calculations can change.

In SQL:

COUNT(*)

counts rows.

But:

COUNT(discount)

ignores NULL values.

And this can be even more dangerous:

COALESCE(discount, 0)

It is perfectly valid SQL.

But by replacing every NULL with zero, you are making an assumption:

“Missing means no discount.”

Is that actually true?

Maybe.

Maybe not.

The same issue appears in Python/Pandas when we use things like:

fillna(0)

The code is easy.

𝗧𝗵𝗲 𝗱𝗲𝗰𝗶𝘀𝗶𝗼𝗻 𝗶𝘀 𝘁𝗵𝗲 𝗵𝗮𝗿𝗱 𝗽𝗮𝗿𝘁.

Before replacing missing values, ask:

• Why is this value missing?
• Does zero have a real business meaning?
• Is the missingness itself informative?
• Will replacement distort averages or distributions?
• Should this be imputed, excluded, flagged, or left missing?

🤖 And this matters even more when using AI.

AI can instantly write:

df['discount'].fillna(0)

or:

COALESCE(discount, 0)

But AI needs the business context to know whether that is actually the right decision.

Missing data is not just a coding problem.

It is an interpretation problem.

𝗡𝗨𝗟𝗟 ≠ 𝟬 ≠ 𝗕𝗹𝗮𝗻𝗸.

Understanding that small distinction can prevent some very big analytical mistakes.

💬 When you encounter NULLs, what do you check before deciding how to handle them?

📌 Save this for your next SQL or Python project.

🌐 More practical tutorials and cheat sheets:

EverydayDataScience.com

Follow AI & Data With Ibrahim for practical lessons on SQL, Python, Data Analytics, Data Engineering, Machine Learning, and AI.

Learn • Build • Share • Inspire

𝗔𝗜 𝗵𝗮𝘀 𝗺𝗮𝗱𝗲 𝗶𝘁 𝗲𝗮𝘀𝗶𝗲𝗿 𝘁𝗵𝗮𝗻 𝗲𝘃𝗲𝗿 𝘁𝗼 𝘄𝗿𝗶𝘁𝗲 𝗰𝗼𝗱𝗲.

Paste an error.

Describe what you want.

Seconds later, you have Python or SQL that looks ready to run.

But there is a skill becoming even more important:

Debugging.

Because AI-generated code can:

• Run without errors but produce the wrong result
• Reference the wrong column
• Use an inappropriate join
• Introduce data leakage
• Handle NULLs incorrectly
• Make assumptions you never specified
• Use outdated methods or libraries

So when AI gives me code, I don’t only ask:

“Does it run?”

I also ask:

1️⃣ Do I understand what every important step is doing?

2️⃣ What assumptions did AI make?

3️⃣ Are the inputs and data types what the code expects?

4️⃣ Can I test the logic on a few records manually?

5️⃣ Do the row counts and distributions still make sense?

6️⃣ Does the output answer the actual business question?

This is why I don’t think learning Python, SQL, or statistics has become less important because of AI.

I think the opposite has happened.

🤖 AI reduces the value of simply memorizing syntax.

But it increases the value of:

• Problem solving
• Debugging
• Validation
• Critical thinking
• Business understanding

𝗬𝗼𝘂 𝗱𝗼𝗻’𝘁 𝗻𝗲𝗲𝗱 𝘁𝗼 𝗰𝗼𝗺𝗽𝗲𝘁𝗲 𝘄𝗶𝘁𝗵 𝗔𝗜 𝗮𝘁 𝘄𝗿𝗶𝘁𝗶𝗻𝗴 𝗰𝗼𝗱𝗲.

You need to become good at knowing when the code is wrong.

💬 Has AI made you better at debugging—or more dependent on generated code?

📌 Save this for your next AI-assisted project.

🌐 More practical tutorials and cheat sheets:

EverydayDataScience.com

Follow AI & Data With Ibrahim for practical lessons on Python, SQL, Data Analytics, Machine Learning, Data Engineering, and AI.

Learn • Build • Share • Inspire

𝗔 𝗺𝗮𝗰𝗵𝗶𝗻𝗲 𝗹𝗲𝗮𝗿𝗻𝗶𝗻𝗴 𝗺𝗼𝗱𝗲𝗹 𝗰𝗮𝗻 𝗽𝗲𝗿𝗳𝗼𝗿𝗺 𝗴𝗿𝗲𝗮𝘁 𝗶𝗻 𝘁𝗵𝗲 𝗻𝗼𝘁𝗲𝗯𝗼𝗼𝗸 𝗮𝗻𝗱 𝘀𝘁𝗶𝗹𝗹 𝗳𝗮𝗶𝗹 𝗶𝗻 𝘁𝗵𝗲 𝗿𝗲𝗮𝗹 𝘄𝗼𝗿𝗹𝗱.

That is one of the biggest differences between building a model and building a reliable machine-learning system.

You can have:

• Strong validation scores
• Clean training data
• Good feature engineering
• A well-tuned model

And still run into problems after deployment.

Why?

Because production changes the game.

Here are 5 reasons a good model can fail after launch:

1️⃣ 𝗗𝗮𝘁𝗮 𝗱𝗿𝗶𝗳𝘁
The data your model sees today may not look like the data it was trained on.

Customer behavior changes.

Markets change.

Products change.

Processes change.

2️⃣ 𝗖𝗼𝗻𝗰𝗲𝗽𝘁 𝗱𝗿𝗶𝗳𝘁
The relationship between your inputs and target can change over time.

A pattern that predicted churn six months ago may not work the same way today.

3️⃣ 𝗕𝗮𝗱 𝗼𝗿 𝗺𝗶𝘀𝘀𝗶𝗻𝗴 𝗶𝗻𝗽𝘂𝘁𝘀
APIs fail.

Columns change.

Values go missing.

Categories appear that the model has never seen before.

4️⃣ 𝗙𝗲𝗲𝗱𝗯𝗮𝗰𝗸 𝗹𝗼𝗼𝗽𝘀
Your model can influence the behavior it is trying to predict.

For example, if a recommendation system keeps showing the same kind of content, future user behavior may partly reflect the model’s own decisions.

5️⃣ 𝗡𝗼 𝗺𝗼𝗻𝗶𝘁𝗼𝗿𝗶𝗻𝗴
If nobody is watching the model after deployment, performance can quietly degrade for weeks or months.

That is why production ML needs more than:

model.fit()

and

model.predict()

You also need to monitor:

• Input distributions
• Prediction distributions
• Performance metrics
• Missing values
• Latency
• Errors
• Business outcomes

🤖 𝗪𝗵𝗮𝘁 𝗮𝗯𝗼𝘂𝘁 𝗔𝗜?

AI can help you write the pipeline, generate monitoring code, detect anomalies, and summarize performance.

But someone still has to decide:

• What should be monitored?
• When is a change significant?
• When should the model be retrained?
• When should we fall back to a simpler rule?
• Is the model still helping the business?

𝗧𝗿𝗮𝗶𝗻𝗶𝗻𝗴 𝗮 𝗺𝗼𝗱𝗲𝗹 𝗶𝘀 𝗻𝗼𝘁 𝘁𝗵𝗲 𝗳𝗶𝗻𝗶𝘀𝗵 𝗹𝗶𝗻𝗲.

It is the beginning of the model’s real test.

💬 Which production ML challenge do you think is hardest: drift, monitoring, feedback loops, or data quality?

📌 Save this for your next machine-learning project.

🌐 More practical tutorials and cheat sheets:

EverydayDataScience.com

Follow AI & Data With Ibrahim for practical lessons on Python, SQL, Data Analytics, Machine Learning, Data Engineering, and AI.

Learn • Build • Share • Inspire

Everyday Data Science: Applied AI, Agentic Systems & AI in Africa Practical AI, machine learning, and data science for people who build, with a focus on agentic systems and applied AI in Africa. Written by practitioners.

𝗢𝗻𝗲 𝗦𝗤𝗟 𝗱𝗲𝗰𝗶𝘀𝗶𝗼𝗻 𝗰𝗮𝗻 𝗾𝘂𝗶𝗲𝘁𝗹𝘆 𝗿𝗲𝗺𝗼𝘃𝗲 𝗵𝘂𝗻𝗱𝗿𝗲𝗱𝘀 𝗼𝗳 𝗿𝗼𝘄𝘀 𝗳𝗿𝗼𝗺 𝘆𝗼𝘂𝗿 𝗮𝗻𝗮𝗹𝘆𝘀𝗶𝘀.

And sometimes, you will not even notice.

Imagine you have:

1,000 customers

and you join them to an orders table.

If you use:

INNER JOIN

you only keep customers who have matching orders.

So if 180 customers have never placed an order…

they disappear.

Your result now has 820 customers.

That may be exactly what you want.

Or it may completely change the business question.

This is why, during exploratory analysis, I often prefer to start with a:

LEFT JOIN

It keeps every customer from the left table—even when there is no matching order.

Then I can ask:

• Who has never ordered?
• Which records failed to match?
• Are the join keys clean?
• Are we losing important rows?
• Is “no match” itself an insight?

𝗧𝗵𝗲 𝗱𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝗰𝗲 𝗶𝘀 𝘀𝗶𝗺𝗽𝗹𝗲:

INNER JOIN → Keep only matches.

LEFT JOIN → Keep everything from the left + whatever matches on the right.

Neither is automatically better.

The correct join depends on the question you are answering.

Before accepting the result of any join, I like to check:

1️⃣ Row count before the join
2️⃣ Row count after the join
3️⃣ Number of unmatched records
4️⃣ Whether the join created duplicates
5️⃣ Whether the join key is actually unique

🤖 𝗔𝗻𝗱 𝘄𝗵𝗮𝘁 𝗮𝗯𝗼𝘂𝘁 𝗔𝗜?

AI can write your SQL join in seconds.

But if you simply say:

“Join these two tables”

it may produce perfectly valid SQL that answers the wrong business question.

You still need to understand:

What should happen to records that do not match?

That is not a syntax question.

That is an analysis question.

𝗚𝗼𝗼𝗱 𝗦𝗤𝗟 𝗶𝘀 𝗻𝗼𝘁 𝗷𝘂𝘀𝘁 𝗮𝗯𝗼𝘂𝘁 𝗴𝗲𝘁𝘁𝗶𝗻𝗴 𝘁𝗵𝗲 𝗾𝘂𝗲𝗿𝘆 𝘁𝗼 𝗿𝘂𝗻.

𝗜𝘁 𝗶𝘀 𝗮𝗯𝗼𝘂𝘁 𝗸𝗻𝗼𝘄𝗶𝗻𝗴 𝘄𝗵𝗶𝗰𝗵 𝗿𝗼𝘄𝘀 𝘆𝗼𝘂 𝗮𝗿𝗲 𝗸𝗲𝗲𝗽𝗶𝗻𝗴 — 𝗮𝗻𝗱 𝘄𝗵𝗶𝗰𝗵 𝗼𝗻𝗲𝘀 𝘆𝗼𝘂 𝗮𝗿𝗲 𝗹𝗼𝘀𝗶𝗻𝗴.

💬 Which do you use more during analysis: INNER JOIN or LEFT JOIN?

📌 Save this for your next SQL project.

🌐 More practical tutorials and cheat sheets:

EverydayDataScience.com

Follow AI & Data With Ibrahim for practical lessons on SQL, Python, Data Analytics, Data Engineering, Machine Learning, and AI.

Learn • Build • Share • Inspire

𝗠𝗼𝗿𝗲 𝗰𝗵𝗮𝗿𝘁𝘀 𝗱𝗼 𝗻𝗼𝘁 𝗺𝗮𝗸𝗲 𝗮 𝗯𝗲𝘁𝘁𝗲𝗿 𝗱𝗮𝘀𝗵𝗯𝗼𝗮𝗿𝗱.

In fact, they often make it worse.

One of the easiest mistakes to make in Power BI, Tableau, or Excel is trying to show everything.

Every KPI.

Every chart.

Every slicer.

Every possible breakdown.

The result?

A dashboard that looks busy but makes the decision harder.

𝗔 𝗴𝗼𝗼𝗱 𝗱𝗮𝘀𝗵𝗯𝗼𝗮𝗿𝗱 𝘀𝗵𝗼𝘂𝗹𝗱 𝗮𝗻𝘀𝘄𝗲𝗿 𝗮 𝗳𝗲𝘄 𝗶𝗺𝗽𝗼𝗿𝘁𝗮𝗻𝘁 𝗾𝘂𝗲𝘀𝘁𝗶𝗼𝗻𝘀 𝗾𝘂𝗶𝗰𝗸𝗹𝘆.

Before adding another visual, ask:

1️⃣ 𝗪𝗵𝗮𝘁 𝗱𝗲𝗰𝗶𝘀𝗶𝗼𝗻 𝗱𝗼𝗲𝘀 𝘁𝗵𝗶𝘀 𝗰𝗵𝗮𝗿𝘁 𝘀𝘂𝗽𝗽𝗼𝗿𝘁?

If the answer is “none,” it probably does not belong there.

2️⃣ 𝗗𝗼𝗲𝘀 𝗶𝘁 𝗮𝗱𝗱 𝗻𝗲𝘄 𝗶𝗻𝗳𝗼𝗿𝗺𝗮𝘁𝗶𝗼𝗻?

Three visuals telling the same story are usually unnecessary.

3️⃣ 𝗖𝗮𝗻 𝘁𝗵𝗲 𝘂𝘀𝗲𝗿 𝘂𝗻𝗱𝗲𝗿𝘀𝘁𝗮𝗻𝗱 𝗶𝘁 𝗶𝗻 𝟱 𝘀𝗲𝗰𝗼𝗻𝗱𝘀?

If not, simplify it.

4️⃣ 𝗜𝘀 𝘁𝗵𝗲 𝗺𝗼𝘀𝘁 𝗶𝗺𝗽𝗼𝗿𝘁𝗮𝗻𝘁 𝗶𝗻𝘀𝗶𝗴𝗵𝘁 𝗼𝗯𝘃𝗶𝗼𝘂𝘀?

Your audience should not have to hunt for the point.

5️⃣ 𝗖𝗼𝘂𝗹𝗱 𝗼𝗻𝗲 𝗯𝗲𝘁𝘁𝗲𝗿 𝘃𝗶𝘀𝘂𝗮𝗹 𝗿𝗲𝗽𝗹𝗮𝗰𝗲 𝘁𝘄𝗼 𝗼𝗿 𝘁𝗵𝗿𝗲𝗲 𝘄𝗲𝗮𝗸𝗲𝗿 𝗼𝗻𝗲𝘀?

Often, yes.

🤖 𝗔𝗜 𝗰𝗮𝗻 𝗯𝘂𝗶𝗹𝗱 𝘃𝗶𝘀𝘂𝗮𝗹𝘀 𝗳𝗮𝘀𝘁.

But speed can make it easier to overbuild.

AI can suggest charts, layouts, and KPIs.

You still need to decide what actually deserves attention.

𝗧𝗵𝗲 𝗯𝗲𝘀𝘁 𝗱𝗮𝘀𝗵𝗯𝗼𝗮𝗿𝗱 𝗶𝘀 𝗻𝗼𝘁 𝘁𝗵𝗲 𝗼𝗻𝗲 𝘄𝗶𝘁𝗵 𝘁𝗵𝗲 𝗺𝗼𝘀𝘁 𝗰𝗵𝗮𝗿𝘁𝘀.

It is the one that helps someone understand the situation and make a decision faster.

💬 What is the most common dashboard mistake you see?

📌 Save this before building your next dashboard.

🌐 More practical tutorials and cheat sheets:

EverydayDataScience.com

Follow AI & Data With Ibrahim for practical lessons on Power BI, Excel, SQL, Python, Data Analytics, Machine Learning, and AI.

Learn • Build • Share • Inspire

🚀 **AI can clean your data.**

But can you tell if it cleaned it correctly?

That's becoming one of the most valuable skills in data analytics.

Today, tools like ChatGPT, Claude, and GitHub Copilot can generate Pandas code in seconds.

I use AI every day.

But here's the reality:

**AI is only as good as the person reviewing its output.**

Imagine AI gives you code to fill missing values.

Do you know:

- Should the missing values be removed or filled?
- Is the median a better choice than the mean?
- Are those duplicates actually duplicates?
- Is that outlier an error or a legitimate business event?
- Did the cleaning introduce bias into your analysis?

These are decisions AI **cannot** make for you without context.

That's why every Data Analyst needs strong data cleaning fundamentals.

Master these 10 tasks and you'll be able to:

✅ Handle missing values correctly

✅ Remove duplicate records

✅ Fix incorrect data types

✅ Standardize inconsistent text

✅ Detect outliers

✅ Validate your data

Because here's the truth:

**Garbage In = Garbage Out.**

Even the most advanced AI model can't produce reliable insights from poor-quality data.

Clean data is the foundation of accurate dashboards, trustworthy reports, and successful machine learning models.

The goal isn't to avoid AI.

The goal is to **use AI with understanding.**

When you know the fundamentals, AI becomes your assistant—not your replacement.

💬 **Which data cleaning task do you find the most challenging?**

👇 **Save this post.** It's a checklist you'll use throughout your data analytics journey.

📚 Get more free Data Analytics cheat sheets, tutorials, and career resources:

**https://everydaydatascience.com**

Follow **AI & Data With Ibrahim** for practical lessons on SQL, Python, Data Analytics, Data Engineering, Machine Learning, and AI.

**Learn • Build • Share • Inspire**