Power QueryExercises

How long does it take to learn Power Query? A realistic timeline

Career · By Tahir Nas · Examples run in our simulator · Updated

10 min read

As a planning guide, expect to build a first useful query in an afternoon, and to handle everyday cleaning jobs confidently after a few weeks of short, regular practice. Robust queries and your own M functions take longer, usually a few months of using Power Query on real work, because those skills come from meeting messy data rather than from reading.

The short answer, stage by stage

Power Query is not one skill. Importing a CSV and removing two columns is a different job from writing a function that cleans fifty files in a folder. A useful way to plan is to split the learning into four stages and judge each by what you can do, not by how long you have studied.

StageWhat you can doRough time with regular practice
1. First useful queryImport a file, fix types, filter, sort, load and refreshA few hours to a week
2. Everyday cleaningSplit and clean text, merge, append, group, unpivotTwo to four weeks
3. Robust queriesHandle errors, foreign formats, folders of files, parameters, refresh-proof stepsOne to three months of real use
4. M fluencyRead and edit M freely, write custom functions, work with lists and recordsSeveral months and beyond

"Regular practice" here means something like twenty to thirty minutes on most days, the pace the site's four-week practice plan is built around. The times are estimates for planning: they follow the order and pacing of the site's four-week plan and foundations learning path, and they are not measured from a group of learners. Someone who already writes SQL or complex Excel formulas will move faster through stages 2 and 4; someone who rarely handles raw exports will take longer over stage 3, because the problems it solves haven't happened to them yet.

Stage 1: your first useful query

The first stage is about the mental model: Power Query records your steps and replays them on refresh, without changing the source. Microsoft describes Power Query as a way to "save the transformation steps as a repeatable query that you can refresh" (What is Power Query?, Microsoft Learn). Once that clicks, the editor's buttons make sense.

By the end of stage 1 you should be able to build something like this from the ribbon, and understand the M the editor wrote for you:

let
    Source = #table(
        {"OrderID", "Region", "Status", "Amount"},
        {{"A-1", "North", "Complete", "120.50"}, {"A-2", "South", "cancelled", "80"}, {"A-3", "North", "Complete", "45"}, {"A-4", "South", "Complete", "200"}}
    ),
    Typed = Table.TransformColumnTypes(Source, {{"Amount", type number}}, "en-GB"),
    Complete = Table.SelectRows(Typed, each [Status] = "Complete"),
    Sorted = Table.Sort(Complete, {{"Amount", Order.Descending}})
in
    Sorted

Result

OrderIDRegionStatusAmount
A-4SouthComplete200
A-1NorthComplete120.5
A-3NorthComplete45

Output produced by the Power Query Exercises simulator, an independent implementation of a documented subset of M.

The result keeps three orders, largest first: A-4, A-1 and A-3. The lower-case "cancelled" row is excluded only because it isn't equal to "Complete"; if the filter had been <> "Cancelled" it would have slipped through, because text comparison in M is case-sensitive. Noticing that kind of detail is the real goal of stage 1. (The "en-GB" argument tells the type change to read "120.50" with a decimal point whatever the computer's regional settings; stage 3 comes back to this.)

A good starting point is Power Query for beginners, followed by the exercise clean and summarise a sales export.

Stage 2: everyday cleaning

Stage 2 covers the transformations that most real jobs use: text cleaning, splitting columns, merges, appends, Group By, pivot and unpivot. None of these is hard on its own. The time goes into learning which one a problem needs, and into understanding what a merge does to your row count.

A typical stage-2 task joins two tables and summarises them:

let
    Orders = #table({"OrderID", "CustomerID", "Amount"}, {{"A-1", "C1", 120}, {"A-2", "C2", 80}, {"A-3", "C1", 45}, {"A-4", "C3", 200}}),
    Customers = #table({"CustomerID", "City"}, {{"C1", "Leeds"}, {"C2", "York"}, {"C3", "Leeds"}}),
    Merged = Table.NestedJoin(Orders, {"CustomerID"}, Customers, {"CustomerID"}, "Customer", JoinKind.LeftOuter),
    Expanded = Table.ExpandTableColumn(Merged, "Customer", {"City"}),
    ByCity = Table.Group(Expanded, {"City"}, {{"Orders", each Table.RowCount(_), Int64.Type}, {"Revenue", each List.Sum([Amount]), type number}})
in
    ByCity

Result

CityOrdersRevenue
Leeds3365
York180

Output produced by the Power Query Exercises simulator, an independent implementation of a documented subset of M.

Leeds has three orders worth 365 and York one order worth 80. The self-test for this stage: before running a merge and expand, say how many rows they will return. If the customer table had two rows for C1, the answer would change, and knowing why is what separates stage 2 from stage 1. The exercise predict how many rows each order becomes after a merge covers it.

Stage 3: queries that survive refresh

Stage 3 is where the timeline stretches, because it is learned from failures. A query that worked on Monday breaks on Thursday because a column was renamed, a number arrived as "n/a", or a file came from a colleague in another country, the same changes behind Excel reports that break every month. Each of these teaches a pattern: refer to columns by name, convert types with a culture, combine from a folder, and decide what to do with values that won't convert. The post on habits that keep queries easy to maintain collects these patterns in one place.

Handling bad values on purpose looks like this:

let
    Source = #table({"Sensor", "Reading"}, {{"S1", "21.5"}, {"S2", "n/a"}, {"S3", "19"}}),
    Parsed = Table.AddColumn(Source, "Value", each try Number.From([Reading]) otherwise null, type nullable number),
    Flagged = Table.AddColumn(Parsed, "Problem", each [Value] = null, type logical)
in
    Flagged

Result

SensorReadingValueProblem
S121.521.5false
S2n/anulltrue
S31919false

Output produced by the Power Query Exercises simulator, an independent implementation of a documented subset of M.

S2's "n/a" becomes null and is flagged as a problem, while S1 and S3 convert to 21.5 and 19. The important part is the last step: the bad value is not only replaced but reported, so nobody mistakes a missing reading for a real one. The lesson on try … otherwise explains the expression.

You can speed this stage up by practising on data that is already broken, so you meet the failures in an afternoon instead of over several months. The exercise debug a query that works today and breaks on refresh is built for that.

Stage 4: reading and writing M

M is the formula language behind every Power Query step. Microsoft's reference calls it "a functional, case-sensitive language similar to F#" (Power Query M formula language, Microsoft Learn). You meet M from day one in the formula bar, but fluency, the point where you would rather type a step than click it, usually comes last.

The marker of stage 4 is writing your own function and applying it to a table:

let
    ShippingCost = (weightKg as number, optional express as nullable logical) as number =>
        let
            Base = if weightKg <= 2 then 4.5 else 4.5 + (weightKg - 2) * 1.2,
            Total = if express = true then Base * 1.5 else Base
        in
            Number.Round(Total, 2),
    Orders = #table({"OrderID", "WeightKg", "Express"}, {{"A-1", 1.5, false}, {"A-2", 5, false}, {"A-3", 5, true}}),
    WithCost = Table.AddColumn(Orders, "Shipping", each ShippingCost([WeightKg], [Express]), type number)
in
    WithCost

Result

OrderIDWeightKgExpressShipping
A-11.5false4.5
A-25false8.1
A-35true12.15

Output produced by the Power Query Exercises simulator, an independent implementation of a documented subset of M.

The costs come out as 4.5, 8.1 and 12.15. A 5 kg parcel costs 4.5 plus 3 kg at 1.2, which is 8.1, and the express option multiplies that by 1.5. The lesson write and use custom functions is the next step once this reads naturally.

Many analysts work productively for years in stages 2 and 3 without writing a function from scratch. Stage 4 matters most if you maintain queries for other people, combine many similar files, or are aiming at a role where Power Query is a core part of the job. For that, showing Power Query skills on a CV covers how to prove them.

What changes your timeline

  • How often you practise. We suggest short, frequent sessions over occasional long ones, so that each session picks up where the last left off. Twenty minutes on most days is a pace that is easy to sustain.
  • Whether you have real data. The patterns in stage 3 only make sense once you have seen the failure they prevent. If your job doesn't supply messy exports, practise on prepared ones.
  • What you already know. Strong Excel users know lookups and pivots, which map directly to merges and Group By. SQL users already think in joins and set operations; the guide SQL to Power Query M maps one to the other.
  • Whether you read the M. Opening the Advanced Editor after every few steps is the fastest way from stage 2 to stage 4, even before you write any M yourself.

If you have a deadline

For a job interview or practical test, aim for solid stage 2 with the stage-3 basics: types and locale, merges with the right join kind, Group By, unpivot, and simple error handling. The guide to preparing for a Power Query practical test covers the format of typical tasks.

For the Power BI Data Analyst certification, Microsoft's study guide for exam PL-300 (skills measured as of 20 April 2026) lists "Prepare the data" as 25–30% of the exam, covering skills such as resolving data import errors, pivot and unpivot, merge and append queries, and choosing column data types (Study guide for Exam PL-300, Microsoft Learn). That maps closely onto stages 1 to 3 here. Microsoft also publishes a free module, Clean, transform, and load data in Power BI, whose objectives include profiling data, combining queries and editing M in the Advanced Editor.

How to check where you are

Predict, then run. Take any query from a lesson or exercise, read it, write down the result you expect, and only then run it. If your prediction is right for stage-2 queries but wrong for stage-3 ones, that tells you exactly where to spend the next fortnight.

The free quizzes include predict-the-output questions with every answer explained, and the timed assessments, part of the Pro plan, give you a mark against a pass threshold. Power Query Exercises checks every exercise against hidden variations of the data, so a passing answer shows that your steps keep working when the data changes, not just on the sample you were given.

Frequently asked questions

Can I learn Power Query without learning M?

Yes, for most everyday work. The editor generates M for every step you click. Reading that M becomes useful in stage 2 and important in stage 3, but writing it from scratch is only needed for stage-4 tasks.

Is Power Query harder to learn than Excel formulas?

It is different rather than harder. Formulas work cell by cell; Power Query works on whole columns and tables as a sequence of steps. People who already think in terms of tables, such as pivot table or SQL users, often find it quicker to pick up.

Is learning Power Query in Excel the same as in Power BI?

The engine and the M language are the same in both, so the skills transfer. Loading, refresh and some connectors differ by host, so check where your results load and how they refresh when you move between them.

Sources

About the author

Tahir Nas, software engineer, writes and reviews the lessons, guides and exercises on Power Query Exercises. Tahir has 8 years of experience in tech, working across system administration, cloud architecture, QA, scripting and automation, and software engineering in many languages and mainstream databases. GitHub profile. Every M example shown with a result was run in the site's simulator when the page was built, and the output is that run's result; examples marked for Excel and Power BI only are shown without output. How content is tested.

Keep reading

Practise Power Query in the browser with graded exercises checked against fresh data.

Power Query Exercises is an independent educational platform and is not affiliated with, endorsed by, sponsored by, or approved by Microsoft Corporation. All third-party trademarks belong to their respective owners.