Hello everyone and welcome to another episode of Microsoft Knowledge Nuggets.
Today's topic is Dataverse and it sounds like a made up buzzword at first.
Most people hear it and think it's just a fancy name for a database,
but it's actually the hidden engine behind most business apps built on Microsoft's power platform.
And here's the thing, it's not just a database, it's something much more practical.
By the end of this episode, you'll understand what Dataverse actually is,
how it organizes data, and why it's the backbone of every power platform solution worth building.
There's one thing Dataverse does that most people don't expect,
and it changes how you think about building apps entirely.
Grab your coffee and let's dive in.
Why Dataverse exists?
Imagine you start a new company tomorrow.
20 years ago, you'd buy separate products for everything,
one server for email, another for file storage,
a different system for customer data.
Each one had its own login, its own rules, its own way of doing things,
and getting them to talk to each other was a full-time job.
Fast forward to today, and the problem hasn't really gone away.
Businesses still use disconnected spreadsheets,
sharepoint lists, and random databases that don't talk to each other.
You've got customer data in one place,
order data in another, and inventory data in a third,
and someone's probably still tracking something important
in a dusty Excel file that only one person knows how to find.
Now, Excel works fine for small teams.
You can track a few dozen assets, a handful of customers,
maybe a simple project list, but it breaks its scale.
There's no real security, so anyone with the file can see everything.
There's no relationships between data,
so you're copying and pasting the same customer name across multiple sheets.
And there's no audit trail, so if someone changes a number,
you'll never know who did it or when.
Sharepoint lists are a step up.
They live in the cloud, support multiple users,
and are included with Microsoft 365.
But they hit a hard wall.
There's a 5,000 item view threshold,
so try to show more than 5,000 items in a list view,
and SharePoint just says no.
And there's no real relational data.
You can create look-up columns, but they're not enforced,
so you can link to a record that doesn't exist
or delete a manufacturer and leave often products floating around.
It's a mess.
So Microsoft looked at all this fragmentation and thought,
"What if there was one unified data platform
where all your power platform apps talked to the same data?
What if you didn't need to worry about security,
relationships, and logic in every single app?
What if the platform handled that for you?"
That's Dataverse, and here's the key point.
It's not just storage.
It's a managed service that handles security,
logic, and relationships, so you don't have to.
You define your data model once,
and every app, every flow, every report,
uses the same foundation.
No more copying data between systems, no more inconsistent records,
no more building the same security logic five times.
Tables, the foundation.
So what exactly is a Dataverse table
and how is it different from an Excel sheet or a SharePoint list?
Let's start with the simplest definition.
A table is the most basic building block in Dataverse.
Think of it like a spreadsheet tab, but smarter.
Each table has columns with specific data types,
text, numbers, dates, choices, currencies.
You define what kind of data goes in each column,
and Dataverse makes sure only valid data gets stored.
No more typing NA in a date field because someone didn't know what to put there.
But here's where Dataverse pulls ahead of Excel.
You get tools that spreadsheets simply don't have.
Auto numbering.
Every new record gets a unique ID automatically.
Calculated columns, a field that computes its value based on other fields
like total price, it was quantity times unit price,
business rules, logic that runs on the server,
not in a macro that someone might accidentally disable.
And you don't start from scratch.
Dataverse gives you standard tables out of the box.
Contacts, accounts, activities, these are ready to use,
already designed with the columns and relationships
that make sense for common business scenarios.
You can create custom tables for your own needs,
products, assets, orders, whatever your business requires.
Here's something most people don't realize.
When you create a table in Dataverse,
a lot happens behind the scenes without you lifting a finger.
Dataverse automatically adds a primary key,
a unique identifier for every record.
It adds created and modified dates.
It adds ownership fields who created this record,
who owns it now.
It adds a status field, active or inactive,
so you can soft delete records instead of permanently removing them.
All of that is there from the moment you create the table.
Let me give you a real world example.
Say you're building an asset tracking system.
You create a table called assets.
You add columns for the asset name, serial number,
purchase date and current value.
That's four columns you define.
But behind the scenes, Dataverse adds another dozen,
the unique ID, the created date, the modified date,
the owner, the status and so on.
You get all of that for free.
And when you start building apps on top of this table,
those extra fields are already there,
ready to use for security, auditing and reporting.
One to many relationships.
Once you have a few tables,
the real power comes from connecting them together.
And the most common way to do that is with a one to many relationship.
Here's how it works.
One record in one table links to many records in another table.
Let me give you a concrete example.
Say you have a table for vehicle manufacturers.
Honda Ford Toyota.
And you have another table for vehicles.
Civic F-150 Camry.
One manufacturer makes many vehicles.
That's a one to many relationship.
The way you build this in practice is with something called a lookup column.
On your vehicle table, you add a column called manufacturer.
And you set it to lookup values from your manufacturer table.
When a user fills in that field,
they don't type the manufacturer name from scratch.
They search for it.
Dataverse shows a search box,
not a drop down of thousands of options.
They pick Honda and the relationship is created.
Now, why does this matter?
Because instead of repeating the manufacturer name
in every single vehicle row,
you store it once and reference it.
The Civic points to the Honda record.
The accord points to the same Honda record.
The CRV points to the same Honda record.
You're not typing Honda three times.
You're storing it once.
And every vehicle just links back to it.
This prevents data entry errors.
No more typos.
Honda in one row, Honda motor in another, Honda cumped in a third.
It's all the same record.
And it makes updates incredibly easy.
Say Honda decides to rebrand and change their company name.
In a spreadsheet, you'd have to find every single row that says Honda
and update it.
Miss one and now you've got inconsistent data.
In Dataverse, you change the manufacturer name once
and every vehicle that links to that manufacturer
automatically reflects the update.
One change, everything updates.
Dataverse also enforces something
called referential integrity.
You can't link to a manufacturer record
that doesn't exist.
If someone tries to delete a manufacturer
that still has vehicles linked to it,
Dataverse will stop them.
No often records, no broken references.
The data stays clean.
And here's where it gets visual.
On the manufacturer form,
you can add something called a subgrid.
This is a small table embedded in the form
that shows all the vehicles belonging to that manufacturer.
So when you open the Honda record,
you see a list, Civic, Accord, CRV,
right there on the same screen.
You can see the relationship from both sides.
The vehicle knows which manufacturer it belongs to.
And the manufacturer knows which vehicles are linked to it.
That's the power of a one-to-many relationship.
Many-to-many relationships.
Now, what about when you need a more flexible connection?
Where many records linked to many other records,
sometimes one-to-many isn't enough?
Take a car dealership.
A single customer might own multiple vehicles.
That's easy.
One customer, many vehicles.
But what about a household?
A single vehicle might be owned by multiple people.
A husband and wife, for example.
So you've got a situation where one customer can own many vehicles
and one vehicle can be owned by many customers.
That's a many-to-many relationship.
Dataverse supports this natively.
You don't need to create an extra table.
You just define a many-to-many relationship
between your contact table and your vehicle table
and Dataverse handles the rest.
Behind the scenes, it creates a hidden table
that stores the connections.
But you never see it.
You just see that a contact can have multiple vehicles
and a vehicle can have multiple contacts.
But here's the catch.
That out-of-box many-to-many table is invisible.
You can't see it in your list of tables.
You can't add columns to it.
You can't store extra data on it.
So if you want to track the purchase price of that vehicle
or the data was bought or the financing terms,
you can't.
The hidden table only stores the relationship itself.
Nothing else.
If you need to track additional information,
you create a custom intersection table.
Let's say you create a table called "Purchase".
This table has a lookup to the contact who bought it.
A lookup to the vehicle.
What they bought.
And then you can add whatever columns you need.
Purchase price, purchase date,
warranty expiration, payment status.
This gives you full control.
You can add columns.
Trigger power automate flows when a purchase is created.
Import data from Excel.
Everything you'd expect from a proper table.
So when do you use which?
The out-of-box many-to-many is great for simple associations.
Tags on a blog post, categories on a product,
quick lightweight connections
where you just need to know what's linked to what.
The custom intersection table is for business transactions.
Things that have their own data, their own process, their own life cycle.
Think of it this way.
The out-of-box version is like a sticky note.
Quick, easy, gets the job done.
But you can't write much on it.
The custom version is a proper filing cabinet with folders.
Takes a bit more setup,
but you can store everything you need.
Security and access.
Storing and connecting data is only half the story.
The other half is making sure the right people see the right data.
And this is where dataverse really separates itself
from a simple spreadsheet or list.
Dataverse uses role-based security.
You don't assign permissions to individual users one at a time.
You create roles.
Think of them as job descriptions.
And you assign permissions to those roles.
Then you add users to the roles.
A salesperson gets the sales role.
A support agent gets the support role.
A manager gets a role with broader access.
Clean, scalable, and easy to audit.
Now there are three levels of control.
First, table level.
Can this person even see the asset table?
Second, record level?
Which specific rows can they see?
And third, column level can they see every field in a record
or are some fields hidden?
Let's break that down.
Table level is straightforward.
You decide which tables a role can access.
Maybe your support team doesn't need to see the financial tables at all.
Done.
Record level is where it gets interesting.
You control this through something called access levels.
The most common ones are user.
You can only see records you own.
Business unit, you can see records owned by anyone in your department.
And organization, you can see everything in the environment.
Here's something important to understand.
Security and dataverse is additive, not subtractive.
If a user has two roles, they get the most permissive access from either role.
You can't give someone a role that says read only.
And then another role that says, can't see this table
and expect the second one to override the first.
It doesn't work that way.
The system always gives the highest level of access.
So you need to be intentional about which roles you assign to which users.
Business units create natural boundaries.
You set up a business unit for sales,
another for support, another for finance.
Users in the sales unit see sales data.
Users in the support unit see support data.
It creates a clean separation without needing complex role configurations.
And it scales.
Add a new salesperson to the sales business unit
and they automatically inherit the right access.
The golden rule of dataverse security is this,
don't assign system administrator to everyone.
That role gives full access to everything in the environment.
It's tempting to use it as a shortcut when someone says,
I can't see this data.
Don't do it.
Instead, clone a base role, trim it down to only what that person needs
and assign that.
It takes a few extra minutes,
but it saves you from security headaches down the road.
Teams make permission management even easier.
Instead of assigning roles to 20 individual users,
you create a team, assign the role to the team,
and add users to the team.
When someone joins the team, they inherit the team's access.
When someone leaves, you remove them from the team.
No need to update individual role assignments.
It scales beautifully.
Dataverse versus SharePoint.
So after all that, you might still be wondering,
should I use Dataverse or can I just stick with SharePoint?
That's a fair question.
Let's compare them directly.
Here's the biggest difference.
SharePoint is a collaboration platform that happens to have lists.
Dataverse is a proper relational database,
built from the ground up for business apps.
SharePoint lists work great for team sites,
document libraries, and simple trackers,
but they're not designed to be the backbone of a real application.
Dataverse is, now let's talk cost.
SharePoint lists come with your Microsoft 365 subscription.
You already have them.
No extra license needed.
Dataverse requires a power app's premium license,
which runs about $20 per user per month.
That's real money, and it matters.
But you get what you pay for.
Scale is another big difference.
SharePoint has a hard limit.
The 5,000 item view threshold.
If your list goes over that, certain operations just fail.
You can work around it with indexing and careful filtering,
but it's a constant headache.
Dataverse can handle millions of rows with proper queries.
No arbitrary view threshold.
No workarounds needed.
Relationships are where things really split.
SharePoint has look-up columns, but they're not enforced.
You can create a look-up to a record that doesn't exist.
You can delete a record that other records point to,
leaving orphaned references everywhere.
Dataverse enforces referential integrity.
You can't create a broken link.
The data stays clean.
And column-level security?
SharePoint doesn't have it.
You can't hide a salary field while showing the rest of an employee record.
It's all or nothing.
Dataverse lets you secure individual columns.
The HR manager sees the full record.
The team leads sees everything except the salary.
That's not possible with SharePoint alone.
So when do you use each one?
Use SharePoint for simple trackers,
document libraries, team-level collaboration,
and low-budget solutions.
It's fast, it's familiar, and it's already paid for.
Use Dataverse for business-critical data,
complex relationships, enterprise security,
model-driven apps, and anything that needs AI integration.
It's the right foundation when your app needs to grow.
And here's a common pattern that works really well.
A hybrid approach.
Use Dataverse for your structured data,
customers, orders, products,
the things that need relationships and security.
Use SharePoint for documents.
Contracts reports attachments.
Dataverse links to the SharePoint document,
so you get the best of both worlds.
Structured data in a proper database.
Documents in a collaboration platform designed for them.
Power Platform integration.
So Dataverse handles the data layer.
But how does it fit into the bigger power platform picture?
This is where everything comes together.
Dataverse is the shared data layer
that power apps, power automate, and power BI all use.
Think of it as the foundation every other tool builds on top of.
Power Apps connects to it for app data.
Power Automate uses it for triggers and actions.
Power BI queries it for dashboards.
One Data Platform, three different tools,
all working with the same information.
Let's start with Canvas Apps.
You can connect the Canvas app to Dataverse
just like you'd connected to any other data source.
SharePoint, SQL, Excel.
But here's the difference.
When you connect to Dataverse, you get full delegation.
That means your app can query millions of records
without slowing down.
The query runs on the server, not on the user's device.
And you inherit Dataverse's security model automatically.
You don't have to build security logic into the app itself.
The platform handles it.
Model-driven apps are a different story.
These apps are built directly on Dataverse.
They're not possible without it.
When you create a model-driven app,
you're essentially building a user interface
on top of your Dataverse tables.
The forms, the views, the dashboards,
they all come from the Data model you've already defined,
no separate Data Source configuration,
no custom connection strings.
The app and the data are one and the same.
Power Automate can trigger on Dataverse events.
When a record is created, updated, or deleted,
you can kick off a flow automatically.
Send an email notification.
Update a related record, start an approval process.
All triggered by changes in the data itself.
This is where the real automation happens,
not in scheduled batch jobs,
but in real-time responses to business events.
Power BI can query Dataverse tables directly.
You don't need to export Data,
build a separate Data Warehouse,
or set up complex ETL processes.
You point Power BI at your Dataverse environment,
pick the tables you want, and build your dashboards.
The data is live.
When someone updates a record in Power Apps,
the dashboard reflects that change in real-time.
No stale reports, no manual refreshes.
This creates a continuous loop.
You analyze Data in Power BI and spotted trend.
Maybe a spike in support tickets for a specific product.
You act on it in Power Apps.
Create a case, assign it to a team.
You automate the follow-up with Power Automate.
Send a notification, update the status.
All of it runs on the same data.
One platform, one source of truth, end-to-end.
Now here's where things get interesting for the future.
Co-pilot and AI agents use Dataverse as their memory.
When you ask an AI assistant a question about your business data,
it's not searching the internet.
It's querying your Dataverse tables.
Your customer records, your order history, your inventory levels,
that's what feeds the AI.
Not random web content, your actual business data.
And it's secured by the same role-based security we talked about earlier.
The AI can only see what the user has permission to see.
Looking further ahead,
fabric integration means you'll be able to analyze Dataverse data
in one lake without copying it.
No more moving data around.
No more duplicate storage.
Your operational data and your analytical data live in the same place.
That's the direction Microsoft is heading.
Getting started.
So after all that, you might be wondering
where to actually start.
Let's make it simple.
Start with one question.
Do you need a system of record or just a lightweight tracker?
A system of record holds your core business data.
Customers, orders, products, cases.
It needs to be secure, reliable, and connected to other systems.
A lightweight tracker is more like a project list,
a task board or a simple inventory sheet.
Useful, but it doesn't need enterprise-grade infrastructure.
If you're building a real business app
with multiple related tables, security layers, and automation,
Dataverse is the right foundation.
You'll thank yourself later when you need to add a new table,
change a relationship, or integrate with another system.
If you're just tracking a few items for your team,
SharePoint is probably fine.
Use the right tool for the job.
The easiest way to start is to go to make.
PowerApps.com, create a solution, and add your tables.
Don't worry about building an app yet.
Just define your data model.
What tables do you need?
What columns go in each table?
What relationships connect them?
Get that right first, and everything else becomes easier.
Use the standard tables before creating custom ones.
Dataverse comes with tables for contacts,
accounts, activities, and more.
They're already designed for common business scenarios.
The contact table has fields for name, email, phone, address, company,
everything you'd expect.
Before you create a custom/customer table,
ask yourself if the standard account or contact table will work.
It probably will.
And it saves you from reinventing the wheel.
Plan your data model on paper before you start building.
Draw the tables, draw the relationships,
figure out who needs to see what.
A few hours of planning can save you weeks of rework.
And here's a common mistake.
Overcomplicating the model upfront.
Start simple.
Add complexity as you need it.
You don't need 15 tables and 20 relationships on day one.
Start with the core tables.
Get them working.
Add more as your requirements grow.
And here's the beauty of dataverse.
You can change the data model later without breaking your apps.
Add a new column.
Create a new relationship.
Change a data type.
The apps adapt.
Try doing that with a spreadsheet.
You change a column in Excel.
And every formula, every pivot table,
every chart that references it breaks.
Not in dataverse.
The platform handles the changes gracefully.
That alone is worth the switch.
So here's what we covered.
Dataverse is a managed relational data platform
that gives power platform apps a shared, secure,
and scalable foundation.
It's not just a database.
It's a unified layer that handles tables,
relationships, security, and logic.
You don't have to build those things from scratch every time.
The main idea is this.
Think of dataverse as the office building.
Not just a single room.
The office building provides the structure,
the security, the plumbing, the electricity.
You just furnish the rooms.
That's what dataverse does for your apps.
It provides the infrastructure.
You build the solutions.
If you want to see dataverse in action,
check out the video on building your first model driven app.
It walks through the whole process from start to finish.
And subscribe on your favorite podcast platform.
Share this episode with someone who's still using Excel
for everything.
They might thank you later.