Microsoft Copilot Code Preview: Build and Publish Tenant Apps With Admin Controls

Is this the end of the overgrown spreadsheet? Probably not yet. It is a preview, it needs a licence and an admin who switches it on, and there are permission and billing details to work through first. Here's what Microsoft has announced, what its documentation adds, and what IT admins should check before Frontier users start asking for the new tab.

What Copilot Code is​

Microsoft's pitch starts with how office work is organised. For decades the basic unit has been the file: a document, a spreadsheet or a deck. AI can already write code, but Microsoft notes that code on its own isn't something people can use. Someone still has to set up an environment, host the app, share it and keep it running.

Copilot Code is meant to handle that whole chain. The FiveForward consultancy summed it up this way: Code is a new tab in Copilot where anyone describes an app, tracker, dashboard or automation and Copilot builds it, using the same engine as GitHub Copilot.

Microsoft first previewed Code in September. In its September 25 post on the official Microsoft Blog, the company said that powered by the same underlying technology as GitHub Copilot, Code runs in a sandboxed environment and can be hosted securely within your tenant. It also made clear who keeps doing the professional work: your software developers continue to use GitHub Copilot for their day-to-day work with more connectivity into the Copilot platform.

Section summary: Copilot Code is a natural-language app builder for people who don't write code. It shares its agent technology with GitHub Copilot, but it is aimed at a different audience.

How the workflow runs​

The blog gives a sample scenario: a business leader trying to close a revenue gap across several markets, with the relevant data scattered across Power BI tables, documents, meetings and conversations. In Microsoft's telling, that person can build an interactive investment-modelling app without a development budget or any engineers. That is an illustration, not a documented customer result, but it shows the intended workflow:

1. Start with the outcome. Describe the goal in plain language. Copilot asks clarifying questions and can draw on work context through Work IQ to fill in requirements you didn't spell out.
2. Build from work context. Copilot assembles a working application with a live preview next to the conversation.
3. Refine through conversation. Add charts, business logic or data sources by asking, or edit directly, without starting over.
4. Stay in the preview or open the code. Non-coders can stay in the visual preview. Others can view the code, work with local files or use a terminal.
5. Run locally or in the cloud. Keep a personal project on your device, or publish it to a Microsoft-managed cloud environment so others can use it.

Microsoft's Learn documentation adds some practical detail:

• What you can build: apps and interactive tools such as trackers, forms and calculators; dashboards and data views; static websites and landing pages; data transforms, scripts and automations; and internal tools.
• How to iterate: you can select an element in the preview to point Copilot at it, and you can ask to go back to an earlier version.
• Microsoft's advice: start with the core of what you want and make one focused change at a time.
• Supported inputs: CSV files, spreadsheets, images, documents, PDFs, presentations, pasted text and, for local projects, an existing folder on your device.
• Preview limits: what can be previewed depends on the type of output and the device. Some things can't be previewed on every platform.

Section summary: You describe what you want, answer Copilot's questions, try the live preview and keep refining. Opening the code is optional.

Local vs. cloud, and the permission model​

According to Microsoft Learn, local projects run inside a project folder on your device. Copilot Code can read files there, install what the project needs and run the app so the preview stays current. It asks for approval before it reaches outside that folder or makes a network connection. Cloud projects run in an isolated cloud environment, so you can pick up the work from another device.

By default, Microsoft says Copilot Code asks permission before it:

• makes network calls, including internet access
• uses extensions and MCP
• runs shell or terminal commands
• reads or writes files outside the projects and folders already in use

Reading and writing inside folders that are already in use needs no extra prompt, and that applies across Copilot Code projects. If you start a new project in an existing folder, every Copilot Code project can read from and write to that folder.

The setting to watch is Always allow. Microsoft's documentation warns that once it's turned on, it stays on until you turn it off. It also covers existing sessions and workspaces, plus any new ones. In practice, one click can approve every future action for that user, so treat it accordingly.

Local coding is also off unless an admin turns it on. The Microsoft 365 Message Center notice MC1519871 says local coding sessions are disabled by default. Admins can allow local coding on PC by setting Code execution location to Cloud and local in the Microsoft 365 admin center.

Section summary: Cloud is the default. Local coding is an admin opt-in, and the permission prompts protect you only as long as nobody clicks "Always allow."

Growing a project: the GitHub handoff​

The blog's second theme is what happens when a personal tool turns into something a team depends on. At that point a project usually needs code review, release management and security controls. Microsoft's answer is to connect the project to a new or existing GitHub repository and open a draft pull request that engineering teams can review.

Microsoft Learn says GitHub is optional. You don't need it to build, preview or save projects. Once you connect it, you can work with repositories, ask questions about your code and open pull requests.

A draft pull request is where an engineering review starts. It doesn't mean anyone has approved the code. An app generated by AI hasn't been through QA or security testing just because it sits in a repository. Developers who inherit these projects will need the same discipline they apply to code from a new hire, and probably more.

The Copilot Managed Runtime tooling is built with that handoff in mind. Integration consultant Stephen W. Thomas notes that the SDK and CLI support project setup, typed connector services for TypeScript, local development, deployment, and versioning. The code remains editable and Git-backed.

Section summary: Projects can be handed to developers through GitHub. Review still has to happen; the handoff doesn't replace it.

Sharing apps through Copilot Managed Runtime​

When an app is meant to be shared, the blog says Copilot builds it on Copilot Managed Runtime, so there is no separate deployment step. Microsoft also says the app inherits the governance, security and management controls the organisation has already configured.

Copilot Managed Runtime isn't specific to Code. In its September announcement, Microsoft called it an enterprise-grade platform to run code within the Microsoft 365 tenant boundary that's governed by IT, adding that it already powers the apps built in Copilot Cowork, Copilot Code, and Microsoft Copilot Studio. WindowsForum's earlier coverage noted that IT manages those apps from a new Apps page in the Microsoft 365 admin center. Copilot Managed Runtime itself is still in preview.

Microsoft Learn adds two details that matter for sharing:

• Saving isn't publishing. Projects save automatically, but an app goes live only when you ask Copilot to publish it.
• Sharing an app doesn't share the data behind it. People you share with see only data they can already access in the connected sources, such as a SharePoint list. They may be asked to approve a connection the first time they open the app.

That second point refines the blog's claim that anyone with permission to the underlying data can use a shared app. Your existing permissions still decide what each person sees, which is the right design. It also means a shared dashboard can look different, or partly empty, depending on who opens it.

Section summary: Publishing is a deliberate step, apps run in your tenant under Entra identity and tenant policies, and each user's data permissions stay in force.

Requirements and admin controls​

Here is how the requirements line up, based on Microsoft Learn and Message Center notice MC1519871:

Billing needs the most attention. MC1519871 lists those affected as users in the Frontier program who have a Microsoft 365 Copilot license and are enabled for usage-based billing. Admins are told to enable Copilot Credit consumption and configure the appropriate spending policies in the Microsoft 365 admin center under Copilot > Cost management.

Admins should also check one easily missed setting. Per the notice, users covered by a spending policy where the setting "Allow new Agents and services as they become available" is enabled automatically receive access to Code through that spending policy. If you want to decide who gets Code yourself, review that setting before the rollout reaches your tenant.

Microsoft Learn's admin page lists these defaults, all of which may change during the preview:

• Pre-install Copilot Code components: Off
• Auto-approve setting: On, meaning users can let Copilot approve permissions automatically
• Execution location: Cloud only
• GitHub connection: Off
• Allowed GitHub connections: GitHub.com, GitHub Enterprise, both or none
• Organizational data (Microsoft Graph and Work IQ): On for cloud, off for local

Admins can also limit GitHub connections to accounts associated with their tenant and set spend limits for each user.

There's a small inconsistency in the sources. MC1519871 lists the Copilot app on Windows and the web, while the Learn requirements page also lists the Mac desktop app. If your Mac users can't find the tab, the staggered rollout is the likely reason.

Section summary: You need a licence, usage-based billing, a spending policy and an organisation-level switch. Review the auto-approve default and the "new agents and services" spending setting.

Rollout timing​

The schedule has moved. In September, Microsoft said Code would reach Frontier at the end of the month, with broad availability in the coming weeks. The October 21 blog says the rollout is only now beginning through Frontier, and MC1519871 puts the start in late October 2026. "Rolling out" means a gradual arrival, so not every Frontier tenant will see Code at once, and Microsoft hasn't given a general availability date.

Analysis: shadow IT with an admin console?​

This analysis is based on general industry experience rather than Microsoft's materials. Everyone who has run IT through the Access-database and Excel-macro years has seen this pattern: business users build what they need, and IT finds out about it when it breaks. Copilot Code makes that kind of building much faster. Microsoft is betting that running these apps inside the tenant, under Entra identity, existing data permissions and an admin inventory, turns shadow IT into managed IT.

That bet is reasonable, but some risks remain:

• Correctness. A good-looking investment model with a wrong formula is still wrong. Generated business logic needs checking before anyone makes a decision based on it.
• Ownership. When the person who built an app leaves, who maintains it? The GitHub handoff helps only if someone in engineering actually takes it on.
• Cost. Usage-based billing means experiments cost money. Spend limits are there for a reason.
• Consent fatigue. Permission prompts work until people get tired of clicking them. The "Always allow" option and the auto-approve default deserve a policy decision now, before users make it for you.

For admins with Frontier enabled, a sensible first week looks like this:

1. Confirm who is covered by spending policies with "Allow new Agents and services" turned on.
2. Decide between cloud only and cloud plus local.
3. Decide whether users may auto-approve permissions.
4. Leave GitHub connections off until there's a review process, then limit them to tenant-associated accounts.
5. Brief the help desk, which Microsoft's notice specifically recommends.
6. Agree on what counts as an app that has graduated and must go through engineering review.

The bottom line​

Copilot Code is Microsoft's clearest push yet to bring app building to people who don't write code. You describe the app, refine it in conversation, keep it to yourself or publish it inside your tenant, and hand it to developers through a draft pull request when it outgrows you. The approach is sound and the governance design is careful. It is still a preview that requires Frontier enrollment, comes with usage-based billing and has defaults admins should review.

The people closest to the problem can now build the fix. Making sure the fix is correct, paid for and maintained is still IT's job.