E-Commerce Platform: Strangler Pattern Migration

The Strangler Pattern Solution

The architecture implements the Symfony strangler pattern through complete interface abstraction. Named after strangler fig trees that germinate in tree canopies and eventually replace their hosts, this pattern allows new systems to grow around legacy systems, gradually assuming responsibilities until the legacy system can be removed.

The core architectural decision was interface-driven abstraction. Every backend operation exposes an interface defining its contract, with concrete implementations containing the actual API calls. Controllers depend only on interfaces. Backends swap through dependency injection configuration changes rather than code modifications.

The authentication layer shows the strangler pattern in action. The custom Symfony Security authenticator bridges modern authentication patterns with Magento's legacy session cookies. The interface abstraction means we can switch to Sylius authentication without touching the authenticator itself.

Token caching implements sophisticated performance optimisation. Sylius JWT tokens expire after 60 minutes, so the architecture caches them for 59minutes, refreshing before expiry whilst maintaining security. Authentication overhead drops from potentially hundreds of requests per session to a single request per hour. An order-of-magnitude performance improvement for distributed architectures.

Cross-system context preservation proved essential for background job processing. When a customer triggers an action dispatched to Symfony Messenger for background processing, the message handler runs in a different context without access to the original request's session, cookies, or environment details. Custom Messenger middleware captures context during dispatch (Magento URL, currency settings) and restores it during consumption, ensuring background processes operate with the same configuration as the original request.

NOT COOKIE CUTTER Decisions

This project made several decisions diverging from standard approaches, each justified by project constraints and business requirements.

Interface Markers for Cross-Cutting Concerns

Trading operations require availability checking before execution (preventing customers from attempting trades during maintenance windows or system failures). But implementing explicit checks in every controller method creates duplication and risks inconsistent enforcement where forgotten checks create vulnerabilities. The solution? Empty marker interfaces, enabling declarative behaviour with zero boilerplate.

Live Components Over Custom API Endpoints

Traditional reactive frontends implement custom API endpoints returning JSON, with frontend JavaScript managing state updates. This duplicates logic between API response formatting and HTML rendering. It creates state synchronisation complexity. It risks divergence between client and server rendering.

Symfony UX Live Components eliminate these issues by rendering entirely server-side. Components receive events. They execute business logic server-side using the same services as traditional requests. They render templates using the same Twig templates. They return HTML. The framework handles communication transparently.

Visible Timer vs Silent Polling

Trading interfaces typically implement invisible background price polling with no customer visibility into data freshness. This creates uncertainty. Customers cannot assess whether prices are current. They hesitate to trade due to uncertainty about price currency. They develop false confidence in stale data.

The visible countdown timer sets clear expectations (you have exactly this much time before refresh). It builds trust through transparency (we're showing you when data will refresh). It maintains data freshness (prices remain current within this interval). The automatic cancellation mechanism prevents stale submissions even if customers click submit just before expiry. Zero stale trades processed.

This pattern transfers to any time-sensitive application where stale data presents business risk: stock trading platforms requiring current market prices, auction systems with time-limited bids, limited inventory booking where availability changes rapidly, and currency exchange applications with fluctuating rates.

Key Learnings

Strangler Pattern Requires Complete Abstraction

Partial abstraction fails catastrophically. Every backend operation must expose an interface (not just "important" ones). Cookie management must be centralised (scattered cookie handling creates debugging nightmares). Authentication must work through dependency injection (hardcoded authentication calls can't be replaced). Any direct coupling to legacy systems creates migration blockers requiring code changes when you need configuration changes. The 240 API integration files (110 interfaces, 110 implementations) show the discipline required.

Progressive Enhancement Isn't Just Accessibility

Server-side authority prevents duplicate business logic (no divergence between client and server calculations). It simplifies testing (base functionality testable without browser automation requiring Playwright or Cypress). It reduces JavaScript complexity (no complex state management libraries needed). It maintains SEO and accessibility (search engines see content, screen readers work perfectly). The 2% of purchases without JavaScript validates the approach's practical benefits, not theoretical ones.

Context Preservation in Async Operations

Background jobs lose request context automatically (session, cookies, environment details vanish in worker processes). Explicit parameter passing for context creates bloated message payloads and risks forgotten parameters creating subtle bugs. Custom Messenger middleware capturing context during dispatch and restoring during consumption proved essential for maintaining session continuity across Magento's cookie-based sessions and multi-currency pricing calculations requiring environment-specific configuration.

Visible State Builds Trust

The visible countdown timer for price refresh sets clear customer expectations (you have exactly 30 seconds before prices refresh). It builds confidence through transparency. Silent background updates create uncertainty where customers don't know if prices are current or stale. Transparency about data freshness proved more valuable than hiding implementation details. This isn't just good UX. It's risk reduction preventing stale price submissions.

Token Caching is Performance Critical

Caching JWT tokens for 59 minutes (one minute before 60-minute expiry) reduced authentication overhead from hundreds of requests per session to one per hour. This represents order-of-magnitude performance improvement for distributed architectures coordinating multiple authenticated APIs. The one-minute buffer ensures tokens refresh before expiry whilst maintaining security (tokens never cache after expiry).

Interface Markers Enable Declarative Behaviour

Empty marker interfaces using PHP's type system for semantics proved cleaner than attribute-based approaches or explicit method calls. Controllers declare their nature through interface implementation (TradingInterface). Event subscribers detect through instanceof checks (type-safe). The pattern delivers zero boilerplate (just the interface declaration). This approach suits any cross-cutting concern enforced across multiple controllers: feature flags, logging, rate limiting, permission checking.