20 Data Analytics Project Ideas for Beginners, by Tool and Difficulty

A certificate proves you sat through a course. A project proves you can take a messy dataset, ask a real business question of it, and come back with an answer someone could act on. LinkedIn's own hiring data backs this shift up directly: employers are looking less at job titles or degrees and more at what people can actually do, and for an entry-level data analyst with no work history to point to, a portfolio of real projects is the only evidence of "what you can actually do" that exists yet.

The problem isn't a shortage of project ideas. It's that most lists are either forty generic "analyse this Kaggle dataset" suggestions with no structure, or five overused ones (the Titanic dataset, the Iris dataset) that every recruiter has seen a thousand times. This list is neither. Twenty projects, organised by the tool they primarily test and the difficulty band they sit in, each with a specific business question, a note on where to get realistic data, and what completing it actually demonstrates.

What makes a project count, before you pick one

Not every finished notebook is a portfolio piece. A project earns its place when it does four things: it uses a real or realistically messy dataset, not a pre-cleaned textbook table; it starts from an actual business question rather than "explore this data"; it involves genuine cleaning and transformation work, because that's most of the job; and it ends in a dashboard, report or written summary with a recommendation, not just a chart. A project that skips the recommendation is a data exercise. A project that includes one is an analyst's work.

Keep that bar in mind as you pick from the list below. Two or three projects done to that standard, with a clear write-up of the decisions you made, outperform ten half-finished notebooks every time.

How to use this list

Pick projects that match two things: the tools your target roles actually ask for, and your current skill level rather than the level you'd like to be at. A Beginner-tagged project done well is a stronger portfolio piece than an Advanced one done badly. The difficulty labels below reflect the technical complexity of the analysis, not the length of time it takes.

Excel projects

Excel projects are the fastest to start and the easiest for a non-technical interviewer to actually open and review, which makes them a good place to begin a portfolio even if your target roles lean more technical. If you haven't settled on which Excel skills are actually worth your time yet, the Excel for Data Analysis guide covers the working set these projects draw on.

1. Sales Performance Dashboard (Beginner). Build an interactive dashboard tracking revenue, targets and regional performance using Pivot Tables, Pivot Charts and slicers. Use a realistic multi-region, multi-month sales dataset rather than a single flat table; the interesting part of this project is handling a dataset messy enough to need real cleaning before the pivot works. This mirrors the first project in Gradient's own curriculum, and it's the project most interviewers will recognise, so the differentiator is the quality of the insight you extract, not the fact that you built a dashboard at all.

2. Customer Segmentation, RFM (Intermediate). Segment customers by Recency, Frequency and Monetary value using formulas and Pivot Tables, then identify which segment deserves a retention campaign and which is safe to deprioritise. This project demonstrates business judgment, not just Excel skill, because the interesting question isn't the segmentation itself but what you'd recommend doing with each segment.

3. Marketing Campaign ROI Report (Beginner). Pull together spend and conversion data across several channels (search, social, email, referral) and calculate ROI per channel. The trap to avoid is reporting spend and revenue without ever calculating a ratio; the whole point of an ROI report is the ratio, not the raw numbers either side of it.

4. Employee Attrition Tracker (Intermediate). Using an HR dataset (tenure, department, exit reason, performance rating), identify which teams or tenure bands show the highest attrition and what those leavers have in common. This is a genuinely underused project idea; HR analytics rarely appears in beginner portfolios, which makes it a small but real differentiator.

SQL projects

SQL projects matter most for interview credibility, since live SQL rounds are standard at most companies hiring analysts. These are best built against a proper relational schema (multiple joined tables), not a single flat CSV, because the whole point is proving you can join, aggregate and filter correctly.

5. E-commerce Order Analysis (Beginner). Using orders, customers and products tables, write queries to find best-selling products, highest-value customers and monthly revenue trends. This is the project to demonstrate JOIN and GROUP BY fluency cleanly, before moving to anything more advanced.

6. Cohort Retention Analysis (Intermediate). Group users by signup month and track what percentage of each cohort returns in the following weeks or months. This is one of the strongest SQL projects available at this level, because cohort analysis is genuinely underrepresented in beginner portfolios and directly relevant to product-company interviews.

7. Signup Funnel Drop-off Analysis (Intermediate). Model a multi-step funnel (visited, signed up, verified email, completed profile, made first purchase) and calculate the drop-off rate at each step using window functions. The trap here is timestamp ordering: make sure a user's funnel steps are genuinely sequential in your data before trusting the drop-off numbers.

8. Customer Lifetime Value Query Set (Advanced). Write a set of queries that calculate CLV by segment, incorporating repeat purchase rate and average order value, then rank segments by their contribution to total lifetime value. This pairs naturally with project 2, giving you both an Excel and a SQL version of a related business question, which is a good story to tell in an interview.

Python and Pandas projects

Python projects prove you can handle a dataset too large or too irregular for Excel, and that you can build something repeatable rather than one-off.

9. Exploratory Data Analysis on a Messy Dataset (Beginner). Take a genuinely messy public dataset (inconsistent formatting, missing values, mixed types) and run a structured EDA: understand the shape of the data, clean it, and summarise what you found and what you fixed. Resist the urge to skip straight to charts; the cleaning and the "here's what was wrong with this data" writeup is the actual skill being demonstrated.

10. Customer Churn Analysis (Intermediate). Using a customer dataset with usage and subscription features, identify the characteristics that differ most between customers who churned and those who didn't. You don't need a machine learning model to make this a strong project; a well-reasoned comparison of churned versus retained customers, backed by clear descriptive statistics, is often more convincing to an analyst interviewer than a model with unexplained feature importances.

11. A/B Test Results Analysis (Intermediate). Given control and variant group data, calculate the observed lift, build a confidence interval, run the appropriate hypothesis test, and write a recommendation on whether to ship. This project is a strong pairing with statistical reasoning specifically; it shows you can go past "the variant won" into the full analysis a real rollout decision requires.

12. Automated Monthly Reporting Script (Advanced). Build a script that takes a raw monthly data export, cleans it, calculates a standard set of metrics, and outputs a formatted report automatically. This project demonstrates something the others don't: that you think about repeatability, not just one-off analysis, which is exactly the instinct that separates an analyst who scales with a growing team from one who doesn't.

Power BI and Tableau projects

BI tool projects are where you prove you can build something a non-technical stakeholder would actually use, not just something that's technically correct. If you haven't decided which tool to prioritise yet, Power BI vs Tableau vs Excel walks through how to choose based on the companies you're targeting rather than which one looks nicer in a screenshot.

13. Interactive Sales KPI Dashboard (Beginner). Build a dashboard with headline KPIs, trend lines and drill-down filters, published from a properly modelled dataset rather than a single flat table. The habit worth demonstrating here is designing for a specific audience; a dashboard built for a regional manager looks different from one built for a CFO, and saying so in your write-up shows design thinking, not just tool fluency.

14. Executive Summary Dashboard (Intermediate). Design a single-page view answering "how is the business doing" in the time it takes to glance at a screen. The constraint is the whole exercise: an executive dashboard crammed with fifteen charts has failed at its actual job, regardless of how correct each chart is.

15. Product Funnel and Retention Dashboard (Advanced). Combine funnel drop-off and cohort retention (building on projects 6 and 7 if you've done them in SQL first) into a single interactive dashboard that a product manager could use to spot where users are being lost. This is the strongest single BI project on this list for anyone targeting a product company, because product analytics is one of the most under-covered areas in most beginner portfolios.

16. Regional Performance Map (Intermediate). Use a filled map visual to show how a metric (revenue, orders, customer count) varies geographically, with a filter to compare periods. Indian regional or state-level data works particularly well here and gives the project a distinct, locally relevant flavour instead of the default US-state map every tutorial uses.

Cross-tool and capstone projects

These four combine multiple tools deliberately, because that's what a real analyst project actually looks like, and because a project spanning tools is a stronger signal of employability than four single-tool projects of the same difficulty.

17. Customer Churn and Retention Intelligence (Advanced, capstone-style). Clean and explore a customer dataset in Python, build a churn analysis and segment breakdown, then present the findings in a Power BI dashboard with a written set of recommendations. This mirrors the structure of a genuine end-to-end capstone project and is the single strongest portfolio piece on this list if you only have time to build one thing well.

18. UPI and Digital Payments Adoption Trends (Intermediate). Pull transaction volume data from RBI or NPCI public releases, model adoption trends across states or time periods in SQL, and visualise the result in Excel or a BI tool. This is a genuinely under-used project idea for the Indian job market specifically, and one that immediately signals familiarity with the domain most Indian fintech interviewers will ask about.

19. IPL or Cricket Stats Dashboard (Beginner to Intermediate). Pull a season's match and player data and build a dashboard exploring which factors correlate most with match outcomes. This project earns its place for a practical reason: it's genuinely engaging to build, which means people who choose it tend to finish it, and a finished mid-tier project beats an abandoned ambitious one every time. It also gives you something relatable and low-pressure to talk through in an interview.

20. Government Open Data Deep Dive (Intermediate). Pick a specific, narrow question (a state's employment trends, a city's transport patterns, a sector's export data) and answer it using a public dataset from data.gov.in or a similar source, pulling and shaping the data in SQL or Python. The discipline this project teaches is scoping: public datasets are enormous, and picking one specific question rather than "exploring" the whole dataset is itself a skill worth demonstrating.

Where to find realistic data

The projects above work far better with data that has some actual mess in it. A broader Data Analyst roadmap is a useful reference for where project work fits into your overall learning sequence, but for the data itself, government open-data portals (data.gov.in, RBI, NPCI, census data), Kaggle's less-polished datasets, and company-published transparency reports all tend to have the inconsistencies, missing values and formatting quirks that a textbook CSV strips out. That mess is a feature for a portfolio project, not a bug: cleaning it is exactly what you'd be doing in the job.

Common mistakes

• Choosing ten projects instead of finishing three. A recruiter opening a GitHub profile spends under a minute per repository. Depth on a few beats breadth across many.

• Using a pre-cleaned dataset and skipping the cleaning step entirely. The cleaning is most of the actual skill being tested; a project without it looks like it took an afternoon, because it did.

• Ending at the chart instead of the recommendation. "Here's a chart showing churn by segment" is unfinished. "Segment B is churning at twice the rate of Segment A, and here's the one variable that explains most of the gap" is a project.

• Copying a tutorial project without changing the question or the data. Interviewers can tell. Swap the dataset, change the business question, or add a step the tutorial didn't cover.

• Picking every project at the hardest difficulty available. A messy Advanced project you half-finished is a worse signal than a clean Beginner one you finished properly and can explain in detail.

How to present these once they're built

A project only counts as a portfolio piece once someone else can find and understand it. Host the code and any notebooks on GitHub with a clear README explaining the business question, the approach and the finding, not just the code itself. For dashboard projects, a short screen recording or a set of annotated screenshots matters more than people expect, since not every recruiter will download a Power BI or Tableau file to click through it themselves. Whichever format you use, the write-up should let someone understand what you found in under two minutes, even if they never open the file at all.

Where to go from here

Building the project is only half of this; being able to talk through the decisions you made, why you chose one join over another or one chart type over another, is what actually gets tested in an interview. If your SQL is the weaker half of any of the cross-tool projects above, the SQL for Data Analysts guide covers the joins, aggregations and window functions these projects lean on most.

If you'd rather build these projects with structured feedback instead of guessing whether your approach is right, the 20-week Data Analytics program includes four guided projects and a capstone modelled closely on project 17 above, reviewed by working analysts rather than left to self-assessment.