October 28, 2025 • 21 mins
The Myth of “Low-Code for Everyone”Most people think Power Apps is about dragging buttons onto screens until something vaguely resembling an app appears. Click, drag, publish—done. Wrong. That’s the fairy tale version Microsoft marketed to “empower everyone,” and it worked—too well. Because now, there’s a new species loose in the ecosystem: Vibe Code. That’s the evolution where Power Apps meets serious development. Equal parts JavaScript, Git discipline, and AI-assisted chaos.See, Power Apps started as a playground for business users: citizen developers armed with enthusiasm and questionable naming conventions. The dream was simple—“Build your own app without writing code.” And yes, you could whip up a form faster than it takes IT to say “governance policy.” But somewhere between the fifth nested formula in Power Fx and the third unexplained delegation warning, the dream cracked.Enter the schism: citizen devs versus professional devs. On one side, the drag-and-drop romantics who swear by speed and flexibility. On the other, the pro coders who look at Canvas App formulas and feel a deep, existential dread. One group lives for instant results; the other demands reusable components, source control, and environments that don’t break when someone renames a field.Now, Code Apps—or as I prefer, Vibe Code—bring that missing discipline back. They let you use Visual Studio Code, proper frameworks like React, and still live inside the Power Platform’s luxurious, compliance-approved walled garden. It’s not rebellion; it’s a truce between creativity and control.By the end of this, you’ll know exactly when Vibe Code wins, when Low-Code saves the day, and how GitHub Copilot glues the two worlds together faster than any junior dev could. We’re about to unpack the illusion of simplicity, the metrics of scale, and the AI that’s pulling the strings between both worlds. So forget everything you think you know about Power Apps—because “low-code for everyone” was never the real story. It was just the prologue.Section 1: The Low-Code IllusionLow-Code sold a convenient fantasy: anyone could be a developer. That sounds noble until you realize “anyone” includes Gary from accounting, who just built an app that performs twenty SQL queries every five seconds. The promise was empowerment. The result? Syntax chaos disguised behind pastel-colored buttons.Let’s demystify it. Power Apps comes in two main flavors: Canvas and Model-Driven. Canvas Apps are the design-your-own interface kind—freedom incarnate. You drag components onto a blank canvas, wire them up with Power Fx, and feel like Picasso with an API. Model-Driven Apps, however, are the rule-followers. They take your Dataverse tables and automatically generate UI like a disciplined robot. They’re structured, but rigid—perfect for data-heavy use cases, less so for anything that demands flair.Now, what both share is speed. You can prototype in hours, sometimes minutes. That’s the dopamine hit Microsoft built this empire on. Business units didn’t need IT approval anymore; they could “empower” themselves. But the hidden cost came later—maintenance nightmares that grew like invasive plants across the enterprise. Because Low-Code doesn’t mean low complexity. It just hides that complexity behind cheerful names and mouse clicks.Take Power Fx, for example. It looks harmless—a little Excel-inspired formula language for app logic. But under the hood, it creates sprawling dependency webs that only the original creator can untangle. Lose that person, and you lose the logic. Governance tools can help, sure, but most organizations end up with dozens of variations of the same “Task Tracker” app, all slightly broken in unique, fascinating ways.The analogy is inevitable: Low-Code is IKEA furniture. Assemble it fast, feel competent, and then realize you don’t know where that extra bolt came from. Heaven help you if you ever need to move it or upgrade it—because there’s always missing documentation and a mystery hex key involved.Departments hit the tipping point the moment they want serious integrations: SQL backends, Git repositories, automated pipelines. Canvas Apps weren’t designed for that depth. They shine for quick process tools—leave requests, status dashboards—but not full production-grade systems that must survive audits, scaling, and developer turnover. That’s when teams face the “rewrite moment,” where Low-Code’s convenience suddenly becomes its cost.So, Microsoft did something smart. Instead of pretending the problem didn’t exist, they equipped developers with a new way to take back structure without abandoning the platform’s benefits. And thus, Vibe Code entered the chat—a form of Power Apps that behaves like a modern web project but still enjoys all the comforts of enterprise governance, connectors, and authentication.What’s coming next flips the script entirely. Because where Low-Code abstracted complexity away, Code Apps embrace it—on your terms. This isn’t rebellion for its own sake. It
Mark as Played
Transcript
Episode Transcript
Available transcripts are automatically generated. Complete accuracy is not guaranteed.
Speaker 1 (00:00):
Most people think power apps is about dragging buttons onto
screens until something vaguely resembling an app appears. Click, drag, published,
done wrong. That's the fairy tale version Microsoft marketed to
empower everyone, and it worked too well, because now there's
a new species loose in the ecosystem, vibe code. That's
the evolution where power apps meet serious development equal parts JavaScript,
(00:21):
get discipline and AI assisted chaos. See. Power apps started
as a playground for business users citizen developers, armed with
enthusiasm and questionable naming conventions. The dream was simple, build
your own app without writing code, and yes, you could
whip up a form faster than it takes itty to
say governance policy. But somewhere between the fifth nested formula
(00:42):
in power effects and the third unexplained delegation warning, the
dream cracked. Enter the schism citizen devs versus professional depths
on one side, the drag and drop romantics who swear
by speed and flexibility. On the other, the pro coders
who look at canvas app formulas and feel a deep
existential dread. One group lives for instant results, the other
demands reusable components, source control, and environments that don't break
(01:03):
when someone renames the field now code apps, or as
I prefer, vibe code, bring that missing discipline back. They
let you use visual studio code, proper frameworks like React,
and still live inside the power platform's luxurious, compliance approved
walled garden. It's not rebellion. It's a truce between creativity
and control. By the end of this you'll know exactly
when vibe code wins, when low code saves the day,
(01:25):
and how GitHub Copilot glues the two worlds together faster
than any junior dev could. We're about to unpack the
illusion of simplicity, the metrics of scale, and the AI
that's pulling the strings between both worlds. So forget everything
you think you know about power apps, because low code
for everyone was never the real story. It was just
the prolog, the low code illusion. Low code sold a
(01:46):
convenient fantasy. Anyone could be a developer. That sounds noble
until you realize anyone includes Gary from Accounting, who just
built an app that performs twenty SQL queries every five seconds.
The promise was empowerment. The result syntax chaos disguised behind
power still colored buttons. Let's demystify it. Power apps comes
in two main flavors, canvas and model driven Canvas apps
are the design your own interface kind freedom incarnate. You
(02:09):
drag components onto a blank canvas, wire them up with
power effects, and feel like Picasso with an API. Model
driven apps, however, are the rule followers. They take your
data verse tables and automatically generate UI like a disciplined robot.
They're structured but rigid, perfect for data heavy use cases,
less so for anything that demands flare. Now, what both
share is speed. You can prototype in hours, sometimes minutes.
(02:31):
That's the dopamine hit. Microsoft built this empire on business
units didn't need it approval anymore. They could empower themselves.
But the hidden cost came later, maintenance nightmares that grew
like invasive plants across the enterprise. Because loco doesn't mean
low complexity, it just hides that complexity behind cheerful names
and mouse clicks. Take power effects, for example, it looks
harmless a little Excel inspired formula language for app logic,
(02:54):
but under the hood it creates sprawling dependency webs that
only the original creator can untangle. Loose their person and
you lose the logic. Governance tools can help sure but
most organizations end up with dozens of variations of the
same task tracker app, all slightly broken in unique fascinating ways.
The analogy is inevitable. Low code is ikea furniture. Assemble
(03:14):
it fast, feel competent, and then realize you don't know
where that extra bolt came from. Heaven help you if
you ever need to move it or upgrade it, because
there's always missing documentation and a mystery hex key. Involved
departments hit the tipping point, the moment they want serious integrations,
sequel back ends, GIT repositories, automated pipelines, canvas apps weren't
designed for that depth. They shine for quick process tools,
(03:35):
leave requests, status dashboards, but not full production grade systems
that must survive audits, scaling, and developer turnover. That's when
teams face the rewrite moment, where low codes convenience suddenly
becomes its cost. So Microsoft did something smart instead of
pretending the problem didn't exist, They equipped developers with a
new way to take back structure without abandoning the platform's benefits,
(03:56):
and thus Vibe Coode entered the chat, a form of
power apps that behaves like a modern web project but
still enjoys all the comforts of enterprise, governance, connectors, and authentication.
What's coming next flips the script entirely, because where low
code abstracted complexity away, code apps embrace it on your terms.
This isn't rebellion for its own sake. Its infrastructure therapy
delivered through syntax, enter vibecode, power apps, code apps. Now
(04:20):
we come to the grown up table. Vibcode or what
Microsoft humbly calls power apps. Code apps is what happens
when the power platform finally admits it's part of the
developer family. Again. Gone are the days of pastel interfaces
and formula boxes. This is React in a suit and tie,
hosted inside power apps. Think of it as a high
end condominium inside the same gated community, but this unit
(04:41):
has stainless steel, appliances and version control. Here's the simple version.
Code apps are full fledged React web applications that run
inside the power Platform. Yes, inside you write in your
favorite ID visual studio code using all the modern trimmings NODEJS, Typescript,
dot Net, and Git. The power platform gives you structure,
connectors and security. React gives you raw creative control. It's
(05:04):
the best of custom and controlled worlds the artistry of
a full stack dev inside Microsoft's carefully monitored walled garden.
Let's decode the workflow. It starts at the command line,
where developers feel most alive. You initialize a code app
using the power Platform Cli, a tool that connects your
local project directly to your power Platform environment. Then, with
a few commands like pack code in it, you bootstrap
(05:26):
a standard React project, configure your power config Jason, and
link it to your environment. This is the digital equivalent
of setting up residency. Your local machine meets the cloud
and shakes hands politely through authentication. From there, you bring
in connectors. Power app supports over one thousand, five hundred
of them, SharePoint, Esquill, Office three sixty five Service now, Azure,
(05:47):
and more. Add these directly into your app using the CLI,
and a new typescript service pops up like it was
always meant to be. There, no silly formula matching, no
nested conditional statements pretending to be logic. It's just code, predictable, readable, testable.
If low code was lego. You build from what you're given.
Then code apps is the three D printer that fabricates
your own bricks. You're not confined to prefab shapes. You're
(06:08):
sculpting your own UI logic and components. That's why pro
coders love this world. It's still the power platform, but
it respects their intelligence. Imagine this life cycle. Openvs code
type away, test locally on your machine with NPM, run
dev fix, test again, and when satisfied, push the app
to power apps with one command parks code push. Moments later,
your React app appears alongside standard canvas apps within your environment,
(06:32):
inherits all the environment's governance policies, and crucially authenticates automatically
using Microsoft Entra. You're still compliant with organizational rules, but
now you can finally write your own logic without fighting
abstraction layers. The real joy isn't just the technology, it's
the structure. Source control through GIT becomes standard, Collaboration through
pull requests becomes possible, CICD pipelines become trivial. Every software
(06:55):
engineer who's ever cried over a corrupted power effects formula
can now relax. Versioning isn't a dream, it's baseline reality.
And yet Microsoft knew this wasn't enough. Even though code
apps made real code first class citizens again, productivity was
still bottlenecked by the same thing that plagues every dev
shop repetition type, imports, connector calls, data mappings, all boiler plate. Powerful, yes,
(07:16):
but tedious, which is why the next piece of the
puzzle isn't another framework or SDK. It's something far more intoxicating,
artificial intelligence. Microsoft didn't just bring back structure, it brought
a sidekick. The next era of power apps development starts
with a line we never thought we'd say, GitHub copilot
build this for me. GitHub Copilot the Vibe partner. Now,
(07:37):
let's talk about the intern no one paid for, but
everyone relies on GitHub Copilot. You could call it auto
complete on caffeine, but that undertells what it's doing for
power apps developers. In this new Vibe code world, Copilot
isn't just a helper. It's a silent collaborator, one who
writes entire sections of code before your brains had time
to catch up. Let's establish boundaries. First. Copilot doesn't create strategy.
(07:57):
It composes syntax. You the devel define what needs to exist,
a dashboard, a form, a data poll from SharePoint. Copilot
handles the gruntwork, scaffolding components, writing JSX, fetching data, fixing
built errors, streamlining imports. It remembers your context across the session,
so by the time you say add a profile card
(08:18):
that shows username, email, and photo, it's already typing. You
watch React components assemble themselves in real time, and for
one brief second, you think maybe sky Neet deserves forgiveness.
This is the power amplification layer that transforms good developers
into fast ones. Suddenly code apps, development moves at startup Velocity.
Need to hook into data verse, type one comment and
Copilot spits out a full service interface wired to your connection.
(08:41):
Want to display a SharePoint list as a Kanban board,
Ask politely, and within seconds you've got dragable swim lanes
powered by modern React state management efficiency. That used to
take a sprint now takes a coffee. The analogy rights itself.
Copilot isn't your creative director. It's the intern who never
sleeps types one hundred and twenty words per minute and
doesn't complain about documentation. It fills in the blanks while
(09:03):
you guide the architecture, and when you test and iterate,
it learns patterns from your prompts, becoming eerily good at
predicting your next component or data model. It's not AI
replaces programmers. It's AI removes the typing part of programming, which,
let's face it is the boring part anyway. But before
you start deploying blindly, here's the serious note. Copilot accelerate syntax,
(09:23):
not semantics. It can write error free code that's conceptually
wrong if you're not watching. That's why discipline reviews, testing,
source control matters more than ever. Let Copilot generate you
validate that partnership, not automation, is the smart developers advantage.
When this dynamic plays out inside the Power platform, something
magical and pragmatic happens. Enterprises suddenly gain the speed of
(09:44):
citizen development with the integrity of professional code. Business users
get their features faster, it gets its governance, and developers
get out of the swamp of repetitive front and plumbing.
Everybody wins, including Microsoft's server utilization metrics. The net effect
power apps code apps power brought by Copilot feel less
like systems development and more like orchestrating intelligence. You describe intentions,
(10:06):
the machine translates them into running code, all within a
governed environment with secure authentication and managed connectors. So now
both worlds low code and vibe Code are in full motion,
one democratizing creation, the other formalizing scale. But which one
should drive your next project? That's the question professionals are
about to ask in every strategy meeting, because we've tasted
(10:27):
both speed and structure and we're not going back. The
next section decides the winner, vibe code versus Low code,
choosing your weapon. Here's where the philosophical turns practical. Low
code and vibe code aren't moral choices, they are strategic ones.
Both sound enticing. One gives anyone the illusion of instant productivity.
The other offers precise control and a feint whiff of superiority.
(10:48):
The truth you need to know when speed matters more
than architecture, and when governance speeds enthusiasm. Because whether you're
orchestrating a single workflow or a platform portfolio, your weapon
defines your outcome. Start with development work force. Low code
feels friendly because it's graphical. You drag configure and get
that satisfying spark when something actually works. No syntax error
is no failed bills, just a functioning form. But what
(11:09):
you gain in approachability you lose in reusability. Components can't
easily travel between apps. Refactoring means opening interfaces one by one.
Debugging feels like deciphering hieroglyphs. Vibe code, in contrast, trades
ease for power. You live in visual studio code. The
CLI is your home and GIT is your safety net.
You structure your code base, share modules between apps, and
(11:30):
automate everything from bill to deploy the qui. Devotees may
call it overkill. Engineers call it Tuesday. Governance is where
the gap widens into a canyon. Low code operates within
power platform environments, useful for departmental scalability, but bound by
whatever DLP and data boundary policies the admins install. Great
for insulation, not great for orchestration. Code apps, on the
(11:50):
other hand, sync directly with DevOps pipelines. You can enforce
pull request approvals, automated testing, linting, even semantic versioning. That's
not bureaucracy, it's survival. When multiple teams are shipping changes weekly,
governance becomes a feature, not a complaint. Performance follows the
same pattern in low code. Abstruction protects you, but also
handcuffs you. Every button press runs through layers of the
power effects interpreter, then into connector middleware. Then finally to
(12:14):
the data source. Efficient enough for most business use cases. Yes,
but if you need real time dashboards, dynamic rendering, or
high volume processing, those invisible layers turn into molasses. Code
apps shed the fat react handle state in the browser.
JavaScript calls connectors directly through SDK rendering is immediate. It's
like comparing a high level language lesson to a live
(12:34):
circuit demonstration. The latter sparks faster and you can actually
see the current Security isn't as divisive as people assume.
Both worlds live under Microsoft intra authentication. Both obey conditional
access encryption and tenant boundaries. The nuance is granularity. Low
code enforces security through configuration checkboxes, roll tables, and access
lists find for most tasks, limiting for anything. Nuanced code
(12:56):
apps bake insecurity logic right inside your code, roll validation
at run time, custom API calls with token handling dynamic
permission based UI. In other words, you can make the
app itself smart enough to know who's poking around. That
level of control matters when who clicked what could be
an audit question, not just a metric maintenance is the
quiet killer. Low code wins at inception. An app built
(13:18):
in hours, but eventually collapses under its own shortcuts. Connectors
get deprecated, controls change behavior, formulas break when data types evolve.
Each fix is manual because the code isn't really text
its configuration. Meanwhile, code apps live and die by git commits.
You can branch, merge, roll back, and recompile. When Microsoft
changes SDK versions, you update your packages and rebuild, not
(13:41):
rewire everything manually. Longevity favors code, not convenience. Then there's
team alignment. If your builders are business analysts who know
processes but hate syntax, low code is the natural arena.
They understand what needs doing and thrive in a system
that abstracts the details. But once you involve developers, those
who speak Jason fluently and scoff at drag and drop,
forcing them into canvas apps is like asking a surgeon
(14:02):
to operate with mittens. Give them the keyboard, the CLI,
and the repository and they'll deliver something maintainable rather than mystical.
Let's ground this in miniature reality checks. Suppose the HR
department wants a tool that automates employee onboarding right from
a SharePoint list, triggers emails, updates, data verse rows flax
it tasks. That's a perfect low code play, fast, functional,
(14:23):
self contained, low risk. Now picture a manufacturing division needing
a system that pulls data from SQL, external APIs and
IoT telemetry with customized charts and responsive dashboards. That's not
a canvas problem. That's a code app destiny. Low code
can imitate such complexity, but at the cost of maintainability.
Vibe code starts there naturally. Here's where it gets amusing.
Despite the power gap, low code isn't disappearing, it's mutating.
(14:47):
The future isn't a coup where developers overthrow citizen creators.
It's a coalition. Hybrid bills already exist, Canvas apps embedding
custom react components, code apps consuming connectors originally configured in
low code. Think of it as distributed intelligence. One side
prototypes ideas quickly, the other scales them properly. When both coexist,
the entire power platform transforms from tooling chaos to a
(15:08):
cohesive development ecosystem. And yes, there's irony. The platform built
to eliminate code now depends on it again, but elegantly,
with AI accelerating both sides. Vibecode doesn't declare war on
low code. It offers an exit from its limitations while
keeping the ease that made it popular in the first place.
Canvas empowers creativity, code ensures continuity. Together they form a
(15:29):
closed loop of innovation and governance, Microsoft's favorite love story.
When you start viewing power Platform this way, debates about
which one's better sound childish. A hammer isn't better than
a wrench. They're just different tools for different bolts. The
real skill is knowing when you need fine talk or
blunt impact. The best architects design systems that mix both
quick prototypes through low code, hardened modules through vibecode, or
(15:52):
wrapped by copilot's AI suggestions, humming like quiet machinery behind
the scenes. That's the equilibrium professionals are heading toward. Rapid
eye DA married to disciplined execution. The platform isn't bifurcating,
it's specializing. So before you pick sides, remember the weapon
doesn't make the warrior. It just makes their job faster, cleaner, and,
in the case of power apps, significantly more compliant. When
(16:14):
the strategic layer AI, governance and the future of Power Platform.
Here's the part most people miss. Microsoft isn't staging a
coding war, it's engineering a merger. The power Platform's future
isn't low code versus pro code. It's the unification of
both underneath a shared governance and AI driven architecture, a
single nervous system that connects every creative impulse to enterprise
(16:34):
grade control. Think of it less like two camps and
more like one ecosystem learning to self regulate. The strategic
layer is where this evolution becomes visible. At a technical level,
everything's converging around three pillars, Copilot, data verse, and governed extensibility.
Copilot Studio now writes connectors that previously required manual SDK calls,
code components, the tech that lets react or typescript controls
(16:56):
run inside canvas apps are dissolving the wall between citizen
and professional creation and data verse. The central data service,
once reserved for model driven purists, is now the ground
both camps stand on. It provides the schema, security, and
relationship logic that make all these disparate bits behave like
one organism. Picture the platform as a living body. The
citizen developers are its cells, rapidly generating new tissue, dashboards,
(17:19):
forms workflows. The developers are the neurons linking those cells together,
refining reflexes, ensuring the organism thinks before it moves. Governance
meanwhile acts as the immune system, preventing rogue cells from
spawning unapproved connectors or violating data policies. Add AI, and
suddenly that body starts predicting rather than merely reacting to
business needs. From a business perspective, this is gold. It
(17:42):
standardizes deployment pipelines so that every app, whether built by
marketing or engineering, travels through the same CICD arteries. It
centralizes monitoring, security and compliance while preserving creative autonomy. Citizen
devs get to experiment, it gets traceability, leadership gets measurable ROI.
Everyone's incentives aligned finally under one architecture. Instead of fighting
(18:04):
overtooling the air layer cements This true copilot doesn't favor
coders or citizens, it interprets both. To the business user,
it feels like natural language magic. Build me a project
tracker results in an instant canvas skeleton, data verse table,
and basic logic. To the developer, the same engine offers
code suggestions, connector templates, and function scaffolds that would otherwise
(18:25):
eat ours. It's two dialects, English and JavaScript, spoken through
one interpreter. That never sleeps. There's a term for what's
forming governed expressiveness. It's no longer about who can code.
It's about how efficiently each person can express intent and
how safely that intent is deployed. Microsoft's architecture quietly enforces
this balance through policies, environment segmentation, and now Copilot augmented
(18:47):
guidance baked directly into the ide. Its democratization without entropy,
the near future looks less like no code versus full code,
and more like a spectrum of expressiveness per citizen. Someone
building an Excel might graduate to power effects, a power
X user might evolve into writing typescript components, and a
pro dev might prototype new features in low code before
hardening them in React. It's a circular ladder that keeps
(19:09):
everyone contributing at their comfort level without breaking the ecosystem.
This is what vibe coding actually signals. It's not just
writing code with Flare. It's coding that feels like low code,
fast iterative, assisted by AI, but scales like pro code
environments sink to get pipelines, validate deployments. Copilot teaches best
practices invisibly. The experience smooths into one continuous motion between
(19:31):
thinking and building. In effect, power platform becomes a composable brain,
absorbing new patterns from every user, whether they drag components
or refactor functions. That's the strategic horizon and enterprise platform
behaving like collective intelligence. When you see it that way,
the vibe in vibe Coode stops sounding mystical. It's the
resonance between freedom and discipline, between human creativity and machine governance,
(19:54):
and when those vibrations align, the whole system hums the
real truth. Here's the truth stripped of c Logan power apps.
Vibe code isn't killing low code, It's correcting its excesses.
It's the gentle realization that unlimited citizen freedom without rules
turns into messes. Only pro devs can mop up. Vibe
code returns structure, visibility, and maintainability without dismantling the empowerment
(20:16):
that made low codes succeed in the first place. So
use low code for velocity, spin up prototypes, validate ideas,
prove concepts, then expand them using vibe Coode for longevity,
version components, real frameworks, automated deployment, and through it all,
let GitHub copilot unify both worlds. Your silent translator between
business logic and technical syntax. The moment you treat AI
(20:36):
as the bridge, not the replacement, you start developing at
the speed of thought and the discipline of engineering. The
power platform isn't splitting apart. It's evolving toward composable intelligence,
where every workflow app and connector plugs into a shared
mental model of the organization. That's the real transformation, not
faster forms, but smarter systems that learn from how you build.
(20:56):
If that vision saves you time or spares you another
governance post mortem, repay the favor, subscribe, tap follow, and
let the next deep dive arrive automatically, like a scheduled
power automated flow knowledge should update itself proceed
Most people think power apps is about dragging buttons onto
screens until something vaguely resembling an app appears. Click, drag, published,
done wrong. That's the fairy tale version Microsoft marketed to
empower everyone, and it worked too well, because now there's
a new species loose in the ecosystem, vibe code. That's
the evolution where power apps meet serious development equal parts JavaScript,
(00:21):
get discipline and AI assisted chaos. See. Power apps started
as a playground for business users citizen developers, armed with
enthusiasm and questionable naming conventions. The dream was simple, build
your own app without writing code, and yes, you could
whip up a form faster than it takes itty to
say governance policy. But somewhere between the fifth nested formula
(00:42):
in power effects and the third unexplained delegation warning, the
dream cracked. Enter the schism citizen devs versus professional depths
on one side, the drag and drop romantics who swear
by speed and flexibility. On the other, the pro coders
who look at canvas app formulas and feel a deep
existential dread. One group lives for instant results, the other
demands reusable components, source control, and environments that don't break
(01:03):
when someone renames the field now code apps, or as
I prefer, vibe code, bring that missing discipline back. They
let you use visual studio code, proper frameworks like React,
and still live inside the power platform's luxurious, compliance approved
walled garden. It's not rebellion. It's a truce between creativity
and control. By the end of this you'll know exactly
when vibe code wins, when low code saves the day,
(01:25):
and how GitHub Copilot glues the two worlds together faster
than any junior dev could. We're about to unpack the
illusion of simplicity, the metrics of scale, and the AI
that's pulling the strings between both worlds. So forget everything
you think you know about power apps, because low code
for everyone was never the real story. It was just
the prolog, the low code illusion. Low code sold a
(01:46):
convenient fantasy. Anyone could be a developer. That sounds noble
until you realize anyone includes Gary from Accounting, who just
built an app that performs twenty SQL queries every five seconds.
The promise was empowerment. The result syntax chaos disguised behind
power still colored buttons. Let's demystify it. Power apps comes
in two main flavors, canvas and model driven Canvas apps
are the design your own interface kind freedom incarnate. You
(02:09):
drag components onto a blank canvas, wire them up with
power effects, and feel like Picasso with an API. Model
driven apps, however, are the rule followers. They take your
data verse tables and automatically generate UI like a disciplined robot.
They're structured but rigid, perfect for data heavy use cases,
less so for anything that demands flare. Now, what both
share is speed. You can prototype in hours, sometimes minutes.
(02:31):
That's the dopamine hit. Microsoft built this empire on business
units didn't need it approval anymore. They could empower themselves.
But the hidden cost came later, maintenance nightmares that grew
like invasive plants across the enterprise. Because loco doesn't mean
low complexity, it just hides that complexity behind cheerful names
and mouse clicks. Take power effects, for example, it looks
harmless a little Excel inspired formula language for app logic,
(02:54):
but under the hood it creates sprawling dependency webs that
only the original creator can untangle. Loose their person and
you lose the logic. Governance tools can help sure but
most organizations end up with dozens of variations of the
same task tracker app, all slightly broken in unique fascinating ways.
The analogy is inevitable. Low code is ikea furniture. Assemble
(03:14):
it fast, feel competent, and then realize you don't know
where that extra bolt came from. Heaven help you if
you ever need to move it or upgrade it, because
there's always missing documentation and a mystery hex key. Involved
departments hit the tipping point, the moment they want serious integrations,
sequel back ends, GIT repositories, automated pipelines, canvas apps weren't
designed for that depth. They shine for quick process tools,
(03:35):
leave requests, status dashboards, but not full production grade systems
that must survive audits, scaling, and developer turnover. That's when
teams face the rewrite moment, where low codes convenience suddenly
becomes its cost. So Microsoft did something smart instead of
pretending the problem didn't exist, They equipped developers with a
new way to take back structure without abandoning the platform's benefits,
(03:56):
and thus Vibe Coode entered the chat, a form of
power apps that behaves like a modern web project but
still enjoys all the comforts of enterprise, governance, connectors, and authentication.
What's coming next flips the script entirely, because where low
code abstracted complexity away, code apps embrace it on your terms.
This isn't rebellion for its own sake. Its infrastructure therapy
delivered through syntax, enter vibecode, power apps, code apps. Now
(04:20):
we come to the grown up table. Vibcode or what
Microsoft humbly calls power apps. Code apps is what happens
when the power platform finally admits it's part of the
developer family. Again. Gone are the days of pastel interfaces
and formula boxes. This is React in a suit and tie,
hosted inside power apps. Think of it as a high
end condominium inside the same gated community, but this unit
(04:41):
has stainless steel, appliances and version control. Here's the simple version.
Code apps are full fledged React web applications that run
inside the power Platform. Yes, inside you write in your
favorite ID visual studio code using all the modern trimmings NODEJS, Typescript,
dot Net, and Git. The power platform gives you structure,
connectors and security. React gives you raw creative control. It's
(05:04):
the best of custom and controlled worlds the artistry of
a full stack dev inside Microsoft's carefully monitored walled garden.
Let's decode the workflow. It starts at the command line,
where developers feel most alive. You initialize a code app
using the power Platform Cli, a tool that connects your
local project directly to your power Platform environment. Then, with
a few commands like pack code in it, you bootstrap
(05:26):
a standard React project, configure your power config Jason, and
link it to your environment. This is the digital equivalent
of setting up residency. Your local machine meets the cloud
and shakes hands politely through authentication. From there, you bring
in connectors. Power app supports over one thousand, five hundred
of them, SharePoint, Esquill, Office three sixty five Service now, Azure,
(05:47):
and more. Add these directly into your app using the CLI,
and a new typescript service pops up like it was
always meant to be. There, no silly formula matching, no
nested conditional statements pretending to be logic. It's just code, predictable, readable, testable.
If low code was lego. You build from what you're given.
Then code apps is the three D printer that fabricates
your own bricks. You're not confined to prefab shapes. You're
(06:08):
sculpting your own UI logic and components. That's why pro
coders love this world. It's still the power platform, but
it respects their intelligence. Imagine this life cycle. Openvs code
type away, test locally on your machine with NPM, run
dev fix, test again, and when satisfied, push the app
to power apps with one command parks code push. Moments later,
your React app appears alongside standard canvas apps within your environment,
(06:32):
inherits all the environment's governance policies, and crucially authenticates automatically
using Microsoft Entra. You're still compliant with organizational rules, but
now you can finally write your own logic without fighting
abstraction layers. The real joy isn't just the technology, it's
the structure. Source control through GIT becomes standard, Collaboration through
pull requests becomes possible, CICD pipelines become trivial. Every software
(06:55):
engineer who's ever cried over a corrupted power effects formula
can now relax. Versioning isn't a dream, it's baseline reality.
And yet Microsoft knew this wasn't enough. Even though code
apps made real code first class citizens again, productivity was
still bottlenecked by the same thing that plagues every dev
shop repetition type, imports, connector calls, data mappings, all boiler plate. Powerful, yes,
(07:16):
but tedious, which is why the next piece of the
puzzle isn't another framework or SDK. It's something far more intoxicating,
artificial intelligence. Microsoft didn't just bring back structure, it brought
a sidekick. The next era of power apps development starts
with a line we never thought we'd say, GitHub copilot
build this for me. GitHub Copilot the Vibe partner. Now,
(07:37):
let's talk about the intern no one paid for, but
everyone relies on GitHub Copilot. You could call it auto
complete on caffeine, but that undertells what it's doing for
power apps developers. In this new Vibe code world, Copilot
isn't just a helper. It's a silent collaborator, one who
writes entire sections of code before your brains had time
to catch up. Let's establish boundaries. First. Copilot doesn't create strategy.
(07:57):
It composes syntax. You the devel define what needs to exist,
a dashboard, a form, a data poll from SharePoint. Copilot
handles the gruntwork, scaffolding components, writing JSX, fetching data, fixing
built errors, streamlining imports. It remembers your context across the session,
so by the time you say add a profile card
(08:18):
that shows username, email, and photo, it's already typing. You
watch React components assemble themselves in real time, and for
one brief second, you think maybe sky Neet deserves forgiveness.
This is the power amplification layer that transforms good developers
into fast ones. Suddenly code apps, development moves at startup Velocity.
Need to hook into data verse, type one comment and
Copilot spits out a full service interface wired to your connection.
(08:41):
Want to display a SharePoint list as a Kanban board,
Ask politely, and within seconds you've got dragable swim lanes
powered by modern React state management efficiency. That used to
take a sprint now takes a coffee. The analogy rights itself.
Copilot isn't your creative director. It's the intern who never
sleeps types one hundred and twenty words per minute and
doesn't complain about documentation. It fills in the blanks while
(09:03):
you guide the architecture, and when you test and iterate,
it learns patterns from your prompts, becoming eerily good at
predicting your next component or data model. It's not AI
replaces programmers. It's AI removes the typing part of programming, which,
let's face it is the boring part anyway. But before
you start deploying blindly, here's the serious note. Copilot accelerate syntax,
(09:23):
not semantics. It can write error free code that's conceptually
wrong if you're not watching. That's why discipline reviews, testing,
source control matters more than ever. Let Copilot generate you
validate that partnership, not automation, is the smart developers advantage.
When this dynamic plays out inside the Power platform, something
magical and pragmatic happens. Enterprises suddenly gain the speed of
(09:44):
citizen development with the integrity of professional code. Business users
get their features faster, it gets its governance, and developers
get out of the swamp of repetitive front and plumbing.
Everybody wins, including Microsoft's server utilization metrics. The net effect
power apps code apps power brought by Copilot feel less
like systems development and more like orchestrating intelligence. You describe intentions,
(10:06):
the machine translates them into running code, all within a
governed environment with secure authentication and managed connectors. So now
both worlds low code and vibe Code are in full motion,
one democratizing creation, the other formalizing scale. But which one
should drive your next project? That's the question professionals are
about to ask in every strategy meeting, because we've tasted
(10:27):
both speed and structure and we're not going back. The
next section decides the winner, vibe code versus Low code,
choosing your weapon. Here's where the philosophical turns practical. Low
code and vibe code aren't moral choices, they are strategic ones.
Both sound enticing. One gives anyone the illusion of instant productivity.
The other offers precise control and a feint whiff of superiority.
(10:48):
The truth you need to know when speed matters more
than architecture, and when governance speeds enthusiasm. Because whether you're
orchestrating a single workflow or a platform portfolio, your weapon
defines your outcome. Start with development work force. Low code
feels friendly because it's graphical. You drag configure and get
that satisfying spark when something actually works. No syntax error
is no failed bills, just a functioning form. But what
(11:09):
you gain in approachability you lose in reusability. Components can't
easily travel between apps. Refactoring means opening interfaces one by one.
Debugging feels like deciphering hieroglyphs. Vibe code, in contrast, trades
ease for power. You live in visual studio code. The
CLI is your home and GIT is your safety net.
You structure your code base, share modules between apps, and
(11:30):
automate everything from bill to deploy the qui. Devotees may
call it overkill. Engineers call it Tuesday. Governance is where
the gap widens into a canyon. Low code operates within
power platform environments, useful for departmental scalability, but bound by
whatever DLP and data boundary policies the admins install. Great
for insulation, not great for orchestration. Code apps, on the
(11:50):
other hand, sync directly with DevOps pipelines. You can enforce
pull request approvals, automated testing, linting, even semantic versioning. That's
not bureaucracy, it's survival. When multiple teams are shipping changes weekly,
governance becomes a feature, not a complaint. Performance follows the
same pattern in low code. Abstruction protects you, but also
handcuffs you. Every button press runs through layers of the
power effects interpreter, then into connector middleware. Then finally to
(12:14):
the data source. Efficient enough for most business use cases. Yes,
but if you need real time dashboards, dynamic rendering, or
high volume processing, those invisible layers turn into molasses. Code
apps shed the fat react handle state in the browser.
JavaScript calls connectors directly through SDK rendering is immediate. It's
like comparing a high level language lesson to a live
(12:34):
circuit demonstration. The latter sparks faster and you can actually
see the current Security isn't as divisive as people assume.
Both worlds live under Microsoft intra authentication. Both obey conditional
access encryption and tenant boundaries. The nuance is granularity. Low
code enforces security through configuration checkboxes, roll tables, and access
lists find for most tasks, limiting for anything. Nuanced code
(12:56):
apps bake insecurity logic right inside your code, roll validation
at run time, custom API calls with token handling dynamic
permission based UI. In other words, you can make the
app itself smart enough to know who's poking around. That
level of control matters when who clicked what could be
an audit question, not just a metric maintenance is the
quiet killer. Low code wins at inception. An app built
(13:18):
in hours, but eventually collapses under its own shortcuts. Connectors
get deprecated, controls change behavior, formulas break when data types evolve.
Each fix is manual because the code isn't really text
its configuration. Meanwhile, code apps live and die by git commits.
You can branch, merge, roll back, and recompile. When Microsoft
changes SDK versions, you update your packages and rebuild, not
(13:41):
rewire everything manually. Longevity favors code, not convenience. Then there's
team alignment. If your builders are business analysts who know
processes but hate syntax, low code is the natural arena.
They understand what needs doing and thrive in a system
that abstracts the details. But once you involve developers, those
who speak Jason fluently and scoff at drag and drop,
forcing them into canvas apps is like asking a surgeon
(14:02):
to operate with mittens. Give them the keyboard, the CLI,
and the repository and they'll deliver something maintainable rather than mystical.
Let's ground this in miniature reality checks. Suppose the HR
department wants a tool that automates employee onboarding right from
a SharePoint list, triggers emails, updates, data verse rows flax
it tasks. That's a perfect low code play, fast, functional,
(14:23):
self contained, low risk. Now picture a manufacturing division needing
a system that pulls data from SQL, external APIs and
IoT telemetry with customized charts and responsive dashboards. That's not
a canvas problem. That's a code app destiny. Low code
can imitate such complexity, but at the cost of maintainability.
Vibe code starts there naturally. Here's where it gets amusing.
Despite the power gap, low code isn't disappearing, it's mutating.
(14:47):
The future isn't a coup where developers overthrow citizen creators.
It's a coalition. Hybrid bills already exist, Canvas apps embedding
custom react components, code apps consuming connectors originally configured in
low code. Think of it as distributed intelligence. One side
prototypes ideas quickly, the other scales them properly. When both coexist,
the entire power platform transforms from tooling chaos to a
(15:08):
cohesive development ecosystem. And yes, there's irony. The platform built
to eliminate code now depends on it again, but elegantly,
with AI accelerating both sides. Vibecode doesn't declare war on
low code. It offers an exit from its limitations while
keeping the ease that made it popular in the first place.
Canvas empowers creativity, code ensures continuity. Together they form a
(15:29):
closed loop of innovation and governance, Microsoft's favorite love story.
When you start viewing power Platform this way, debates about
which one's better sound childish. A hammer isn't better than
a wrench. They're just different tools for different bolts. The
real skill is knowing when you need fine talk or
blunt impact. The best architects design systems that mix both
quick prototypes through low code, hardened modules through vibecode, or
(15:52):
wrapped by copilot's AI suggestions, humming like quiet machinery behind
the scenes. That's the equilibrium professionals are heading toward. Rapid
eye DA married to disciplined execution. The platform isn't bifurcating,
it's specializing. So before you pick sides, remember the weapon
doesn't make the warrior. It just makes their job faster, cleaner, and,
in the case of power apps, significantly more compliant. When
(16:14):
the strategic layer AI, governance and the future of Power Platform.
Here's the part most people miss. Microsoft isn't staging a
coding war, it's engineering a merger. The power Platform's future
isn't low code versus pro code. It's the unification of
both underneath a shared governance and AI driven architecture, a
single nervous system that connects every creative impulse to enterprise
(16:34):
grade control. Think of it less like two camps and
more like one ecosystem learning to self regulate. The strategic
layer is where this evolution becomes visible. At a technical level,
everything's converging around three pillars, Copilot, data verse, and governed extensibility.
Copilot Studio now writes connectors that previously required manual SDK calls,
code components, the tech that lets react or typescript controls
(16:56):
run inside canvas apps are dissolving the wall between citizen
and professional creation and data verse. The central data service,
once reserved for model driven purists, is now the ground
both camps stand on. It provides the schema, security, and
relationship logic that make all these disparate bits behave like
one organism. Picture the platform as a living body. The
citizen developers are its cells, rapidly generating new tissue, dashboards,
(17:19):
forms workflows. The developers are the neurons linking those cells together,
refining reflexes, ensuring the organism thinks before it moves. Governance
meanwhile acts as the immune system, preventing rogue cells from
spawning unapproved connectors or violating data policies. Add AI, and
suddenly that body starts predicting rather than merely reacting to
business needs. From a business perspective, this is gold. It
(17:42):
standardizes deployment pipelines so that every app, whether built by
marketing or engineering, travels through the same CICD arteries. It
centralizes monitoring, security and compliance while preserving creative autonomy. Citizen
devs get to experiment, it gets traceability, leadership gets measurable ROI.
Everyone's incentives aligned finally under one architecture. Instead of fighting
(18:04):
overtooling the air layer cements This true copilot doesn't favor
coders or citizens, it interprets both. To the business user,
it feels like natural language magic. Build me a project
tracker results in an instant canvas skeleton, data verse table,
and basic logic. To the developer, the same engine offers
code suggestions, connector templates, and function scaffolds that would otherwise
(18:25):
eat ours. It's two dialects, English and JavaScript, spoken through
one interpreter. That never sleeps. There's a term for what's
forming governed expressiveness. It's no longer about who can code.
It's about how efficiently each person can express intent and
how safely that intent is deployed. Microsoft's architecture quietly enforces
this balance through policies, environment segmentation, and now Copilot augmented
(18:47):
guidance baked directly into the ide. Its democratization without entropy,
the near future looks less like no code versus full code,
and more like a spectrum of expressiveness per citizen. Someone
building an Excel might graduate to power effects, a power
X user might evolve into writing typescript components, and a
pro dev might prototype new features in low code before
hardening them in React. It's a circular ladder that keeps
(19:09):
everyone contributing at their comfort level without breaking the ecosystem.
This is what vibe coding actually signals. It's not just
writing code with Flare. It's coding that feels like low code,
fast iterative, assisted by AI, but scales like pro code
environments sink to get pipelines, validate deployments. Copilot teaches best
practices invisibly. The experience smooths into one continuous motion between
(19:31):
thinking and building. In effect, power platform becomes a composable brain,
absorbing new patterns from every user, whether they drag components
or refactor functions. That's the strategic horizon and enterprise platform
behaving like collective intelligence. When you see it that way,
the vibe in vibe Coode stops sounding mystical. It's the
resonance between freedom and discipline, between human creativity and machine governance,
(19:54):
and when those vibrations align, the whole system hums the
real truth. Here's the truth stripped of c Logan power apps.
Vibe code isn't killing low code, It's correcting its excesses.
It's the gentle realization that unlimited citizen freedom without rules
turns into messes. Only pro devs can mop up. Vibe
code returns structure, visibility, and maintainability without dismantling the empowerment
(20:16):
that made low codes succeed in the first place. So
use low code for velocity, spin up prototypes, validate ideas,
prove concepts, then expand them using vibe Coode for longevity,
version components, real frameworks, automated deployment, and through it all,
let GitHub copilot unify both worlds. Your silent translator between
business logic and technical syntax. The moment you treat AI
(20:36):
as the bridge, not the replacement, you start developing at
the speed of thought and the discipline of engineering. The
power platform isn't splitting apart. It's evolving toward composable intelligence,
where every workflow app and connector plugs into a shared
mental model of the organization. That's the real transformation, not
faster forms, but smarter systems that learn from how you build.
(20:56):
If that vision saves you time or spares you another
governance post mortem, repay the favor, subscribe, tap follow, and
let the next deep dive arrive automatically, like a scheduled
power automated flow knowledge should update itself proceed
Popular Podcasts
Las Culturistas with Matt Rogers and Bowen Yang
Ding dong! Join your culture consultants, Matt Rogers and Bowen Yang, on an unforgettable journey into the beating heart of CULTURE. Alongside sizzling special guests, they GET INTO the hottest pop-culture moments of the day and the formative cultural experiences that turned them into Culturistas. Produced by the Big Money Players Network and iHeartRadio.
The Joe Rogan Experience
The official podcast of comedian Joe Rogan.
Stuff You Should Know
If you've ever wanted to know about champagne, satanism, the Stonewall Uprising, chaos theory, LSD, El Nino, true crime and Rosa Parks, then look no further. Josh and Chuck have you covered.