Let me paint a picture you’ve probably seen before.
You’re building an e-commerce app. A customer places an order, and your code needs to do a bunch of things: check if the order is valid, charge the card, update inventory, send a confirmation email, generate an invoice. Simple enough, right?
So you write a method that does all of it:
<pre><code>class OrderService
{
 public function process(Order $order): void
 {
 $this-&gt;validate($order);
 $this-&gt;processPayment($order);
 $this-&gt;updateInventory($order);
 $this-&gt;sendEmail($order);
 $this-&gt;generateInvoice($order);
 }
}
</code></pre>
Looks clean at first. But then the business says: “Premium customers get a discount.” So you add an <code>if</code> statement. Then: “International orders need tax calculation.” Another <code>if</code>. Then: “Enterprise clients need approval before payment.” More nesting. Before you know it, that one method is doing everything, and changing one thing risks breaking something else.
This is one of the most common problems in backend development, and Workflow Orchestrator is a PHP library designed to fix it.
<h2>So What Does It Actually Do?</h2>
Think of it like a recipe. Instead of writing all your cooking instructions in one giant paragraph, you break them into steps: chop vegetables, boil water, add pasta, make sauce, plate it. Each step is simple on its own. The recipe just tells you the order.
Workflow Orchestrator works the same way. You define your steps as an array, and each step is its own small method:
<pre><code>// This is the &quot;recipe&quot; — it just lists the steps
#[Orchestrator(channel: &#x27;process.order&#x27;)]
public function processOrder(Order $order): array
{
 return [&#x27;validate&#x27;, &#x27;payment&#x27;, &#x27;inventory&#x27;, &#x27;email&#x27;, &#x27;invoice&#x27;];
}

// This is one step — it does one thing
#[Handler(channel: &#x27;validate&#x27;)]
public function validate(Order $order): Order
{
 if (!$order-&gt;hasItems()) {
 throw new \InvalidArgumentException(&#x27;Order must have items&#x27;);
 }
 return $order;
}

// Another step — also does one thing
#[Handler(channel: &#x27;payment&#x27;)]
public function processPayment(Order $order): Order
{
 $order-&gt;markAsPaid();
 return $order;
}
</code></pre>
The <code>#[Orchestrator]</code> and <code>#[Handler]</code> bits are PHP attributes — they’re labels that tell the library which method is the recipe and which methods are the steps. If you haven’t used attributes before, don’t worry, they’re just a clean way of tagging your methods with metadata.
To run the whole thing:
<pre><code>$orchestrator = WorkflowOrchestrator::create()
 -&gt;register(OrderProcessor::class);

$result = $orchestrator-&gt;execute(&#x27;process.order&#x27;, $order);
</code></pre>
That’s it. Three lines and your workflow runs from start to finish.
<h2>Why Is This Better?</h2>
It’s easy to read. Look at the orchestrator method, you can see the entire business process at a glance. No scrolling through 200 lines to understand what happens when an order is placed.
It’s easy to change. Need to add a discount step for premium customers? Just add it to the array:
<pre><code>#[Orchestrator(channel: &#x27;process.order&#x27;)]
public function processOrder(Order $order): array
{
 $steps = [&#x27;validate&#x27;, &#x27;payment&#x27;];

 if ($order-&gt;getCustomer()-&gt;isPremium()) {
 $steps[] = &#x27;apply-discount&#x27;;
 }

 $steps[] = &#x27;email&#x27;;
 $steps[] = &#x27;invoice&#x27;;

 return $steps;
}
</code></pre>
No tangled <code>if/else</code> chains. You’re just adding a string to an array.
It’s easy to test. Each step is a standalone method. You can test the payment handler without worrying about email sending. You can test validation without touching the database. Small methods mean small, focused tests.
<h2>What About the Advanced Stuff?</h2>
This is where it gets interesting for developers who’ve been around the block.
Async steps. Sending an email shouldn’t hold up the whole order. Mark a step as async and it gets queued for background processing with automatic retry:
<pre><code>#[Handler(channel: &#x27;email&#x27;, async: true)]
public function sendEmail(Order $order): Order { ... }
</code></pre>
Timeouts. Calling a slow external API? Set a time limit so it doesn’t hang forever:
<pre><code>#[Handler(channel: &#x27;call-api&#x27;, timeout: 30)]
public function callApi(Order $order): Order { ... }
</code></pre>
Headers. Need to pass extra information between steps — like a customer’s region or loyalty tier — without stuffing it into your Order object? Headers solve that:
<pre><code>#[Handler(channel: &#x27;enrich-data&#x27;, returnsHeaders: true)]
public function enrichData(Order $order): array
{
 return [&#x27;region&#x27; =&gt; $order-&gt;getShippingAddress()-&gt;getCountry()];
}

#[Handler(channel: &#x27;apply-pricing&#x27;)]
public function applyPricing(Order $order, #[Header(&#x27;region&#x27;)] string $region): Order
{
 // Use the region to calculate pricing
}
</code></pre>
Middleware for things like logging and authorization. Event listeners for metrics and monitoring. Multiple queue backends — in-memory for development, SQLite for simple deployments, Redis for production scale.
And it works with any PSR-11 dependency injection container, so it drops into Laravel, Symfony, or whatever framework you’re using.
<h2>Installing It</h2>
<pre><code>composer require drnasin/workflow-orchestrator
</code></pre>
Requires PHP 8.3 or higher. No other dependencies. MIT licensed.
<h2>Should You Use It?</h2>
Ask yourself: do you have service classes that do too many things in sequence? Business processes that change often and are hard to modify safely? Logic that’s difficult to test because everything is tangled together?
If yes, <a href="https://github.com/drnasin/workflow-orchestrator" target="_blank" rel="noopener nofollow">Workflow Orchestrator</a> might save you some headaches. It’s not a framework, it’s not a state machine, and it won’t take over your codebase. It’s a small tool that does one thing well — it keeps your workflows clean.
Check it out on <a href="https://github.com/drnasin/workflow-orchestrator" target="_blank" rel="noopener nofollow">GitHub</a>, give it a spin, and if it helps you out, leave a star.
<hr>
Workflow Orchestrator is open source and actively maintained. Contributions and feedback are welcome.

Ante

Workflow Orchestrator is a PHP library that breaks complex business processes into discrete, testable steps instead of monolithic methods. It uses PHP attributes to define orchestrators (workflow recipes) and handlers (individual steps), making code easier to read, modify, and test. The library supports async execution, timeouts, headers for passing metadata, middleware, and multiple queue backends. It integrates with PSR-11 containers and works with frameworks like Laravel and Symfony.

Stop Writing Spaghetti Workflows - There's a Better Way (I promise)