Copilot Business Data: Sync or Query Live?

Microsoft Copilot can work with your business data either by syncing it into a dedicated index or by querying the live data source at the moment you ask. The right choice depends on your need for freshness, the size of your dataset, and your governance requirements. This article explains both approaches, their trade-offs, and how to decide which fits your scenario.

Background: How Copilot Accesses Your Data

Microsoft 365 Copilot uses the Microsoft Graph to connect to your tenant’s data—emails, documents, chats, calendar, and more. For files stored in SharePoint or OneDrive, Copilot can search and summarize them using the same permissions you already have. However, for data in external systems (like a SQL database, a CRM, or a custom app), Copilot needs a way to reach it. That’s where the sync-versus-live decision comes in.

Microsoft offers two main paths for this:

• Graph connectors (formerly Microsoft Search connectors) that index external content into the Microsoft Graph. This is a sync approach.
• Plugins and actions that call an external API at query time. This is a live approach.

Each has distinct characteristics, and Microsoft’s documentation often recommends a hybrid strategy, but understanding the core difference is essential for architects and administrators.

How Sync (Graph Connectors) Works

With Graph connectors, you configure a connection to an external data source (e.g., ServiceNow, Jira, a file share, or a custom database). The connector periodically crawls that source and pushes the content into a dedicated index within the Microsoft Graph. Copilot then searches this index when you ask a question.

Key features of the sync approach:

• Content is copied—the original source remains authoritative, but a copy lives in the Microsoft 365 index.
• Permissions are mapped—you can map ACLs from the source to Microsoft Entra IDs, so users only see results they’re allowed to see.
• Refresh schedules—you control how often the index updates, from minutes to daily.
• Search quality—the index is optimized for semantic search, so Copilot can find relevant content even if the query doesn’t match exact keywords.

This is ideal for content that doesn’t change frequently, like policies, product documentation, or historical records. It also offloads the query load from your source system, since Copilot only hits the index, not the original database.

How Live Query (Plugins) Works

Plugins, on the other hand, let Copilot call an external API in real time. When a user asks a question, Copilot sends a request to your API, which queries the live database or service, and returns the result.

Characteristics of the live approach:

• Always current—you see the latest data, which is critical for dashboards, inventory, or any time-sensitive information.
• No copy—data never leaves your source, which can simplify compliance and reduce storage duplication.
• Latency—each query takes time to reach your API and return, so results may be slower than an indexed search.
• Load on source—every Copilot interaction hits your live system, so you need to design for that traffic.

Live query is the right choice when data changes every second (e.g., stock levels, ticket status, or financial transactions) and when you need to enforce row-level security directly in the source.

How to Choose: Factors to Consider

There’s no one-size-fits-all answer. Evaluate these factors for each data source:

• Freshness requirement—If stale data is acceptable for a few hours, sync is simpler. If not, go live.
• Data volume—Indexing millions of records can be expensive and slow. Live queries might be more efficient for narrow lookups.
• Query complexity—If users ask open-ended questions like “summarize the last quarter’s support tickets,” a semantic index works better. If they ask “what’s the current status of order #123?”, a plugin is more precise.
• Security model—Sync requires you to map permissions accurately; live lets the source enforce security natively.
• Cost—Graph connectors consume storage and may have API costs. Live queries also cost API calls, but only when used.

A common pattern is to use sync for knowledge bases and live for transactional data. For example, a company might index its employee handbook (sync) but query its CRM for a customer’s latest order (live).

Common Problems and Misconceptions

One frequent misconception is that Copilot can “see” all your data automatically. In reality, Copilot only accesses content that’s either in Microsoft 365 or explicitly connected via a connector or plugin. If you haven’t set up either, Copilot simply won’t know about your external data.

Another issue is permission sync. With Graph connectors, if you don’t map ACLs correctly, you risk exposing sensitive data to unauthorized users. Microsoft provides tools to map permissions, but it’s a manual design task.

Latency is another surprise. Live queries can take several seconds, which feels slow in a chat interface. Users may perceive the AI as broken when it’s just waiting for an API response. Caching or hybrid approaches can mitigate this.

Finally, data residency and compliance. Sync copies data to the Microsoft 365 cloud, which may violate data residency requirements in some regions. Live queries keep data in place, but the API must be accessible from the Microsoft 365 environment, which may require network configuration.

Comparison: Sync vs. Live at a Glance

Aspect	Sync (Graph Connector)	Live (Plugin)
Freshness	Depends on refresh schedule	Real-time
Data copy	Yes, in Microsoft 365	No, stays in source
Query speed	Fast (indexed)	Slower (API call)
Security	Mapped ACLs	Source enforces
Best for	Documents, knowledge	Transactions, live metrics
Cost	Storage + ingestion	API calls per query

Costs and Licensing Considerations

Microsoft 365 Copilot requires a per-user license, but that doesn’t include unlimited Graph connectors. Each connector may have its own capacity limits, and there are quotas on the number of items you can index. For large-scale indexing, you might need additional capacity, which can incur extra costs.

Live plugins also have costs—usually the API calls to your backend, plus any cloud compute. If you’re using Microsoft Azure for hosting, those costs are separate from your Copilot license.

It’s wise to estimate your data volume and query frequency before committing. Microsoft provides documentation on connector limits, but these can change, so check the current guidance.

Alternatives and Hybrid Approaches

You don’t have to choose one exclusively. Many organizations use a hybrid:

• Sync for static reference data—e.g., product catalogs, HR policies.
• Live for dynamic data—e.g., order status, live inventory.
• Cache with periodic refresh—a middle ground where a plugin caches results for a few minutes to reduce load.

Another alternative is to use Microsoft Fabric or Azure AI Search to create a custom index that you then connect to Copilot via a plugin. This gives you more control over the indexing pipeline, but adds complexity.

For small datasets, you might even skip connectors and simply upload files to SharePoint, which Copilot can access natively. That’s the simplest path, but it doesn’t scale for large or frequently changing data.

Frequently Asked Questions

Can Copilot access my on-premises SQL Server?

Yes, but not directly. You need to expose the database via an API (e.g., a REST API) and then create a plugin that calls that API. Alternatively, you could sync the data using a Graph connector that supports on-premises sources, but you’d need a gateway.

Does sync mean my data is stored in Microsoft’s cloud?

Yes, the indexed content is stored in your Microsoft 365 tenant’s search index. That’s a copy of the data, so you need to ensure it complies with your data residency policies.

How often does a Graph connector refresh?

It depends on the connector. Some allow you to set a schedule, typically every 15 minutes to daily. Microsoft has documented limits, but you can often customize the refresh interval.

What happens if my live API is down?

Copilot will return an error or a message that the plugin is unavailable. You should design your plugin to handle failures gracefully, perhaps by falling back to cached data.

Can I use both sync and live for the same data?

Yes, but it’s usually unnecessary. You might sync a subset for fast search and use live for the most recent records, but that can lead to inconsistent results.

Is there a security risk with live queries?

Live queries can be secure if you authenticate properly. Copilot uses Microsoft Entra ID to authenticate, and your API must validate the token and enforce permissions. The risk is more about API security than the approach itself.

Related

• Excel Goal Seek: What It Does and How to Use It
• Excel Split One Row into Multiple Rows: 4 Ways
• 4K vs 8K Video: What’s the Real Difference?