---
title: "AEM 6.5 End of Support (February 2027): Technical Migration Guide"
slug: aem-65-end-of-support-february-2027-technical-migration-guide
date: 2026-11-16
author: Abdul Aleem
categories: [Adobe Experience Manager, Migration Guide]
excerpt: "AEM 6.5 on-premise support ends February 2027. Four migration paths compared: LTS, Cloud Service, Edge Delivery, and non-Adobe—with data extraction methods."
tldr: "AEM 6.5 on-premise core support ends Feb 28, 2027. Four paths: LTS (quickest), Cloud Service, Edge Delivery, or leave Adobe entirely. Start scoping now."
canonical: https://clonepartner.com/blog/aem-65-end-of-support-february-2027-technical-migration-guide
---

# AEM 6.5 End of Support (February 2027): Technical Migration Guide


# AEM 6.5 End of Support (February 2027): Technical Migration Guide

**Core support for Adobe Experience Manager 6.5 on-premise ends February 28, 2027** ([experienceleague.adobe.com](https://experienceleague.adobe.com/en/docs/experience-manager-65-lts/content/release-notes/faq)). If you're on Adobe Managed Services, that deadline already passed — AMS support ended August 31, 2026. Customers with approved extended support get critical security fixes until February 2028, and only on the last service pack, SP26 ([experienceleague.adobe.com](https://experienceleague.adobe.com/en/docs/experience-manager-release-information/aem-release-updates/update-releases-roadmap)). After those dates, you are running software Adobe no longer patches.

This guide maps every confirmed date, explains the four realistic migration paths, details the exact methods for extracting content from the Java Content Repository (JCR), names the specific APIs Adobe has already deprecated, identifies the LTS breaking changes that matter most, documents where AEM migrations actually break, and covers what each path requires from an engineering and budget standpoint.

For the broader CMS and DXP end-of-support landscape, including Drupal 10, Umbraco 13, and Sitecore XP deadlines landing in the same window, see our [CMS & DXP End-of-Support Calendar](https://clonepartner.com/blog/blog/cms-dxp-end-of-support-calendar-20262027).

## Every AEM 6.5 end-of-support date that matters

**AEM 6.5 end of support** refers to Adobe's published schedule for discontinuing security patches, service packs, and technical support for the AEM 6.5 release line. The dates vary by deployment model.

| Date | Event | Who is affected |
|---|---|---|
| **31 Aug 2026** | AEM 6.5 Managed Services support ended | AMS customers |
| **12 Nov 2026** (target) | Service Pack 26 (6.5.26.0) — last SP for classic 6.5 | All 6.5 customers |
| **28 Feb 2027** | Core support for AEM 6.5 on-premise ends | On-prem customers |
| **Feb 2028** | Extended support ends (critical security fixes on SP26 only) | On-prem customers with approved extended support |

All dates are sourced from [Adobe's releases roadmap](https://experienceleague.adobe.com/en/docs/experience-manager-release-information/aem-release-updates/update-releases-roadmap) and the [AEM 6.5 LTS FAQ](https://experienceleague.adobe.com/en/docs/experience-manager-65-lts/content/release-notes/faq). Note: the roadmap says on-premise core support is "currently planned to end by February 2027" and that each 6.5 service pack is supported until February 28, 2027. It lists SP26 with a target date, not a confirmed release date, and gives no day for the end of extended support.

> [!WARNING]
> **If you're on AMS, you are already past your deadline.** The February 2027 date applies only to on-premise deployments. AMS customers who haven't moved to 6.5 LTS or Cloud Service are running on an unsupported platform today.

## What changes after core support ends?

After February 28, 2027, Adobe stops providing regular service packs, security patches, and standard technical support for AEM 6.5. Running unsupported software is hard to square with the vulnerability-management controls in frameworks such as SOC 2, ISO 27001 and the HIPAA Security Rule, and auditors can flag unpatched CMS versions as findings.

The practical consequences:

- **No new security patches.** When a vulnerability is disclosed in Apache Sling, Apache Felix, or the underlying OSGi framework after this date, Adobe will not issue a fix for standard support customers. CVEs affecting Jackrabbit Oak (the JCR implementation), Granite UI, or bundled Apache components accumulate with no resolution path.
- **Extended support is limited.** Adobe's roadmap says customers with approved extended support until February 2028 get critical security fixes only, and only on Service Pack 26 ([experienceleague.adobe.com](https://experienceleague.adobe.com/en/docs/experience-manager-release-information/aem-release-updates/update-releases-roadmap)). Get the terms and cost from your Adobe account team in writing.
- **Compliance exposure.** SOC 2, ISO 27001 and HIPAA Security Rule reviews all look at how you manage known vulnerabilities, and out-of-support software is hard to defend in them — especially in regulated industries such as healthcare, financial services and government.
- **Growing API gap.** Adobe's Cloud Service deprecation list sets **March 31, 2027** as the target removal date for several deprecated APIs, including `com.day.cq.wcm.commons.utils`, `com.day.cq.commons.predicate` and `org.apache.tika`, with further tentative removals, such as `org.apache.commons.lang`, on December 31, 2027 ([experienceleague.adobe.com](https://experienceleague.adobe.com/en/docs/experience-manager-cloud-service/content/release-notes/deprecated-removed-features)). The longer you stay on 6.5, the larger the delta your engineers must close when moving to Cloud Service.

## The four migration paths, compared honestly

Every AEM 6.5 team faces the same decision tree. There are exactly four paths, and each trades a different resource — time, money, architectural flexibility, or operational control — for a different outcome.

| Path | What moves | Effort level | Stays on Adobe? |
|---|---|---|---|
| **AEM 6.5 LTS** | Runtime only — content and code stay in place | Low–Medium | Yes |
| **AEM as a Cloud Service** | Content via CTT; code refactored for Cloud Manager | High | Yes |
| **Edge Delivery Services** | Content mapped to new model; front end rebuilt as blocks | High | Yes |
| **Non-Adobe platform** | Content extracted via APIs; application rebuilt | High | No |

How long each path takes depends on your implementation: page count, custom components, OSGi bundles, integrations and multi-site setup. Adobe does not publish typical durations, so size the project from an audit of your own codebase (for Cloud Service, the Best Practices Analyzer report) rather than generic estimates.

### Path 1: Upgrade to AEM 6.5 LTS

**AEM 6.5 LTS (Long-Term Support)** is an in-place upgrade that keeps your content and code where they are while refreshing the underlying runtime. Adobe supports upgrading directly from AEM 6.5 to any 6.5 LTS service pack ([experienceleague.adobe.com](https://experienceleague.adobe.com/en/docs/experience-manager-65-lts/content/release-notes/faq)). LTS updates Apache Jackrabbit Oak to 1.68.x and supports Java 17 and Java 21 ([experienceleague.adobe.com](https://experienceleague.adobe.com/en/docs/experience-manager-65-lts/content/release-notes/release-notes)). Java 8 and 11 are not listed as supported runtimes for LTS.

**When it makes sense:**

- You need to clear the February 2027 deadline quickly and cannot complete a Cloud Service migration in the available window
- Your customizations are extensive and a cloud refactor would take longer than the runway allows
- You want to separate the "get supported" decision from the "go to cloud" decision

**What it does not do:**

- It does not change the architecture. You still manage servers, Dispatchers, OS patching, backups, and release management.
- It does not reduce the eventual Cloud Service migration effort — the code delta accumulates.

**What actually breaks on the LTS upgrade — specific known issues:**

The LTS release notes list removed features and bundles ([experienceleague.adobe.com](https://experienceleague.adobe.com/en/docs/experience-manager-65-lts/content/release-notes/release-notes)). These are the ones most likely to break custom code, not an exhaustive list:

- **Guava removed:** The Guava bundle no longer ships with AEM. Custom code that imports `com.google.common` packages must bundle Guava itself or switch to Java collections. OSGi bundles importing it will fail to resolve at startup.
- **RDBMK removed:** MongoMK is now the only supported persistence option for clustered environments. It requires MongoDB Enterprise 6.0, 7.0 or 8.0 ([experienceleague.adobe.com](https://experienceleague.adobe.com/en/docs/experience-manager-65-lts/content/implementing/deploying/introduction/technical-requirements)).
- **Modules removed with no replacement:** Social/Communities, Screens, AEM Portal Director, the We.Retail sample site, `crx2oak`, `crx-explorer`, `oak-solr-osgi`, and the Abdera and JDOM bundles.
- **AEM CIF Classic removed:** Adobe provides a migration path to AEM CIF.
- **Deprecated, not removed:** The LTS release notes do not list the Foundation components as removed. Adobe's AEM 6.5 notes call them deprecated but still supported ([experienceleague.adobe.com](https://experienceleague.adobe.com/en/docs/experience-manager-65/content/release-notes/deprecated-removed-features)).

**Technical requirements:** Oracle Java 17 or 21 (IBM Semeru is supported only with WebSphere) and Dispatcher 4.3.2 or later ([experienceleague.adobe.com](https://experienceleague.adobe.com/en/docs/experience-manager-65-lts/content/implementing/deploying/introduction/technical-requirements)). Before attempting the LTS upgrade, check your code against the removed features list and the AEM Analyzer tool that the LTS FAQ points to.

Adobe's roadmap lists target dates for LTS service packs through SP7 in November 2027 ([experienceleague.adobe.com](https://experienceleague.adobe.com/en/docs/experience-manager-release-information/aem-release-updates/update-releases-roadmap)). Confirm your specific contract coverage post-February 2027 with your Adobe account team in writing.

> [!TIP]
> **LTS is the lowest-friction path to clear the deadline.** For most on-premise teams, this is the sensible first step. The cloud decision can happen on its own schedule — but be aware that every month on LTS is another month of technical debt accumulating against your eventual Cloud Service migration.

### Path 2: Migrate to AEM as a Cloud Service

**AEM as a Cloud Service (AEMaaCS)** is Adobe's cloud-native deployment model — a rolling release with automatic updates managed through Cloud Manager. This is not a version patch or a hosting change. It is a major architectural shift.

Key differences from AEM 6.5 ([experienceleague.adobe.com](https://experienceleague.adobe.com/en/docs/experience-manager-cloud-service/content/release-notes/aem-cloud-changes)):

- **/apps and /libs are immutable at runtime.** In AEM 6.5, developers could deploy OSGi bundles and overlay `/libs` paths at runtime. In AEMaaCS, content in `/apps` and `/libs` is read-only, and all custom code arrives exclusively through Cloud Manager pipelines. Any deployment path that bypasses the pipeline is not available.
- **OSGi configurations move to JSON** (`.cfg.json` files in run-mode-specific config folders under `/apps`), which supersede the older `sling:OsgiConfig` repository nodes ([experienceleague.adobe.com](https://experienceleague.adobe.com/en/docs/experience-manager-cloud-service/content/implementing/deploying/configuring-osgi)). All existing configurations must be converted.
- **Replication agents are gone.** Publishing uses Sling Content Distribution (SCD). Custom replication agent configurations, pre- and post-processors, and transport handlers must be rebuilt using SCD extension points or removed.
- **Asset processing moves to asset microservices.** AEM 6.5 handles DAM ingestion through the AEM JVM via workflow steps. AEMaaCS offloads processing to containerized microservices. Custom workflow steps for image rendition generation, video transcoding, or metadata extraction must be rebuilt using Adobe App Builder and custom asset compute workers via the Asset Compute SDK.
- **Classic UI is removed.** Authors must use Touch UI exclusively. Admin tooling built on ExtJS is gone.
- **Identity moves to Adobe IMS.** LDAP-synced users, local service users, and group structures must be mapped to IMS. This is a non-trivial migration task for large organizations with complex permission trees.

**Adobe's migration toolchain:**

- **Best Practices Analyzer (BPA):** Downloaded from the Software Distribution portal and installed on your 6.5 instance. It flags patterns that must change — code to refactor, repository items to move, legacy UI dialogs and components, deployment and configuration issues, and features unsupported in Cloud Service ([experienceleague.adobe.com](https://experienceleague.adobe.com/en/docs/experience-manager-cloud-service/content/migration-journey/cloud-migration/best-practices-analyzer/using-best-practices-analyzer)).
- **Cloud Acceleration Manager (CAM):** Ingests the BPA report, which BPA can upload automatically, and organizes findings into a structured migration plan.
- **Repository Modernizer:** Restructures your Maven project packages to separate immutable (`/apps`) from mutable (`/content`) content, which Cloud Manager's immutable content validation requires.
- **Dispatcher Converter:** Converts AMS or on-premise `httpd.conf` and `dispatcher.any` configurations to the Cloud Service directory structure and variable format.
- **Content Transfer Tool (CTT):** Extracts content from your source instance into a migration set (cloud storage Adobe provides) and ingests it into a Cloud Service environment. It supports differential top-ups that transfer only the changes since the previous run ([experienceleague.adobe.com](https://experienceleague.adobe.com/en/docs/experience-manager-cloud-service/content/migration-journey/cloud-migration/content-transfer-tool/overview-content-transfer-tool)).

**CTT technical limits — plan around these before scoping** ([experienceleague.adobe.com](https://experienceleague.adobe.com/en/docs/experience-manager-cloud-service/content/migration-journey/cloud-migration/content-transfer-tool/prerequisites-content-transfer-tool)):

| Constraint | Limit |
|---|---|
| Source AEM version | 6.3 or higher |
| JCR node count (segment store) | < 750 million nodes |
| Segment store size (Author, online compacted) | ≤ 500 GB |
| Segment store size (Publish, online compacted) | ≤ 50 GB |
| File Data Store total | ≤ 20 TB |
| Total Lucene index size (excluding `/oak:index/lucene` and `/oak:index/damAssetLucene`) | ≤ 25 GB |

Repositories exceeding these limits require a support ticket with Adobe Customer Care before migration begins. Adobe also recommends running Revision Cleanup and data store consistency checks on the source repository before extraction ([experienceleague.adobe.com](https://experienceleague.adobe.com/en/docs/experience-manager-cloud-service/content/migration-journey/cloud-migration/content-transfer-tool/guidelines-best-practices-content-transfer-tool)).

**What CTT does not migrate:**

- Content in immutable paths such as `/apps` and `/libs` — CTT cannot migrate it ([experienceleague.adobe.com](https://experienceleague.adobe.com/en/docs/experience-manager-cloud-service/content/migration-journey/cloud-migration/content-transfer-tool/prerequisites-content-transfer-tool)). Code arrives through the Cloud Manager pipeline instead.
- Users. CTT migrates groups that appear on ACL or CUG policies of migrated content, but not users, who are created when they first log in through Adobe IMS ([experienceleague.adobe.com](https://experienceleague.adobe.com/en/docs/experience-manager-cloud-service/content/migration-journey/cloud-migration/content-transfer-tool/group-migration)).

The CTT handles the data layer. Code refactoring, Dispatcher conversion, CI/CD pipeline configuration, identity migration, and QA are entirely separate engineering workstreams, and they usually take far longer than the content transfer.

> [!NOTE]
> **Keep two clocks apart.** Moving the content with CTT is the shorter clock, and CTT's differential top-ups let a final delta run just before go-live. The full re-platforming project — code refactoring, testing, Dispatcher conversion, identity mapping, CI/CD pipeline configuration — is a separate, much longer effort. Conflating these two timelines is a common planning error in AEM Cloud Service migrations.

### Path 3: Move to Edge Delivery Services

**Edge Delivery Services (EDS)** is Adobe's edge-first delivery tier that replaces the traditional AEM Publish/Dispatcher architecture with pre-rendered content served from a global CDN. Content is flattened to Markdown and HTML at publish time — there is no server assembling a page at request time.

EDS supports document-based authoring (Google Docs or Microsoft Word) and the Universal Editor. The content model is organized around **blocks** — the building units of EDS pages — rather than AEM's component dialogs and HTL templates. Performance is the primary technical argument for the architecture.

**The hard truth:** Moving a traditional AEM Sites implementation to Edge Delivery Services is not a lift-and-shift. Component dialogs, HTL templates, front-end JavaScript, and editable field structures all require rebuilding. This is a front-end rebuild and a content model rethink, and much of the content will need review during restructuring.

Adobe offers an Experience Modernization Agent that migrates sites to Edge Delivery Services. For migrations Adobe delivers with it, the standard source scope is publicly accessible static HTML, and Adobe's team assesses protected or private-network sources case by case ([experienceleague.adobe.com](https://experienceleague.adobe.com/en/docs/experience-manager-cloud-service/content/ai-in-aem/agents/brand-experience/modernization/aoe-delivery)).

**When EDS makes sense:**

- Your primary goal is performance (fast page loads)
- Your content is primarily marketing pages, not complex application flows or transactional experiences
- You have front-end engineering capacity to rebuild the delivery layer in JavaScript
- You're comfortable with document-based authoring or the Universal Editor as your primary authoring interface

### Path 4: Leave Adobe entirely

Some teams look at the AEM 6.5 deadline and ask a larger question: should we still be on Adobe at all?

This is a legitimate path when:

- AEM is running primarily a marketing site, and enterprise DXP features (personalization, multi-site management, deep Analytics integration) go unused
- Every content change requires a Java specialist, creating a bottleneck inconsistent with the actual publishing cadence
- The annual licensing cost is difficult to justify against actual usage patterns

**Common destinations outside Adobe** include API-first headless CMS platforms (Contentful, [Sanity](https://clonepartner.com/blog/blog/adobe-cq5-vs-sanity-architecture-tco-migration-guide), Storyblok, Strapi) and enterprise DXPs (Sitecore, Optimizely). Each carries a build cost on top of platform licensing, but ongoing developer dependency can drop significantly with API-first architectures.

Migrating to an API-first headless platform requires translating AEM's hierarchical JCR node structure into flat, structured JSON schemas. AEM content falls into three categories with very different migration complexity:

- **Content Fragments:** Structured, presentation-agnostic data stored under `/content/dam` with a defined model. These map cleanly to headless CMS document types. Migration involves traversing fragment nodes and mapping properties to the target schema. Complexity: low.
- **Experience Fragments:** Content mixed with layout data (HTML, CSS classes, grid structures) stored under `/content/experience-fragments`. These are the most difficult content type to migrate because headless systems reject presentation logic embedded in content. You must parse the Experience Fragment's `jcr:content` tree, strip `sling:resourceType` layout wrappers, and extract only raw text and asset references. Expect some Experience Fragments to need manual remediation after scripted extraction. Complexity: high.
- **Standard Pages (`cq:Page`):** A hierarchical tree of parsys containers holding components. Migration requires scripts to traverse the `jcr:content` node, identify `sling:resourceType` values (e.g., `weretail/components/content/text`), and map component properties to target schema fields. The challenge is that component property names are arbitrary — `textIsRich`, `fileReference`, `linkURL` — and differ across every implementation. There is no standard mapping. Complexity: medium to high, proportional to the number of distinct component types.

The migration is an ETL problem: extract from AEM, transform to the target's content model, load via the target platform's API. No off-the-shelf connector exists for any non-Adobe CMS. This is always custom migration engineering.

## How to extract data from AEM 6.5

Extracting data from AEM is a specialized engineering task. The JCR is a hierarchical NoSQL datastore — you cannot perform a SQL dump. Data extraction must respect the node tree and handle AEM-specific node types and namespaces.

The four extraction methods, ranked from most to least preferred for cross-platform migrations:

### 1. Sling Model Exporter (preferred for headless migrations)

The **Sling Model Exporter** exposes AEM components as structured JSON via HTTP GET requests ([experienceleague.adobe.com](https://experienceleague.adobe.com/en/docs/experience-manager-learn/foundation/development/develop-sling-model-exporter)). If your AEM implementation uses Sling Models with the `@Exporter` annotation, this is the cleanest extraction path — it returns business data without AEM-specific namespace pollution.

```java
@Model(adaptables = SlingHttpServletRequest.class, 
       resourceType = "my-app/components/custom-article")
@Exporter(name = "jackson", extensions = "json")
public class ArticleComponent {
    @ValueMapValue
    private String title;
    
    @ValueMapValue
    private String bodyText;
    // Getters omitted for brevity
}
```

Migration scripts crawl the AEM site map, request each page with the `.model.json` selector, and ingest clean JSON into the target system. Adobe's Core Components support JSON export, so pages built on them already respond to `.model.json`. Custom components need their own Sling Model with an exporter ([experienceleague.adobe.com](https://experienceleague.adobe.com/en/docs/experience-manager-65/content/implementing/developing/components/json-exporter-components)).

### 2. QueryBuilder API

The **QueryBuilder API** queries the JCR using a predicate-based syntax and returns JSON results from `/bin/querybuilder.json` ([experienceleague.adobe.com](https://experienceleague.adobe.com/en/docs/experience-manager-65/content/implementing/developing/platform/query-builder/querybuilder-api)). It is effective for bulk-extracting specific content types — all news articles, all PDF assets, all pages using a specific template.

Example: find all pages using a specific template, paginated:

```text
path=/content/mysite/en
type=cq:Page
property=jcr:content/cq:template
property.value=/conf/mysite/settings/wcm/templates/article-page
p.limit=100
p.offset=0
```

**Critical warning:** QueryBuilder can trigger full repository traversal if predicates do not resolve to an indexed property. A poorly constructed query against a large repository can badly degrade the AEM author instance. All extraction scripts must page through results with `p.offset` and `p.limit` (the JSON servlet returns ten hits by default), use `p.guessTotal` to avoid counting the full result set, run during off-peak hours, and include rate limiting with delays between requests. Always test against a clone, not production.

### 3. GraphQL API

For Content Fragment-based content models, AEM's **GraphQL API** provides a clean, typed extraction path. AEM 6.5 supports it, and Adobe asks GraphQL users to install its Content Fragment with GraphQL Index Package ([experienceleague.adobe.com](https://experienceleague.adobe.com/en/docs/experience-manager-65/content/assets/extending/graphql-api-content-fragments)). It is also native in AEMaaCS. This is the best option when your content is already structured as fragments with defined models. The GraphQL schema is auto-generated from your Content Fragment models, so queries are type-safe and predictable. Use persisted queries for extraction workloads to avoid URL length limitations and to enable caching.

### 4. Package Manager / FileVault (avoid for cross-platform migrations)

The **Package Manager** exports JCR data as ZIP files containing XML in FileVault format. While this is Adobe's preferred mechanism for moving data between AEM instances, it is the worst option for migrating to any non-Adobe system.

The resulting XML is polluted with AEM-specific namespaces (`jcr:`, `cq:`, `sling:`, `dam:`, `granite:`) and contains binary references, ACL entries, and versioning metadata interleaved with business content. Parsing FileVault XML to extract usable business data requires handling dozens of edge cases and is significantly more error-prone than API-based extraction. Use this method only when no API access is available — for example, if the AEM instance is decommissioned and you're working from a backup.

## Where AEM migrations actually break: a failure taxonomy

The technical documentation describes how migrations should work. This section describes where they fail in practice.

**1. Bundle resolution failures on startup**
A common LTS upgrade failure. After upgrading, the OSGi container attempts to resolve all installed bundles against the new framework. Bundles that import packages AEM no longer ships (for example Guava's `com.google.common` packages, or classes from the removed Abdera and JDOM bundles) fail to resolve and enter a `INSTALLED` (not `ACTIVE`) state. The AEM instance starts but those bundles are non-functional, often silently — components they provide render as blank or return 500 errors. Detection: check the Felix console (`/system/console/bundles`) for bundles in non-ACTIVE state immediately after every upgrade attempt.

**2. Missing asset renditions post-CTT ingestion**
CTT moves assets as they exist in the source repository. If your source instance has not reprocessed assets after a previous AEM upgrade, some renditions may be missing or in an outdated format, and those gaps travel with the migration. Mitigation: run a rendition completeness audit on the source before extraction, and reprocess any asset set with incomplete renditions in Cloud Service after ingestion.

**3. Dispatcher configuration rejections**
Cloud Service validates Dispatcher configuration in the deployment pipeline, and it accepts less than a typical on-premise setup. Configuration it does not support causes pipeline failures. The Dispatcher Converter migrates the structure but cannot fix semantically unsupported directives — these require manual rewriting.

**4. Experience Fragment layout data contaminating headless migrations**
When extracting Experience Fragments for a non-Adobe target, scripted extraction often carries along `sling:resourceType` wrappers, `par` container nodes, and CSS grid class strings as if they were content. The target CMS rejects or silently stores this layout data, and authors later discover that rich text fields contain HTML class strings (`class="responsivegrid aem-GridColumn"`) instead of clean prose. Mitigation: add an explicit stripping step to the ETL pipeline that removes all properties matching AEM layout namespaces before loading to the target.

**5. QueryBuilder queries crashing the author instance**
Extraction scripts that run unthrottled QueryBuilder queries against production author instances can exhaust heap and destabilize the JVM. Unpaginated queries over large result sets are the usual cause. This failure mode is both embarrassing and production-impacting. It happens specifically to teams that test against a small development instance and then run the same script against production without adjusting limits.

**6. IMS user mapping gaps**
CTT does not migrate users to Cloud Service. It migrates groups that appear on ACL or CUG policies of migrated content, and those groups must be recreated in Adobe IMS. Users are created in AEM when they first log in through IMS ([experienceleague.adobe.com](https://experienceleague.adobe.com/en/docs/experience-manager-cloud-service/content/migration-journey/cloud-migration/content-transfer-tool/group-migration)). Adobe flags ACLs that reference users directly as not a recommended practice. If your 6.5 instance relies on locally created author accounts or direct user ACLs, permissions will not carry over as they are. Mitigation: perform a complete user and group inventory and IMS provisioning before running CTT — not after.

## Migrating digital assets and preserving referential integrity

AEM manages assets in the `/content/dam` path. A successful migration must extract the binary files, preserve the metadata (alt text, copyright info, tags, XMP data), and update all internal references before cutover.

When a `cq:Page` references an image, AEM stores the path (e.g., `/content/dam/mysite/images/hero.jpg`). When that asset moves to a new platform — Cloudinary, a headless CMS asset library, or AEMaaCS — the URL changes. All references to the old path must be updated, or the site goes live with broken images.

References to assets appear in three distinct locations that migration scripts must handle separately:

1. **Component property fields** (e.g., `fileReference=/content/dam/...` stored as a JCR property on a component node)
2. **Rich text HTML** (e.g., `<img src="https://clonepartner.com/blog/content/dam/...">` embedded in an HTML string stored in a `text` property)
3. **Content Fragment references** (typed asset references in Fragment models, stored as JCR paths)

All three must be updated. Migrations that only update component properties and miss rich text HTML references produce pages that render correctly in previews but have broken images on specific rich text sections — a failure mode that often isn't caught until post-go-live QA.

The correct process:
1. Upload binaries to the target system and capture the new URL for each asset.
2. Build a reference map: old AEM path → new URL.
3. Apply the reference map to component property fields using string replacement on extracted JSON.
4. Apply the reference map to rich text HTML using a parser (not regex — HTML parsers handle nested attributes correctly; regex misses edge cases).
5. Apply the reference map to Content Fragment references.
6. Run a referential integrity check: scan all migrated content for any remaining `/content/dam/` path strings.

## How long does an AEM 6.5 content migration take?

The answer depends on which clock you're asking about.

**The data migration** — extracting content, assets, and metadata from AEM and loading it into a target system — is what ClonePartner performs. Most migrations are completed within 1–5 business days, depending on data volume, complexity, and API rate limits. Small datasets under 10,000 records can complete in under 24 hours. The bulk load runs during the working days before go-live while your authors keep working in AEM. On go-live Monday, AEM is frozen before the working day starts, a final delta of changed content runs in about 30 minutes, and authors log in to the new platform that morning.

**The re-platforming project** — code refactoring, template rebuilds, Dispatcher conversion, CI/CD setup, identity migration, QA, and cutover — is a separate effort on your own clock. Its timeline is an engineering timeline, not a data migration timeline, and it varies by implementation in ways no vendor can honestly estimate without reviewing your codebase.

Start scoping the data migration well before your internal deadline. That leaves room for a content audit, field-level mapping, sample migrations, referential integrity validation, and a clean cutover plan.

## What to do right now: a decision checklist

1. **Confirm your deployment model.** AMS or on-premise? The deadlines are different, and for AMS, the deadline has already passed.
2. **Run the Best Practices Analyzer.** Install BPA on your 6.5 instance, generate a report, and upload it to Cloud Acceleration Manager. This gives you a concrete inventory of incompatible patterns even if you aren't certain of your destination yet.
3. **Inventory your customizations.** OSGi bundles, custom workflows, Dispatcher rules, third-party integrations. The volume of custom code and the presence of removed APIs (check specifically for imports of bundles the LTS release notes list as removed, such as Guava) is the primary driver of migration effort.
4. **Decide: stay on Adobe or leave?** If staying, determine whether LTS buys enough runway for a proper Cloud Service migration, or whether Cloud Service must be the direct target.
5. **Scope the content migration separately from the code refactoring.** Don't let content transfer block code refactoring, and don't let code refactoring delay your content audit.
6. **Decide on extended support.** If your Cloud Service migration will not complete before February 2027, contact your Adobe account team about extended support pricing. Get the cost and scope in writing before assuming it's available.

> [!NOTE]
> **Don't confuse the upgrade with the migration.** Upgrading to AEM 6.5 LTS is an in-place operation that buys you time. Migrating to Cloud Service, Edge Delivery, or a non-Adobe platform is a project. You can do the first now and plan the second properly — but recognize that LTS is a bridge, not a destination.

## How ClonePartner handles AEM content migrations

We extract content from AEM's JCR repository — pages, Content Fragments, assets, metadata, taxonomies — and load it into the target platform with field-level mapping and referential integrity validation.

**Process:** connect accounts → migration checklist → sample migration → full migration → delta sync. Each project has a dedicated migration engineer. Sample migrations iterate until field mapping is correct at no additional cost. Validation includes checksum verification, record-count parity, and referential integrity checks for asset paths. Delta syncs keep your source operational through cutover.

Security infrastructure: SOC 2 Type II and ISO 27001, independently audited, AES-256 encryption at rest, TLS 1.2+ in transit, GDPR/CCPA/HIPAA safeguards. Staging data purges no later than 30 days after project close.

One fixed price per project, starting at $500. No hourly billing, no change orders.

## What happens if you do nothing?

Running AEM 6.5 past its support dates is a risk decision, not a technical impossibility. The software does not stop working on March 1, 2027. But the risk profile is specific:

- **Security:** CVEs affecting bundled OSGi components (Apache Sling, Apache Felix, Jackrabbit Oak, Lucene) will not be patched. Each unpatched CVE is a potential attack surface in an enterprise CMS that holds customer data, internal content, and publishing credentials.
- **Compliance:** SOC 2, ISO 27001, and HIPAA Security Rule reviews look at how you patch known vulnerabilities, and unpatched, unsupported software is hard to defend in them.
- **API drift:** Adobe's next round of Cloud Service API removals is targeted for March 31, 2027. Each month on 6.5 after that increases the Cloud Service migration effort. The gap is not static — it compounds.
- **Vendor support:** After February 2027, only customers with approved extended support get fixes, and only critical security fixes on SP26.

The February 2027 date separates "Adobe is responsible for patching this" from "you are responsible for everything." The compensating controls required to safely operate unsupported enterprise software — enhanced WAF rules, additional vulnerability scanning, manual patch evaluation, compensating access controls — can cost more in engineering time than the migration they're deferring.

For a framework on operating a CMS past its support date — the specific risk categories, compensating controls, and when the math stops working — see our [risk playbook for running a CMS past end of support](https://clonepartner.com/blog/blog/running-a-cms-past-end-of-support-the-risk-playbook).

> Facing the AEM 6.5 deadline? Book a free 30-minute scoping call with our migration engineers. We'll map your content, identify the extraction method, and give you a fixed-price proposal.
>
> [Talk to us](https://clonepartner.com/talk-to-us?duration=30&utm_source=blog&utm_medium=button&utm_campaign=demo_bookings&utm_content=cta_click&utm_term=demo_button_click)

## Frequently asked questions

### When does AEM 6.5 support end?

AEM 6.5 on Adobe Managed Services reached end of support on August 31, 2026. On-premise core support ends February 28, 2027. Customers with approved extended support get critical security fixes, on Service Pack 26 only, until February 2028.

### What is AEM 6.5 LTS and should I upgrade?

AEM 6.5 LTS (Long-Term Support) is an in-place upgrade that moves your runtime to Java 17 or 21 while keeping your content and code in place. It is the quickest way to clear the February 2027 support deadline without a full re-platforming project.

### Can I migrate AEM 6.5 content to a non-Adobe CMS?

Yes. Content can be extracted from AEM's JCR via Sling Model Exporter, GraphQL API, QueryBuilder API, or Package Manager, then transformed and loaded into any target platform's API. There is no off-the-shelf connector — this is custom migration work.

### How long does an AEM content migration take?

The data migration — extracting and loading content — is usually completed within 1–5 business days, depending on data volume, complexity, and API rate limits. Small datasets under 10,000 records can finish in under 24 hours. The full re-platforming project (code refactoring, testing, CI/CD) is a separate, much longer effort on its own clock.

### What happens if I stay on AEM 6.5 after February 2027?

The software continues to run, but Adobe stops providing security patches, bug fixes, and standard support. Security and compliance audits are likely to flag the unsupported platform, and the API gap to AEM Cloud Service widens with each Adobe release.
