It is past midnight in the war room and the homepage is crawling. The dispatcher looks happy. The CDN shows a perfect hit rate. Marketing is sliding a laptop across the table and PageSpeed Insights is yelling in red. We cut a new build on Adobe Experience Manager and the hero image weighs as much as a vinyl record collection. You could brew a coffee in the time it takes the first paint to show. Everyone looks at me like I can pull a rabbit out of Apache.
We tweak client libraries, move analytics to load later, and resize images. We remove a redirect hop between the root and the country selector. The needle jumps from terrible to decent. Not perfect, but enough to sleep tonight. That is the dance with AEM, SEO, page speed, and structure. You spend your time trading nice authoring features for faster pages and clean markup.
What actually makes an AEM page feel fast
On paper, AEM should be fast. You have an author tier that feeds a publish tier. In front you place the dispatcher in Apache or IIS, and usually a CDN in front of that. With a strong cache strategy, your time to first byte can be great. The trouble begins after the first byte. That is where render start, first meaningful paint, and time to interactive live.
Here are the big levers that matter right now:
- Dispatcher rules and TTLs. Cache every page that is not personalized. Push static assets to long time to live with fingerprinted paths. Keep invalidation simple and predictable. One publish click should not flush the world.
- Client libraries. Split your JavaScript and CSS into base and feature sets. Turn on minify. Use defer for scripts that are not needed for first paint. HTTP 2 is common now, so one giant bundle is not the only path. Avoid blocks that force the browser to wait.
- Images. The easiest win. Serve the right size for the device. Use renditions or Dynamic Media presets. Progressive JPEGs at a sane quality beat bloated retina dreams. Add srcset and sizes so the browser can pick. Lazy load below the fold.
- HTML structure. AEM can create a deep nest of divs if you let it. Keep the DOM small. Put main content high in the source. Use real headings. Use nav and main and footer to help crawlers and assistive tech.
- Redirects. One hop or none. Put redirect rules at the web server or CDN. Do not tax the application for vanity routing.
- Analytics and tags. DTM and friends can wait. Fire them asynchronously. Delay chat and widgets until the page feels alive.
On the server side, keep business logic out of HTL. Use Sling Models for data and keep expensive queries out of the request path. Precompute where possible. If a component is doing a JCR query on every render, your cache misses will hurt.
SEO structure that plays nice with AEM
Search bots love clear intent. AEM can either help you nail that or bury it under ten design systems. Make these your non negotiables:
- Canonical URLs. Every page should declare the version you want ranked. AEM link mapping can hide ugly selectors, but your canonical must be stable.
- Sitemaps. Generate XML sitemaps on publish and expose them under robots. Split by language or section if your site is large.
- Hreflang with MSM. If you use language copies or live copies, wire hreflang links so Google understands the family. Keep it consistent between pages.
- Meta basics. Title and description should be obvious fields in every template. Do not bury them in a dialog three tabs deep.
- Structured data. Add JSON LD for articles, products, breadcrumbs. Make it a component so authors can add it without code.
Thinking about single page apps inside AEM? You can do it, but be careful. Crawlers can choke if there is no server rendered markup. If you go that route, add server render or a safe pre render service. Pure client boot with empty HTML is a traffic diet you do not want.
Common traps and the risk behind each one
- Cache misses from personalization. Target offers on the whole page force a pass through the application. That can be fine for key pages, but not for everything. Risk is slow loads during campaigns.
- Redirect chains. Migration projects love to stack old to new to newer. Each hop delays first paint and tests patience. Risk is bleed in authority and higher bounce.
- Giant client libraries. One category that ships everything to every page. Risk is slow first paint and blocking scripts that run before content.
- Expensive queries. A component that searches the whole repository on every request. Risk is publish nodes pegged at full CPU after a cache flush.
- DOM salad. Components inside components inside a layout that adds wrappers everywhere. Risk is heavy pages that jank on scroll.
- CDN staleness. Flush logic that does not touch the right paths. Risk is out of date promotions in prime time.
- Messy hreflang and canonicals. Mixed signals in multi country sites. Risk is wrong page ranking in the wrong market.
- Blocking tags. Synchronous analytics or AB scripts. Risk is empty page while a third party server yawns.
Decision checklist for your AEM and SEO setup
- Dispatcher: Are rules caching all public pages and pushing long TTL for assets with versioned paths?
- CDN: Is it in front of dispatcher with HTTP 2 and compression on, and origin shield set?
- Redirect policy: Do we have a single source of truth for redirects at CDN or web server with no chains?
- Client libraries: Are base CSS and JS minimal and loaded early, with the rest deferred?
- Images: Do we have renditions or Dynamic Media presets and guidance for authors on sizes?
- Templates: Do all templates expose title, description, canonical, and structured data fields?
- Sitemaps and robots: Are sitemaps auto generated on publish and linked in robots?
- International: Are hreflang and canonical rules consistent across language copies and country roots?
- Personalization: Which pages are allowed to skip cache and why? Is that list small?
- Monitoring: Do we track Core Web Vitals style timings with RUM and synthetic tests?
Action items you can start this week
- Run a baseline. Use Lighthouse and WebPageTest on top templates. Keep both mobile and desktop. Save the results to compare later.
- Thin the head. Move non critical scripts to the footer or defer. Make sure CSS above the fold is small. Kill unused libraries.
- Clean your redirects. Export all redirects, find chains, fold them to one step. Enforce a single format for URLs with or without trailing slash and with one host.
- Fix images. Create standard image renditions in DAM. Add srcset to the image component. Lower quality until you cannot tell in a blind test.
- Harden dispatcher. Cache HTML where possible, whitelist selectors you need, and block any extension you do not serve. Add a clear invalidation strategy.
- Set authoring guardrails. Publish a short playbook for editors with real examples. Show the cost of pasting a 3000px PNG into a promo slot.
- Ship structured data. Build a simple component that outputs JSON LD for your main content types and drop it into templates.
- Audit queries. Find components that hit QueryBuilder on every request. Cache their results or precompute.
- Tag manager review. Audit DTM. Remove old tags. Set marketing pixels to fire after the page becomes interactive.
- Watch it live. Add real user monitoring to capture first paint, DOM content loaded, and onload. Alert on regressions.
One last thought. People debate AMP, single page apps, and fancy frameworks. They can help in the right place. But the boring wins still stack the fastest. Small HTML, smart caching, right sized images, and clean redirects. In AEM that means tight client libraries, a dispatcher that serves more than it asks AEM to render, and templates that speak clearly to crawlers. Do that and those late night red numbers turn green without magic.