RHEA — EDS Migration Strategy

A repeatable framework for evaluating and executing AEM Edge Delivery Services (EDS) site migrations using RHEA (Reusable High-Efficiency Architecture using AEM EDS) — our core block library and architecture — from candidate validation through measurable gains.

At a Glance

Phase Name Focus Timeline
1 Research Candidate validation 1 week
2 Discovery Block & content audit 1 – 2 weeks
3A Build & Author RHEA development track 4 weeks*
3B CDN / API / Infra Runs in parallel with 3A 4 weeks*
4 Validate & Optimize Measure gains, build playbook 1 week

*Phase 3 is project dependent; 3A and 3B run concurrently.

Phase 1 · Research — Candidate Validation

Goal: Determine if the site is a viable EDS migration target before investing further. Timeline: 1 week

Candidate validation is a single five-question rubric. Rate each question 1–4, sum for a /20 total — a confidence score that indicates how strong an EDS candidate the site is, from poor fit to strong fit.

Is your site a good EDS candidate?
Is your site a content/marketing experience only (no app/portal behavior, no transactional functionality), and does it contain no heavy Java/OSGi backend requirements (front-end-first with lightweight APIs only)? If yes, please proceed and fill out the form. If no, EDS may not be a good candidate — but AEM Site Theme could be.
# Question 1 — Poor fit 4 — Strong fit
Q1 Is the site content/marketing-driven with minimal application logic? App-like / heavily interactive (SPA, search-heavy) Pure content/marketing site
Q2 Is the technical stack lightweight and front-end-oriented? Heavy Java/OSGi backend required Front-end effort only, no deep backend
Q3 Does the editorial model favor lightweight publishing over heavy governance? Formal multi-step approval / heavy governance Instant preview-and-publish is acceptable
Q4 Is there a clear performance problem and a defined success metric? Healthy CWV, no agreed metric Poor CWV + agreed SLA / accessibility target
Q5 Are third-party scripts limited and well-governed? Uncontrolled tag sprawl Few, well-governed scripts
Total / 20

Rating scale: 4 = strong yes / ideal fit · 3 = mostly yes · 2 = mostly no · 1 = clear no.

Recommendation Bands (total /20)

Score Recommendation
≥ 16 Strong candidate — proceed to Phase 2
11–15 Viable with noted risks — proceed to Phase 2 with documented mitigations
≤ 10 Poor candidate — defer until blockers are resolved

Bands are a starting heuristic — tune them as real migration outcomes accumulate (feed back via Phase 4 learnings).

Risk read-out: any question scoring 1–2 is a risk to record in the assessment (with a mitigation or a note on why it's acceptable). The lowest-scoring dimensions are what you carry into Phase 2 scoping.

The full detail for each question is below — use it to anchor each 1–4 rating.

Q1. Is the site content/marketing-driven with minimal application logic?

EDS is purpose-built for content delivery — Adobe targets consistent 100 Lighthouse performance scores for EDS sites. Highly interactive SPAs, search-heavy experiences, or app-like UIs are poor fits. 📄 Source: Adobe Edge Delivery Services documentation

Q2. Is the technical stack lightweight and front-end-oriented?

EDS is a front-end-first model — blocks are built with standard HTML/CSS/JS and authored content, without a heavy Java/OSGi backend. The strongest candidates can be delivered with standard front-end development effort and no deep AEM Java/backend expertise. If the site depends on substantial server-side business logic, custom Java services, or complex backend integrations that can't be reduced to lightweight API calls, traditional AEMCS is the better fit.

Q3. Does the editorial model favor lightweight publishing over heavy governance?

EDS's strength is fast, near-instant publish and go-live with a light editorial workflow — authors preview and publish directly. If the site instead requires formal multi-step approval workflows, staged sign-offs, or heavy CMS-level governance before content can go live, that need points toward traditional AEMCS (with its workflow engine, approval states, and content governance).

Q4. Is there a clear performance problem and a defined success metric?

EDS's primary value is speed, so the strongest candidates have a known performance problem and a measurable target to prove the win. Poor Core Web Vitals ("Needs Improvement" / "Poor") plus an agreed SLA — e.g. reaching the green (LCP ≤ 2.5s, CLS ≤ 0.1, INP ≤ 200ms), closing an accessibility gap toward AbbVie's ≥ 90% Lighthouse accessibility target, or an authoring-efficiency goal — is ideal. A site with already-healthy CWV and no defined metric has little to gain and no way to declare success. CWV has been a Google Search ranking signal since May 2021; reference benchmark: 0.1s faster mobile load ≈ ~8% lift in retail conversions. 📄 Sources: Google Core Web Vitals docs / web.dev; Google/Deloitte "Milliseconds Make Millions" (2019) — verify current availability.

Q5. Are third-party scripts limited and well-governed?

Third-party scripts are the #1 source of performance regression on content sites — each additional third-party domain adds roughly 100ms of DNS + TCP overhead. EDS's performance model assumes strict script governance; uncontrolled tag sprawl (analytics, chat, A/B, ad tags) will erode the gains before launch and often needs a governance plan first. 📄 Source: Web Almanac (HTTP Archive), annual third-party chapter.

Baseline Metrics

Before exiting Phase 1, record current-state metrics. These become the Phase 1 baseline used for comparison in Phase 4 · Validate & Optimize.

Metric Tool Record Here
Core Web Vitals — LCP, CLS, INP (field data) CrUX / PageSpeed Insights
Lighthouse — Performance score (lab) Chrome DevTools / CI
Lighthouse — Accessibility score (lab) Chrome DevTools / CI
Estimated time-to-publish (authoring) Stakeholder interview
Business metrics baseline (engagement, bounce rate — if applicable) Analytics platform

Baseline must be captured before Phase 2 begins. Do not defer to post-deploy.

Phase 1 Output

Brief assessment doc — Candidate Confidence Score (/20), key risks, and the recommendation to proceed or defer. Includes captured baseline metrics.

Phase 2 · Discovery — Block & Content Audit

Goal: Map what exists today to what EDS can support. Timeline: 1 – 2 weeks

# Activity
1 Inventory all current components/blocks
2 Map each to the RHEA core block library — identify coverage gaps
3 Flag blocks requiring additional features vs. full custom builds
4 Assess custom block complexity and estimated dev effort
5 Review designs (if available) for any non-standard patterns
6 Identify integration touchpoints (analytics, DAM, forms, APIs)
7 Define block specifications for custom/extended blocks — identify location of change, i.e., will this feature be part of core offering, or will it be project-specific customization
8 Estimate content migration complexity (volume, structure, assets)
9 Inventory legacy URLs & routes — capture existing paths (e.g. from legacy RouteConfig/CMS) to build the EDS redirect map
10 Capture existing SEO artifacts & GEO — robots.txt, sitemap.xml, llms.txt, JSON-LD, canonical/meta patterns to reproduce on EDS
11 Identify consent/analytics footprint — OneTrust/CCPA, GTM, Adobe Analytics/dataLayer, reCAPTCHA, any third-party tags
12 Note localization scope — locales/languages that require path + index scoping

Phase 2 Output

Block gap analysis, estimated effort by block, migration scope definition, legacy URL/redirect map, SEO & consent inventory.

Phase 3 · Implementation — Parallel Tracks

Goal: Execute the build. Phase 3 splits into two tracks that run in parallel — development/authoring track (3A) and the CDN/API/infrastructure track (3B) — converging at go-live. Timeline: 4 weeks (project dependent)

Phase 3A — Build & Author (RHEA Development Track)

Only includes RHEA-specific activities. Analytics, SLC etc. are part of standard AbbVie development activities that should always be followed.

# Activity Notes
1 Environment setup (code repo, pipeline) Repo from RHEA/boilerplate, AEM Code Sync, aem up local dev, CI/quality gates (ESLint xwalk, Stylelint, Husky, Renovate), Repoless config setup using eds-site-config
2 Universal Editor & authoring setup Content source setup, Edge service cloud configuration updated for config service
3 Configure and extend RHEA core blocks Per-brand theming/tokens where applicable
4 Develop custom blocks per spec (extending RHEA) Build UE models — component-definition / models / filters
5 AEM-CS provisioning (prerequisite) repoinit — content paths, DAM folders, author/approver groups + ACLs, workflow users
6 Indexing / search setup query.yaml via Admin API — include/exclude paths, meta-field mapping; re-index; verify query-index.json
7 Forms / DAM / integrations (as applicable) Adaptive Forms embed, reCAPTCHA, Maps, aem-bootstrap.js path proxying; Content Fragment (GraphQL) + asset-package migration
8 Localization (as applicable) Locale-scoped paths + indexing (avoid hard-coded en)

Phase 3B — CDN / API / Infrastructure (Parallel Track)

Runs alongside 3A so infrastructure and integration work don't block — or get blocked by — RHEA development. Additional AbbVie deployment activities should also be followed.

# Activity Notes
1 Cloudflare — Worker configuration Configure Cloudflare Worker to route Edge Delivery to Cloudflare. Follows step 1 — once zone, record, and applicable domain/subdomains are active
2 Cloudflare — CF-overlay worker (if needed) Content Fragment → HTML rendering for dynamic feeds (e.g. press/events); path mappings + forwardHeaders
3 Security headers / CSP Define CSP + security headers at the edge (not provided by boilerplate)
4 API integration work Endpoints, auth, data contracts for dynamic content

Convergence — Go-Live

  • Both tracks converge for go-live + hypercare window
  • Final cutover (DNS/CDN) coordinated with QA sign-off from 3A
  • Pre-cutover checklist

Phase 3 Output

Live site on EDS (built with RHEA), QA sign-off, CDN/API integration verified, redirects + SEO parity confirmed, performance delta documented.

Phase 4 · Validate & Optimize — Measure Gains, Build the Playbook

Goal: Quantify the wins against baseline and codify what worked into a repeatable playbook. Timeline: 1 week

Metrics to Track (vs. baseline recorded in Phase 1)

Metric What It Measures
Core Web Vitals (LCP, CLS, INP) Real-user performance
Lighthouse — performance + accessibility Lab scores vs. targets
Time-to-publish for content authors Authoring efficiency
Development velocity for block changes Iteration speed
Business metrics (engagement, bounce rate) Outcome impact, as applicable

Process Outputs

  • Learnings doc — what worked, what to do differently next time
  • Updated RHEA block library documentation
  • Runbook for repeating this process on future sites
  • Backlog of optimizations or missed gaps
On this page
h3
true