Category: Magento

Search Engine Optimisation (SEO) for Magento 2 has evolved significantly in 2025. While traditional elements like metadata, canonical tags, and XML sitemaps are still critical, Google’s increased focus on Core Web Vitals, AI-driven search algorithms, and semantic indexing means merchants need to adapt quickly.

This comprehensive checklist, created for Kiwi Commerce, reflects the most important SEO updates for Magento 2 stores in 2025, covering everything from technical health and structured data to multilingual SEO and content strategy.

1. Core Web Vitals (CWV): Now Non-Negotiable

Google introduced Core Web Vitals as ranking factors in 2021, but poor CWV can drastically limit your visibility — especially across mobile search.

Largest Contentful Paint (LCP)

• Target: Under 2.5 seconds

• How to Improve:

  • Optimise hero banners and above-the-fold assets

  • Lazy-load product images

  • Use a high-performance CDN such as Fastly

Interaction to Next Paint (INP)

(Replacing FID)

• Target: Under 200ms

• Fixes:

  • Reduce JavaScript execution time

  • Delay non-essential third-party scripts (chat widgets, review apps)

Cumulative Layout Shift (CLS)

• Target: Under 0.1

• Fixes:

  • Reserve space for fonts and images

  • Prevent layout shifts during load

  • Ensure banners and widgets load predictably

Magento Tip:
Switch to a lightweight frontend such as Hyvä Themes, or significantly optimise Luma using bundling, minification, and critical CSS techniques.

---

2. Canonical Tags & Clean URL Strategy

Duplicate content is a frequent Magento SEO challenge caused by layered navigation, sorting parameters, and pagination.

Best Practices

• Implement rel=”canonical” on products and categories to define the preferred URL

• Enable Magento’s canonical settings:
  Stores → Configuration → Catalog → Search Engine Optimisations

• Avoid indexing filter and sort URLs (e.g., ?dir=asc, ?order=price) using robots.txt or meta robots noindex

Pro Tip:
Use Google Search Console or Screaming Frog to uncover incorrect or conflicting canonical tags.

---

3. Structured Data & Rich Snippets

Google depends heavily on structured data to understand your pages and enhance them with rich results.

Essential Schema Types to Add

• Product (name, SKU, price, image, availability)

• Review / AggregateRating

• BreadcrumbList

• FAQPage for blogs and help centre articles

Implementation Tools

• Magento SEO extensions (Amasty, MageWorx)

• Custom JSON-LD blocks

• Google Rich Results Test & Schema.org validator

Bonus:
Add Organization and Website schema to your homepage to strengthen brand credibility.

---

4. Multilingual & Multi-Region SEO

For Magento stores operating across multiple regions (e.g., .co.uk, .com, .fr), correct hreflang configuration is essential.

Checklist

• Add proper hreflang tags (en-GB, en-US, fr-FR)

• Include an x-default fallback

• Do not auto-redirect based on IP alone; offer a country selector

• Use consistent URLs across store views

• Configure Magento’s URL Options for clarity and stability

---

5. Pagination, Infinite Scroll & SEO

Magento supports pagination natively, but it must be implemented cleanly.

Recommendations

• Use rel=”prev” and rel=”next” (still helpful for some engines)

• Ensure paginated pages have self-referencing canonicals

• Avoid noindexing pagination unless using infinite scroll with JavaScript

If using AJAX infinite loading, ensure content is crawlable through prerendering or progressive enhancement.

---

6. Semantic SEO & AI-Driven Optimisation

Search engines now use advanced AI systems like Google MUM and Gemini to understand context and intent.

Content Strategy

• Create topical clusters, not isolated keyword pages

• Add semantic variations naturally into product/category descriptions

• Include useful sections such as:

  • “Who is this for?”

  • “Why buy this?”

  • “Common questions”

Helpful Tools

• ChatGPT or Claude for semantic enrichment

• SurferSEO, NeuronWriter for NLP scoring

---

7. Indexing, Crawling & Robots.txt Control

Magento sites require careful control over what should and shouldn’t be crawled.

Recommended robots.txt Rules

• Ensure CSS, JS, and media are not blocked

• Submit updated sitemaps in Google Search Console

• Use meta robots noindex for layered navigation instead of blocking globally

---

8. Sitemap Optimisation

Magento can auto-generate sitemaps, but they must be refined for indexing efficiency.

Checklist

• Enable Product, Category, and CMS Page sitemaps individually

• Exclude non-indexable or duplicate URLs

• Set logical priority and frequency

  • Homepage: daily, priority 1.0

• Submit to Google and Bing Webmaster Tools

---

9. Voice Search & Conversational Intent

Voice search continues to grow across mobile and smart devices.

Optimise by:

• Adding FAQs marked up with FAQPage schema

• Writing naturally, not keyword-stuffed

• Including clear answers under descriptive subheadings

Examples of voice queries:

• “What is the best tumble dryer under £300?”

• “How do I choose the right size TV?”

---

10. Image Optimisation & WebP Support

Fast image delivery is vital for UX, conversion, and Core Web Vitals.

Magento Recommendations

• Enable WebP via extensions or server-level optimisation

• Lazy-load images below the fold

• Compress assets with TinyPNG, ImageMagick, or equivalent tools

Conclusion

Magento 2 SEO in 2025 is no longer about stuffing keywords into product descriptions. It’s about technical excellence, semantic precision, and performance-first experiences. Follow this checklist, created by Kiwi Commerce, to future-proof your SEO and stay ahead of competitors in search rankings.

 

Adobe Optimizer (powered by Adobe Target) enables A/B testing, multivariate
testing, and AI-driven personalisation in Magento 2 (Adobe Commerce). It integrates
seamlessly to deliver targeted content, optimize conversions, and test UX elements
without disrupting core operations.
Key Capabilities
➔ A/B/n Testing: Compare page variants.
➔ Automated Personalisation: AI-driven content targeting.
➔ Visual Experience Composer (VEC): Edit pages visually.
➔ Server-Side Delivery: Reduce client-side flicker.
➔ Magento Data Layer: Leverage cart and checkout data for targeted
advertising.
Prerequisites
Before integrating Adobe Optimizer with Magento 2:

• Adobe Experience Cloud Setup
  ➔ Ensure your organisation has an active Adobe Experience Cloud
  account.
  ➔ Access to Adobe Launch (Tag Manager).
  ➔ Adobe Optimizer workspace and API credentials.
• Magento 2 Requirements
  ➔ Adobe Commerce (Magento 2.4. x)
  ➔ Access to Magento Admin and developer tools (CLI, code access).
  ➔ Frontend theme access (for injecting scripts).

Core Architecture
Adobe Optimizer operates through a hybrid architecture combining:
➔ Client-Side (AT.js): For DOM manipulation and quick implementation
➔ Server-Side (Node.js/PHP SDK): For zero-flicker experiences
➔ Edge Network: Global CDN for low-latency decision-making

Architectural Flow

Setup & Configuration
Step 1: Install Adobe Commerce Extension
composer require magento/target-rule
bin/magento module:enable Magento_TargetRule
bin/magento setup:upgrade

Step 2: Configure Credentials
{
“client_code”: “your_adobe_client_code”,
“organization_id”: “IMS_ORG_ID”,
“workspace”: “default”,
“server_side”: true // Enable server-side delivery
}

Step 3: Inject Target SDK in Theme
Edit app/design/frontend///requirejs-config.js:
var config = {
paths: {
‘adobe-target’: ‘https://assets.adobedtm.com/activation’
},
shim: {
‘adobe-target’: { ‘exports’: ‘adobeData’ }
}
};

Creating an A/B Test: Code Example
Scenario: Test two checkout button colours.
Step 1: Define Activities in Adobe Target UI
➔ Create Experience A (Green Button) & Experience B (Blue Button).

Step 2: Add Target Logic in Magento Template
File:
app/design/frontend///Magento_Checkout/templates/cart
.phtml

helper(‘Magento\TargetRule\Helper\Data’)->isEnabled()): ?> Proceed to Checkout

Step 3: Server-Side Rendering (Advanced)
Use Magento’s PagePlugin to inject content:
// Plugin to modify block output
class RenderTargetContent
{
public function afterToHtml(
\Magento\Checkout\Block\Cart $subject,
$result
) {
$targetContent =
$this->targetService->applyContent(‘checkout-btn-test’);
return str_replace(‘btn-default’, $targetContent,
$result);
}
}

Tracking & Metrics
➔ Conversion Goals: Track via Magento events:
➔ View Reports: Real-time analytics in Adobe Target dashboard.
document.querySelector(‘#checkout-button’).addEventListener(‘click
‘, function() {
adobe.target.trackEvent({
mbox: ‘checkout-click’,
conversion: true
});
});

Best Practices
➔ Avoid Flicker: Use server-side delivery or pre-hiding snippets.
➔ Leverage Magento Context: Pass SKU, category, and cart value to Target:
adobe.target.getOffer({
params: {
“cartTotal”: “getCartTotal() ?>”,
“customerGroup”: “getCustomerGroup() ?>”
}
});
➔ Cache Considerations: Exclude personalised blocks from full-page cache.
➔ QA with AT.js Debugger: Use Chrome extension for validation.

Key Performance Indicators

Metric Baseline Target Measurement
Personalization ROI 0.1 5:1 Adobe Analytics
Time-to-Decision 300ms <50ms Chrome DevTools Offer Cache Hit Rate 0% >85% Target Reports
Test Velocity 2/month 10/week Activity Log
Lift Significance N/A >95% Stats Engine

Troubleshooting
➔ Common Error: Offers not rendering?
◆ Verify IMS credentials in Admin.
◆ Check the browser console for adobe.target errors.
➔ Missing Data Layer: Ensure Magento\TargetRule\Block\Data is included
in the layout.

Conclusion
Adobe Optimizer transforms Magento 2 into a testing/personalisation powerhouse.
By combining server-side logic with client-side flexibility, developers can deploy
experiments without compromising performance. Start with simple A/B tests, then
scale to AI-driven personalisation using Magento’s rich e-commerce data layer.

In today’s fast-paced digital world, applications need to process massive amounts of data, handle millions
of requests, and scale seamlessly. One of the unsung heroes that makes this possible is the Message
Queue (MQ).

At Kiwicommerce, our Magento development services integrate seamlessly with MQ technology, helping eCommerce stores manage large order volumes, synchronize inventory in real time, and deliver a smooth shopping experience even during peak traffic.

What is a Message Queue?
A message queue is a communication method that allows different parts of a system (or even different
applications) to talk to each other asynchronously. Instead of sending requests directly, one system puts a
“message” into a queue, and another system picks it up whenever it’s ready.

Think of it as a post office:
You drop a letter (message) in the mailbox (queue).
The recipient (consumer) collects it when they’re ready.
This way, you don’t have to wait until they’re free you just trust the mailbox to hold it safely.

Why Use a Message Queue?
✅ Asynchronous Processing – Tasks don’t have to finish instantly. ✅ Decoupling – Producers and consumers are independent. ✅ Scalability – Add more consumers to handle high traffic.
✅ Reliability – Messages aren’t lost if a system crashes.

How Does a Message Queue Work?

1. Producer – sends a message to the queue.
2. Queue – stores the message temporarily.
3. Consumer – retrieves and processes the message.

Popular Message Queue Systems
RabbitMQ – widely used, feature-rich, and open-source.
Apache Kafka – designed for high-throughput event streaming.
Amazon SQS – fully managed queueing service on AWS.
Azure Service Bus – Microsoft’s enterprise-grade queueing system.

Real-World Use Cases
E-commerce: Handling orders and inventory updates.
Banking: Processing transactions securely.
Social Media: Delivering notifications and messages.
IoT: Managing millions of sensor readings from devices.

Technical Examples
🔹 Example 2: Kafka with Node.js
Producer (producer.js):
const { Kafka } = require(“kafkajs”);
const kafka = new Kafka({
clientId: “my-app”,
brokers: [“localhost:9092”],
});
const producer = kafka.producer();
const run = async () => {
await producer.connect();
await producer.send({
topic: “test-topic”,
messages: [{ value: “Hello Kafka!” }],
});
console.log(“✅ Message sent to Kafka”);
await producer.disconnect();
};
run().catch(console.error);
Consumer (consumer.js):
const { Kafka } = require(“kafkajs”);
const kafka = new Kafka({
clientId: “my-app”,
brokers: [“localhost:9092”],
});
const consumer = kafka.consumer({ groupId: “test-group” });
const run = async () => {
await consumer.connect();
await consumer.subscribe({ topic: “test-topic”, fromBeginning: true });
await consumer.run({
eachMessage: async ({ topic, partition, message }) => {
console.log(📩 Received: ${message.value.toString()});
},
});
};
run().catch(console.error);

Final Thoughts
Message queues are a crucial part of modern software architecture, especially in systems that need to
handle large amounts of data, high traffic, or multiple services working together.

Whether you’re building a simple app with RabbitMQ or managing real-time event streams with
Kafka, message queues help you create systems that are scalable, reliable, and efficient.

Discover how Kiwicommerce can help scale your business connect with us.