What Is Microsoft Power Fx? The Low-Code Language of the Power Platform

Power Fx is the low-code language of Microsoft Power Platform. It is a general-purpose, strongly typed, declarative and functional language, expressed in human-friendly text — the same Excel-like formula language that has always powered canvas apps in Power Apps, now being extended across the Power Platform and released as open source. If you have ever written a formula in Excel, you already know how to think in Power Fx.

What is Power Fx?

Power Fx lets you describe logic in concise formulas that you type directly into an Excel-like formula bar — or, for professionals, into a text editor such as Visual Studio Code. The “low” in low-code comes from the simple, compact nature of the language: it covers the full spectrum from no-code for people who have never programmed to pro-code for seasoned developers, with no learning or rewriting “cliffs” in between.

• Excel-like — types, operators and function names borrow heavily from the Excel formula language you already know.
• Declarative & functional — you say what you want, not how or when; most work is done with pure functions that have no side effects.
• Strongly typed — the type of every value is known as you author, so mistakes are caught early with rich suggestions.
• Open source — Microsoft is extracting Power Fx from Power Apps and publishing it on GitHub so it can be reused everywhere.

Think spreadsheet

Every language has expressions — a way to calculate over numbers, strings and other data (for example mass * acceleration). Power Fx goes one step further: instead of a lone expression, you write a formula that binds an expression to a name.

// A formula binds a name to a calculation
force = mass * acceleration

When mass or acceleration changes, force is recalculated automatically — exactly like a cell in Excel. Bind a control’s Visible or Fill property to a formula and it simply stays correct as its inputs change. There are no OnChange event handlers to wire up, because there is no “when” for you to manage. Logic is built from many small, independent formulas rather than large monolithic procedures, which makes it far easier to read and safely change.

Always live

A worksheet has no compile or run mode — edit a formula and results update instantly. Power Fx works the same way, using an incremental compiler that keeps your app in sync with its data as you type. That also powers a rich editing experience: IntelliSense, autocomplete, type checking and immediate error highlighting. A mistake surfaces right away without stopping the rest of the app, and there is no build step — only a publish step to decide which version your users get.

From no-code to pro-code — with no cliffs

• No-code — switches, colour pickers and UI builders read and write Power Fx for you. The formula bar stays visible so you can see (and learn) what is happening on your behalf.
• Low-code — drop into the formula bar and take any property further, for example wrapping a colour in ColorFade(…) or adding a Sort.
• Pro-code — store formulas in YAML source files, edit them in VS Code, and put them under source control in GitHub or Azure DevOps. Reusable components and user-defined functions let professionals build and share building blocks.

What Power Fx quietly does for you

Because formulas are declarative, the system is free to optimise. A one-line lookup can hide a surprising amount of work:

• Asynchronous by default — data operations don’t block, and you never manage promises or callbacks.
• Local and remote, one syntax — the same functions work in-memory or against a database or service, and Power Fx delegates filters and sorts to the server when it can.
• Relational, without keys — walk relationships with simple dot notation like .Employee.'First Name'; no joins or foreign keys to hand-write.
• Automatic projection & paging — only the columns you actually use are fetched, and large results are paged in as the user scrolls.
• Display names & localization — friendly, translatable column names in the formula, correct logical names sent to the data source.

A few example formulas

// Look up one related value with dot notation
LookUp( Orders, OrderID = 43860 ).Employee.'First Name'

// Filter and sort a data source
Sort( Filter( Orders, Status = "Active" ), 'Order Date' )

// Concatenate strings with & (just like Excel)
"Hello, " & Customer.Name & "!"

// Show a success banner (imperative logic, when you need it)
Notify( "Saved successfully", NotificationType.Success )

Design principles

• Simple & Excel-consistent — keep the number of new concepts to a minimum; when Excel has no answer, look to SQL next.
• Declarative & functional — describe intent and prefer pure functions, giving the compiler room to optimise.
• Composition — powerful behaviour is built by composing small functions (for example Sort and Filter together in one Items property).
• Strongly typed with type inference — types are known at compile time but inferred from use, so you rarely declare them.
• Not object-oriented — like Excel, length is Len("Hello"), not "Hello".length.
• Language evolution — every document is version-stamped and “back-compat converters” quietly upgrade old formulas, so apps built years ago still open today.
• No undefined — there is no undefined; uninitialised values are simply blank or a clear error.

Where you’ll use Power Fx

Today Power Fx powers canvas apps in Power Apps, where most makers first meet it in the formula bar. Microsoft is extracting the language so the same formulas can be used across the wider platform — Power Automate expressions, Copilot Studio agents, cards and more — and it is available as open source on GitHub. Learning it once pays off in many places.

Why it matters

Power Fx answers a simple question: what if building an app were as approachable as building a spreadsheet? By reusing Excel concepts that hundreds of millions of people already know, it lets citizen makers start fast while giving professionals a real path to source control, components and reuse — one language, no cliffs, from no-code to pro-code.

If you can write an Excel formula, you can start building with Power Fx today — and the same skill carries across Power Apps, Power Automate and Copilot Studio.

---

Keywords: Microsoft Power Fx, what is Power Fx, Power Fx language, low-code language Power Platform, Power Apps formulas, canvas apps, declarative functional language, Excel-like formulas, delegation, Power Fx examples, Power Fx design principles, Power Fx GitHub open source.