Piotr MuchaPrincipal Software Engineer FairyDeck EN / PL Discuss your system
Menu

Production case · edrone

Published production experience

Modernizing a marketing automation platform processing up to about 45,000 events per minute.

The migration increased event-processing resilience and created a path for continued modernization without a big-bang rewrite.

~1,000
integrated stores at the time
45k/min
events per minute at peak

01

Replace the scaling bottleneck while the campaigns keep running.

Early event processing used disk files and scaled by adding servers. Traffic spikes exposed reliability limits, while old Symfony applications and tightly coupled Java dependencies made a full rewrite impractical.

The system moved to queue-based processing and scalable workers. In parallel, critical PHP and Java components and e-commerce integrations were modernized in controlled steps.

02

A peak-load problem embedded in two legacy stacks.

Initial state

Files, vertical scaling and difficult dependencies

Event handling relied on disk storage and more servers for capacity. Critical PHP applications used Symfony 2.2/2.3, while Java services were constrained by old framework coupling.

Constraints

Events and campaigns could not disappear during the migration

  • Black Friday produced sudden, high-volume traffic peaks.
  • Event loss could prevent a customer communication from being triggered.
  • PHP and Java applications had to remain operational while dependencies changed.
  • Capacity growth needed to avoid a matching growth in infrastructure cost.

Modernization strategy

Change the event path before rewriting the product

Moving the critical flow to queues addressed reliability and scale directly. Incremental application upgrades then reduced legacy risk without coupling every improvement to one release.

My contribution

Hands-on modernization across event processing and integrations.

My work covered the critical migration path, application modernization and features connected to the e-commerce ecosystem.

Event-processing migration
I worked on moving event handling from files to a queue-based model that could scale through workers.
PHP and Java modernization
I upgraded critical Symfony applications and reduced problematic Java framework coupling without replacing the whole platform.
E-commerce and product features
I improved WordPress, Magento and PrestaShop integrations, built the Shoper integration and delivered marketing automation features.

This case describes my contribution to a larger platform. It does not claim sole authorship of the complete edrone architecture.

Key decisions

Scale the unit of work, not the number of monolithic servers.

The migration isolated event processing as the highest-risk flow and improved it without waiting for every legacy dependency to be replaced.

  1. 01

    Queue event processing

    Queues replaced disk files as the coordination point for reliable, distributable work.

  2. 02

    Scale workers independently

    Capacity could grow through workers instead of duplicating the entire application footprint.

  3. 03

    Upgrade incrementally

    Framework and dependency changes followed controlled paths rather than a single platform rewrite.

Delivery model

A controlled path from the bottleneck to a modernizable platform.

  1. 01

    Identify the loss and scale risks

    Map the file-based flow, peak behavior and downstream campaign triggers before changing coordination.

  2. 02

    Move processing behind queues

    Introduce distributable work and scale the worker pool independently under load.

  3. 03

    Modernize applications around the new path

    Upgrade critical PHP and Java components and harden the integrations feeding the platform.

Verified production evidence

Peak scale without losing the event stream.

45k/min
processed by the marketing automation platform
No event loss
during Black Friday event peaks

The architecture limited the need to add complete servers as event volume grew. No monetary saving is claimed without a verified cost baseline.

What this proves

High-volume modernization across PHP, Java and event-driven systems.

The project demonstrates how to replace a critical scaling mechanism, preserve production behavior and leave a platform easier to modernize in subsequent steps.

Modernizing a critical ERP without stopping sales, purchasing or warehouse operations.

A multi-channel automotive parts wholesaler relied on several undocumented, tightly coupled legacy systems. Instead of rewriting everything at once, I moved complete business processes into auditable domains while keeping sales, purchasing and warehouse operations online.

Normalizing European PSD2 bank integrations for an Account-to-Account platform handling hundreds of thousands of transactions each month.

European banks exposed different APIs, statuses and failure semantics. I implemented integrations that mapped these contracts into one Account-to-Account payment flow with Mutual TLS, certificate handling and explicit behavior for retries, duplicates and ambiguous states.

Your event platform

Does peak traffic expose a reliability or cost limit?

We can map the critical event path, its delivery guarantees and the smallest migration that changes the scaling model safely.

Discuss a high-volume event platform

Back to selected work