If QQS + Buffer Entry is the “warehouse staging area”, the Batch Output Connector is the “truck”.

Instead of calling a connector once per object, it can:

• take a list of objects
• package them into a connector request
• send them in one call
• handle a response that contains success/error per item

A typical config looks like:

{
  "id": "batch_out",
  "type": "Qilin.BatchOutputConnector",
  "config": {
    "outputConnectorId": "connector-guid",
    "domainName": "Offer",
    "objectTypePath": "$.FlowObjectContents.entry.objectType",
    "objectIdsPath": "$.FlowObjectContents.entry.objectIds",
    "objectBodiesPath": "$.FlowObjectContents.entry.objectData"
  }
}

When paired with buffering, this gives you classic enterprise integration behavior:

• fewer HTTP calls
• better throughput control
• reduced connector overhead
• easier handling of platform quotas and rate limits

The next problem: not every object should go to the same place.

You might need to route by:

• marketplace
• storefront
• country
• product category
• pricing strategy
• stock availability
• compliance rules

In the old world, routing becomes a pile of nested if-statements.

In Qilin, the Switch-Case Processor gives you a structured approach:

• each outgoing connection can define a condition (Filter Predicate)
• Qilin activates the first matching case
• a default route can catch everything else

A simplified mental model:

• if case A matches → follow path A
• else if case B matches → follow path B
• else → follow default

This is the “switch statement” you already know – adapted to pipeline routing.

Multi-conditions are the difference between:

• “we can build a demo”
• and “we can build policies”

Because real routing often looks like:

• If it’s a hazardous material AND destination is EU → route to compliance enrichment
• If it’s a luxury brand AND price is missing → stop and alert
• If it’s marketplace X AND stock < 5 → route to low-stock strategy

Switch-case lets you express this cleanly, reuse it, and review it.

• batching reduces connector chatter and failure surfaces
• switch-case reduces custom code and makes routing auditable
• both are pipeline-native, meaning you get tracking, logs, and consistent error behavior

• Merchants: faster, more stable syncs—especially for high-volume catalog/offer updates
• Agencies: cleaner architectures and reusable routing templates across clients
• Investors: this is platform maturity that increases addressable use cases and lowers delivery cost

In September, we’ll shift from routing and batching into a different kind of control:

time.

Scheduling is a core part of integration work, and Qilin is adding pipeline primitives for time-based triggering and notifications.

Batches make shipping efficient.

Switch-case makes shipping intelligent.

Qilin.Cloud is building both—so your integrations can grow in volume and complexity without growing in chaos.

A Filter Predicate is a structured condition that can evaluate a value inside your pipeline’s execution context.

At the core, it’s three things:

• operator: what comparison to perform
• path: where to read the value from (JSONPath)
• value: what to compare against (raw value or another path)

Supported operators include:

`eq`, `ne`, `gt`, `gte`, `lt`, `lte`, `contains`, `startsWith`, `endsWith`, `in`, `nin`, `exists`

So yes—this is the battle-tested stuff you’ve been writing by hand for years, made explicit and portable.

Most real-world rules aren’t a single comparison; they’re combinations.

That’s why Qilin predicates can be composed via a PredicateContainer that supports:

• AND: all sub-predicates must match
• OR: at least one sub-predicate must match

That gives you readable, versionable logic without building a tiny programming language in your own codebase (because nobody deserves that fate twice).

Let’s say you only want to sync offers that are:

• active
• in the EU region
• stock > 0

A predicate container could look like this:

{
  "operator": "and",
  "subPredicates": [
    { "operator": "eq", "path": "$.FlowObjectContents.entry.status", "value": { "raw": "active" } },
    { "operator": "in", "path": "$.FlowObjectContents.entry.region", "value": { "raw": ["DE", "AT", "NL", "BE"] } },
    { "operator": "gt", "path": "$.FlowObjectContents.entry.stock", "value": { "raw": 0 } }
  ]
}

Now that rule can power multiple things:

• a filtering processor (“stop the branch if it doesn’t match”)
• a condition processor (“route to path A if true, B if false”)
• a switch-case processor (“route to the first matching case, or default”)

Same rule. Different execution semantics. Less duplication.

1) Qilin Object Filtering Processor

This processor filters based on the FlowObjectContent and a configured object type path. If the predicate fails, the branch stops – cleanly.

Example (simplified):

{
 "type": "Qilin.QilinObjectFiltering",
 "config": {
  "rules": {
   "order": {
    "name": "Only orders from Shopee",
    "predicate": {
     "operator": "contains",
     "path": "$.marketplaceName.en-GB",
     "value": { "raw": "Shopee" }
    }
   }
  },
  "ObjectTypePath": "$.FlowObjectAttributes.entry.objectType"
 }
}

2) Condition Processor

Same predicate idea, but different behavior: it doesn’t “stop”; it directs flow. Connections out of the processor declare what they expect (`true` or `false`), and Qilin activates the matching paths.

3) Switch-Case Processor

This is routing for grown-ups.

Each connection can contain a predicate condition, and Qilin will activate the matching case – plus a default connection when nothing matches.

For developers

• No more hard-coded routing rules in one-off services.
• Rules become configuration you can store, diff, review, and roll back.
• JSONPath gives you power without forcing you to write custom selectors.
• Shared logic across processors means fewer subtle inconsistencies.

For businesses (merchants + agencies)

• Filtering rules are visible and explainable.
• Agencies can build reusable “policy packs” for clients (e.g., compliance, pricing strategy, catalog hygiene).
• Merchants get safer automations: fewer accidental pushes of incomplete or forbidden data.

For investors

This is the kind of “boring feature” that scales revenue: it reduces implementation cost per customer and makes the platform more composable.

Rules are only half the story.

Next month, we’ll talk about something just as foundational: secure access. Specifically, how Qilin.Cloud is evolving API keys, roles, and permissions so teams can collaborate without handing out “master keys” to everything.

If you’ve ever said “just add another if-statement” – and then regretted it six months later – Filter Predicates are your new best friend.

They keep your logic explicit, reusable, and tame.