🚀 Open the live playground  ·  📚 98-function reference  ·  💼 Interview prep  ·  🏗️ Real scenarios

Live Power Fx playground · searchable function reference · code library · real-world architectures · interview prep · light & dark mode

• What's inside
• The playground
• What's new in v2
• Tech stack
• Repository layout
• Run it locally
• Publishing: how the live site updates
• Security model
• Certifications (2026)
• Contributing
• Credits
• Disclaimer & license

The centrepiece: type Power Fx, hit RUN, and watch it evaluate against live data — no sign-in, no backend, no build step.

• 98 Power Fx functions across Text, Math, Date & Time, Logic, Table and Behaviour categories
• Two 100-record datasets (Employees, Orders) from a seeded generator — dates, decimals, booleans and deliberate Blank() cells
• IntelliSense popup with live signatures — ↑/↓ navigate, Tab/Enter accept, Esc dismiss
• ? help — explains the function under your cursor, with a valid example you can run in one click
• 🗄 data — browse both datasets in a table, Blank() cells included
• Structured code view — line numbers + syntax highlighting
• Records and tables — {Name: "Ada"} and [1, 2, 3], with ; statement chaining
• ⌘/Ctrl + Enter to run; every reference card can push its example straight into the editor

git clone https://github.com/LellaSriHarsha/power-platform-hub.git
cd power-platform-hub
open docs/index.html                 # macOS
# xdg-open docs/index.html           # Linux
# start docs\index.html              # Windows

A local server is slightly better (clipboard, Web Worker and fonts behave exactly like production):

cd docs && python3 -m http.server 8000     # then open http://localhost:8000

The editable source lives in app/. Bun is what Lovable uses; npm works too.

cd app

bun install && bun run dev           # http://localhost:8080
# or
npm install && npm run dev

bun run build                        # production build
bun run lint                         # eslint
bun run format                       # prettier

The React shell renders a loading state and hands off to the self-contained powerverse.html bundle, which is where the playground actually runs.

The Power Fx engine, the 98-function reference, the seeded datasets, the snippets, the scenarios and the interview bank all carried over — v2 is the same content in a sturdier shell.

power-platform-hub/
├── docs/                       # ← GitHub Pages serves this folder
│   ├── index.html              #   the published app (self-contained bundle)
│   ├── js-runner.js            #   Web Worker used by the JS playground
│   ├── favicon.ico
│   ├── robots.txt
│   ├── .nojekyll               #   serve the files as-is, no Jekyll processing
│   └── classic/
│       └── index.html          #   v1 single-file edition, preserved
├── app/                        # editable source (React 19 + TanStack Start + Tailwind 4)
│   ├── src/
│   │   ├── routes/             #   router entry + the shell that hands off to the app bundle
│   │   ├── components/ui/      #   shadcn/ui primitives
│   │   ├── lib/                #   error capture + helpers
│   │   └── styles.css
│   ├── public/
│   │   ├── powerverse.html     #   the self-contained app bundle
│   │   └── js-runner.js
│   ├── package.json
│   ├── vite.config.ts
│   └── tsconfig.json
├── assets/
│   └── banner.svg              # README hero artwork (hand-authored SVG)
├── scripts/
│   └── sync-from-lovable.sh    # pull the newest Lovable build into docs/ + app/
├── README.md
├── LICENSE
└── .gitignore

Associate/expert certifications renew free each year via an online assessment; fundamentals do not expire.

GitHub Pages is configured to deploy the docs/ folder from main:

Settings → Pages → Source: Deploy from a branch → main → /docs

So the publish rule is simple: whatever lands in docs/ is what the world sees.

Lovable keeps its own working copy in a separate private repository, so this repo includes a sync helper:

./scripts/sync-from-lovable.sh

It clones the Lovable export, copies the static build into docs/, mirrors the source into app/, then commits and pushes — GitHub Pages redeploys about a minute later.

# point it at a different Lovable repo if you ever recreate the project
./scripts/sync-from-lovable.sh https://github.com/<user>/<lovable-repo>.git

# 1. copy the new build into docs/ (keep docs/classic untouched)
rsync -a --exclude 'classic' /path/to/lovable/docs/ docs/

# 2. ship it
git add -A && git commit -m "chore: publish latest build" && git push

• .nojekyll is present so Pages serves the bundle verbatim.
• The app is a single self-contained index.html, so it works at any subpath — including /power-platform-hub/ — with no base-path configuration.
• The React shell in app/src/routes/index.tsx resolves its hand-off target relative to the current document rather than the domain root, so it also works from a project subpath.

• Power Fx formulas are evaluated by a limited local interpreter against generated sample data.
• JavaScript examples run in a dedicated Web Worker, never in the page context, and are stopped after 2 seconds.
• All dynamic playground output is escaped before display.
• A restrictive Content-Security-Policy limits scripts, connections, objects and embedding.
• No user data is collected or sent to any server — everything happens in your browser.

The JavaScript playground is an educational tool, not a production sandbox. Don't paste secrets or untrusted code into it.

Issues and PRs are welcome. Good places to start:

• New Power Fx functions — add an entry to the FN[] reference data and the matching case in the evaluator, then publish the rebuilt bundle to docs/
• More scenarios or interview questions — the platform grows every release (agents, Fabric, Dataverse MCP)
• Engine parity improvements — delegation warnings, collection persistence, JSON(), Choices(), ParseJSON()
• Accessibility — keyboard traps, focus order in the modals, contrast in light mode
• Docs — corrections, better examples, anything unclear

Conventions:

1. Content changes must be mirrored in both app/public/powerverse.html and docs/index.html (or run the sync script).
2. Keep the playground dependency-free — the Power Fx engine stays plain JavaScript.
3. Run bun run lint inside app/ before opening a PR.
4. Describe the "why" in your PR body; screenshots help for UI changes.

Open an issue with the formula you ran, what you expected, and what happened. The engine is a subset implementation, so "function X isn't supported yet" is a valid, useful report.

• Content and the original Power Fx engine — SriHarsha
• v2 application shell and design iteration — built with Lovable
• Function semantics based on the official Microsoft Power Fx documentation
• Fonts served by Google Fonts: Chakra Petch, Instrument Sans, JetBrains Mono

If this helped you pass an exam or ship your first app, a ⭐ on the repo is the best thank-you.

This is an unofficial, community-built learning resource and is not affiliated with or endorsed by Microsoft. Microsoft, Power Platform, Power Apps, Power Automate, Power BI, Power Pages, Copilot Studio and Dataverse are trademarks of Microsoft Corporation. Certification details reflect publicly available information as of 2026 — always confirm on Microsoft Learn before booking an exam.

MIT — free to use, fork, teach with and remix. See LICENSE.