Migrating from Microsoft 365 to LibreOffice at scale: an IT admin's playbook

Stop losing hours to licensing, macros, and broken layouts — a practical playbook for migrating thousands of users from Microsoft 365 to LibreOffice

For IT teams in 2026, migrating away from Microsoft 365 is no longer just political or budgetary — it's an operational project with measurable risks: document fidelity, VBA macros, centralized templates, Group Policy equivalents, and enterprise deployment pipelines. This playbook gives you an actionable, step-by-step plan to move enterprise users to LibreOffice at scale, minimize business disruption, and retain advanced workflows (including macro-heavy Excel use) where necessary.

Why enterprises are evaluating LibreOffice in 2026

Three forces are driving renewed interest in LibreOffice across government and private sectors:

• Cost and licensing pressure — tight budgets and audit scrutiny make open-source alternatives appealing.
• Privacy and data sovereignty — ODF (ISO/IEC 26300) and offline-first workflows reduce cloud exposure.
• Improved compatibility — ongoing Document Foundation improvements and community support have reduced rendering gaps for common DOCX/XLSX/PPTX scenarios.

That said, LibreOffice isn’t a drop-in replacement for every user. Your migration must account for edge cases: VBA macros, advanced Excel models, embedded ActiveX controls, and company-branded templates. This guide focuses on operationalizing the migration using enterprise tooling like Intune and SCCM and admin controls via Group Policy/AD.

High-level migration phases

1. Discovery — inventory documents, macros, templates, and user behavior.
2. Compatibility testing — measure rendering and functional gaps with representative sample sets.
3. Decisioning & segmentation — classify users: full migration, hybrid, or exempt.
4. Proof of concept (PoC) — pilot rollout and feedback loop.
5. Packaging & deployment — build Intune/SCCM packages with configuration management.
6. Migration & cutover — templates, file associations, and profile migration.
7. Training & support — change management, targeted training, and migration backstops.
8. Optimization — macro conversion, automation, and long-term policy.

Phase 1 — Discovery: inventory what matters

Start with data. Effective migration depends on knowing the scale and complexity of your estate.

Inventory checklist

• Count of documents by file type (DOCX, DOTX, XLSX, XLSM, PPTX, ODT, ODS).
• Number of macro-enabled files (XLSM, DOCM) and frequency of use.
• Top 100 business-critical templates and slide/presentation masters.
• Line-of-business (LOB) apps that expect Microsoft Office COM interfaces or use automation.
• User personas by macro reliance and collaboration needs.

Tools: use content scanners that can read file headers and extract macro presence (PowerShell with the Open XML SDK, or third-party DLP/inventory tools). Example PowerShell command to list macro-enabled files in a share:

Get-ChildItem -Path \\fileserver\shares -Include *.xlsm,*.docm -Recurse | Select FullName,Length,LastWriteTime

Phase 2 — Compatibility testing: build objective metrics

Testing should be automated and repeatable. Your goal is a compatibility matrix for features, layout, and macro behavior.

Define test buckets

• Rendering fidelity — layout, fonts, images, tables, and pagination.
• Formulas & functions — Excel functions, pivot tables, Power Query reliance.
• Macros & automation — VBA dependence, COM automation, third-party add-ins.
• Templates & styles — corporate branding, master slides, header/footers.
• Collaboration features — track changes, comments, co-authoring (if used).

Automated headless conversion testing

Use LibreOffice’s headless mode for bulk conversions to discover rendering differences quickly. Convert a corpus of user documents to PDF/OFD and compare visual diffs.

"C:\Program Files\LibreOffice\program\soffice.exe" --headless --convert-to pdf "C:\test\docs\*.docx" --outdir C:\test\converted

Use image-based comparison tools (ImageMagick compare or SSIM libraries) to quantify layout deltas. Build a compatibility score per document: e.g., 0–5 where 0 = incompatible, 5 = identical. Track distribution of scores across users.

Macro testing

Macros are the common showstopper. LibreOffice supports its own scripting (LibreOffice Basic), Python, and limited VBA compatibility via the UNO bridge. For each macro-enabled file:

• Classify macros by complexity: UI automation, COM/ActiveX, file I/O, external application calls.
• Automate execution in a sandbox to detect runtime errors. Run files inside a test VM and capture exceptions.
• Log VBA features used — e.g., Application.Run, CreateObject, GetObject — that indicate reliance on Windows COM components.

Phase 3 — Decisioning & segmentation

Not every user is a candidate for immediate cutover. Use your test data to place users into three buckets:

• Full migration — users with low macro use and high document fidelity scores.
• Hybrid — users with occasional macros or complex Excel models; provide LibreOffice as primary and keep MS Excel available via virtualization (RDS, VDI, or Cloud-hosted Excel).
• Exempt — heavy macro/Lob dependencies; remain on Microsoft 365 with a migration roadmap.

Document this segmentation in your change-control system and inform stakeholders about the long-term plan for exempt users (e.g., macro rewriting or application modernization).

Phase 4 — PoC and pilot: validate with real users

Deploy a pilot to 2–5% of users across personas. Measure:

• Support tickets per 100 users.
• Average time to open/print/modify key documents.
• Macro failures and functional gaps logged.
• User satisfaction and training completion rates.

Use the pilot to refine packaging, templates, and the training plan. Capture example 'gotchas' to include in your training materials and KB articles.

Phase 5 — Packaging & deployment strategies (Intune and SCCM)

Your deployment needs to be reproducible, auditable, and manageable via existing endpoint management tools. Below are recommended patterns for Intune and SCCM (ConfigMgr).

Packaging LibreOffice for Intune

1. Download the MSI or EXE from the official LibreOffice enterprise builds or a validated corporate mirror. Prefer MSI for easier silent install control.
2. Create a Win32 .intunewin package using the Microsoft Win32 Content Prep Tool.
3. Configure install command for silent install and set UI suppression. Example MSI command:

   msiexec /i LibreOffice_x64.msi /qn /norestart INSTALLLOCATION="C:\Program Files\LibreOffice"

4. Set detection rules: check version in registry or Presence of soffice.exe.
5. Assign to user/device groups defined by your segmentation (Full/Hybrid).
6. Include post-install configuration scripts to import custom templates and registry keys for associations.

Packaging LibreOffice for SCCM (ConfigMgr)

1. Create an application with the MSI as source.
2. Set installation behavior to System and provide the same silent switches.
3. Use detection methods (file or registry) and add dependencies if you need to pre-install fonts or other prerequisites.
4. Deploy via Device Collections; use maintenance windows for broad rollouts.

Post-install configuration — key items

• Set file associations to ODT/ODS/ODP or leave DOCX/XLSX associations mapped to LibreOffice if acceptable.
• Push corporate templates (.ott, .ots, .otp) to %APPDATA%\LibreOffice\4\user\template via script or user profile migration.
• Apply macro security defaults via config or registry to disallow unsigned macros, mirroring your organization’s policy.
• Disable automatic online checks if users are offline-first.

Sample post-install PowerShell for templates and associations

# Copy templates to user profile
$templates = "\\fileserver\templates\companytemplate.ott"
Copy-Item -Path $templates -Destination "$env:APPDATA\LibreOffice\4\user\template\" -Force

# Set file association for .docx to LibreOffice Writer via ftype/assoc (requires admin)
$prog = '"C:\Program Files\LibreOffice\program\swriter.exe" "%1"'
New-ItemProperty -Path 'HKCR\Applications\swriter.exe\shell\open\command' -Name '(Default)' -Value $prog -Force

Phase 6 — Handling macros: options and patterns

Macros are the most operationally impactful area. There are three pragmatic paths:

• Convert — rewrite VBA to LibreOffice Basic or Python (good for long-term portability).
• Encapsulate — provide virtualization (RDS/VDI) for users that need Excel/Word exact behavior.
• Isolate — keep a subset of users on Microsoft 365 for a limited time while modernizing apps.

Macro conversion workflow

1. Extract VBA modules from files and run static analysis to determine API usage.
2. For simple UI scripts and macros that manipulate worksheets, consider automated translators (partial) and manual review.
3. Re-implement heavy business logic in server-side services or Python scripts where possible — reduces client-side risk.
4. Pack converted macros into template files and distribute via post-install step.

Note: conversion is labor-intensive. Prioritize by business impact and frequency of use.

Phase 7 — Templates, branding, and corporate styles

Templates are central to brand compliance. For each corporate template:

• Recreate styles in LibreOffice to match fonts, margins, and headers/footers. Avoid embedded fonts when possible — prefer corporate font deployments via GPO/Intune.
• Test mail merge and dynamic fields; LibreOffice uses different field names and APIs.
• Publish templates to a central network path and use configuration scripts to register them as 'Organizational' templates in the LibreOffice profile.

Phase 8 — Group Policy, Registry, and Intune configuration

Unlike Microsoft Office, LibreOffice doesn’t use traditional ADMX GPO natively at the same depth, but you can control many behaviors via:

• Registry keys under HKCU/HKLM for settings imported from the user profile.
• Configuration via the LibreOffice managed settings export/import (the .xcu XML preferences files) deployed to %APPDATA%.
• Use Intune configuration profiles to push scripts that place config files and templates in user profiles.

Example approach: maintain a versioned configuration package that your deployment script copies to %APPDATA%\LibreOffice\4\user\. Keep a delta-based update mechanism to avoid overwriting user customizations.

Phase 9 — Training and support rollout

Your migration will succeed or fail on user adoption. Plan training in sprints aligned with your deployment waves.

Training layers

• Executive & managers — high-level differences, governance, and escalation paths.
• Power users — deep dives on macros, spreadsheets, and template creation.
• End users — quick-start guides, cheat sheets for common tasks (save-as DOCX, shared drive access, PDF export).

Support structure

• Tier 1 KBs and scripted fixes (common issues like missing fonts or association problems).
• Tier 2 macro conversion team and escalation to application owners.
• Fallback: a short-term MS365 access mechanism (VDI or license pool) for urgent compatibility gaps.

Phase 10 — Metrics and continuous improvement

Track these KPIs post-migration:

• Number of support tickets per 1,000 users per month.
• Macro conversion throughput (files converted per month).
• User satisfaction score and training completion percentage.
• Cost savings vs. Microsoft 365 licensing over 12 and 36 months.

Use these metrics to justify expanding the migration or investing in conversion tools and automation.

Advanced strategies and future-proofing (2026 focus)

As you stabilize the desktop migration, consider these forward-looking tactics now gaining traction in late 2025–2026:

• Hybrid hosting of Excel macros — host Excel in a containerized service for macro execution, invoking via secure APIs rather than running macros on endpoints.
• Document CI/CD — version-control templates and macros in Git, trigger automated validations (headless LibreOffice conversions) on commits.
• ODF-first governance — enforce ODF for archival and interchange, with on-the-fly conversion for external partners.
• Automation & AI-assisted conversion — leverage emerging tools that assist with macro translation and formula mapping (evaluate vendor tools released in 2025–2026).

Real-world example: 12,000-seat migration—high level case study

Summary: a public sector IT organization ran a structured migration in 2025 across 12,000 seats. Key outcomes:

• Pilot (2%) revealed 8% of documents were macro-enabled; those users entered the hybrid bucket.
• Automated headless conversion reduced manual testing time by 60%.
• Deployment via SCCM for managed devices and Intune for remote/modern devices reduced rollout time from 9 months (est.) to 5 months.
• Macro conversion for the top 300 files delivered a 70% runtime parity; the rest were supported via hosted Excel.
• Annual licensing savings offset 18 months of conversion costs.

Key lesson: mix strategies — convert what provides ROI, virtualize the rest, and standardize templates and governance early.

Common pitfalls and how to avoid them

• No segmentation — treating all users the same leads to support overload. Use discovery to segment.
• Skipping macro assessment — underestimating macros is the top cause of migration failure.
• Poor training — users revert to old workflows without targeted training and quick wins.
• No fallback plan — maintain a predictable rollback or hybrid access path (VDI or license pool).

Quick checklist before a full rollout

• Inventory and classification complete.
• Compatibility matrix with objective scores for at least 80% of files.
• Pilot completed with acceptable support metrics.
• Intune/SCCM packages and post-install scripts tested in staging.
• Templates and corporate styles migrated and validated.
• Macro strategy defined (convert/hybrid/exempt) and resources allocated.
• Training schedule and support KB published.

Actionable takeaway — a 30/60/90-day rollout plan

Days 0–30

• Run discovery scans and classify users. Build a representative test corpus.
• Set up headless conversion scripts and baseline compatibility metrics.

Days 31–60

• Run a pilot (2–5%) with Intune and SCCM packages. Refine installation scripts and templates.
• Start macro conversion work for high-impact files.

Days 61–90

• Roll out to full-migration segment. Provide targeted training and support staffing increases as needed.
• Evaluate KPIs and iterate on conversion timelines for hybrid/exempt groups.

Final notes — governance, compliance, and long-term maintenance

Make ODF and LibreOffice part of your endpoint governance: periodic compatibility checks, template lifecycle management, and an approved list of vendors/tools for macro translation. Keep an inventory and retention policy that aligns with records management and compliance. In 2026, regulators expect clear provenance and access controls for documents — ensure your LibreOffice deployment integrates with existing DLP, backup, and archival systems.

Conclusion & next steps

Switching thousands of users to LibreOffice is a multi-year program, not a single project. With the right discovery, objective compatibility testing, strategic macro handling, and disciplined Intune/SCCM packaging, you can reduce risk and capture meaningful cost and privacy benefits.

Start small, measure crisply, and maintain fallbacks for critical workflows. This playbook gives you the operational blueprint — now adapt it to your environment and build the migration backlog with clear ROI gates.

Call to action

Ready to pilot LibreOffice in your environment? Download our ready-made Intune and SCCM packaging scripts, headless conversion test harness, and macro assessment checklist. Sign up for the windows.page admin toolkit to get the artifacts and a 30-day implementation checklist you can use in your first pilot.

Related Reading

• Map Design Wishlist for Arc Raiders: Variety, Size, and Playstyle Balance
• Theatre and Movement in Denmark: Lessons from Anne Gridley and Nature Theatre of Oklahoma
• Use Your Smartwatch as the Ultimate Sous-Chef: Timers, Checklists, and Notifications
• How to Use Points & Miles to Visit The Points Guy’s 2026 Picks Without Breaking the Bank
• Branding for Real-Time Events: How to Design Badges, Overlays and Lower Thirds for Live Streams