Comparing the Sequential Lot and the Open Green for Draft Sequencing

Every draft sequencing workflow eventually faces a fork: do you process items one by one in a fixed order, or do you keep a flexible pool of candidates open for selection? The choice between a Sequential Lot and an Open Green shapes how teams prioritize, review, and adapt. This guide compares both approaches at a conceptual level, focusing on workflow mechanics, hidden costs, and the scenarios where each method shines or stumbles.

Where the Fork Appears in Real Work

Imagine a team that manages a queue of draft documents—proposals, design briefs, or editorial pieces. Each item needs a sequence of reviews, approvals, or edits. The Sequential Lot treats this queue like a conveyor belt: items enter in order, and each step must complete before the next begins. The Open Green, by contrast, keeps a pool of items that are ready for the next stage, and anyone can pull from the pool as capacity allows.

In practice, these patterns appear in contexts as varied as content calendars, software feature backlogs, and legal document review. A team using Sequential Lot might assign a single editor to work through a list of articles from top to bottom. An Open Green team might maintain a shared board where any available reviewer picks the next item that meets readiness criteria.

The fork is not just about preference—it reflects assumptions about predictability, resource allocation, and the nature of the work itself. Sequential Lot assumes that order matters and that each item has a known, stable processing time. Open Green assumes that flexibility and parallel processing are more valuable than strict order.

Teams often default to one method based on habit or tooling. A project management tool that enforces a linear kanban lane nudges users toward Sequential Lot. A collaborative spreadsheet with shared status columns encourages Open Green. Recognizing which pattern you're actually using is the first step to evaluating whether it fits your work.

We've seen teams switch mid-project, only to hit confusion because roles and handoffs were built around the original pattern. The key is to understand the trade-offs before you commit to a tool or workflow.

Typical Scenarios for Each Pattern

Sequential Lot fits workflows where dependencies are tight: a document that must be fact-checked before it can be edited, or a design that needs legal sign-off before production. Open Green suits environments where items are independent and reviewers have varied specialties.

How Tooling Reinforces the Pattern

Kanban boards with explicit WIP limits can support either pattern, but the default settings often bias one way. Understanding your tool's assumptions helps you avoid fighting the system.

Foundations Readers Confuse

A common misunderstanding is that Sequential Lot and Open Green are just different views of the same queue. In reality, they enforce different rules about when an item can move forward. Sequential Lot gates progression based on completion of the previous item; Open Green gates based on item readiness and resource availability.

Another confusion: equating Open Green with 'no process.' Open Green still requires clear criteria for what 'ready' means, and it demands visibility into who is available to pick up work. Without those, it devolves into chaos. Sequential Lot, on the other hand, is often mistaken for 'simpler' because it reduces decision points. But simplicity in ordering can hide complexity in handling exceptions—what happens when an urgent item arrives mid-sequence?

Some teams conflate Sequential Lot with 'batch processing' (doing multiple items at once in a fixed order) and Open Green with 'single-piece flow.' But batching is a separate dimension: you can batch within either pattern. The core distinction is whether the next item is determined by position in a list or by selection from a pool.

We also see confusion around the term 'lot.' In manufacturing, a lot is a group of items processed together. Here, Sequential Lot means items are processed one at a time in a predetermined sequence, but the term 'lot' emphasizes that the set is fixed at the start. Open Green literally means the signal to proceed is open—any ready item can go.

Finally, people often assume that one pattern is inherently more efficient. Efficiency depends on variability in processing times, cost of changing order, and the value of early completion for certain items. A hospital triage system, for instance, uses a form of Open Green (most urgent first) rather than Sequential Lot (arrival order).

Why Order Matters More Than You Think

In Sequential Lot, the order is the plan. Changing it mid-stream requires renegotiating the sequence, which adds overhead. In Open Green, order emerges from selection criteria, which can be adjusted without breaking the workflow.

The Role of WIP Limits

Work-in-progress limits interact differently with each pattern. Sequential Lot naturally limits WIP to one item per lane. Open Green requires explicit WIP limits to prevent overload.

Patterns That Usually Work

Through observing many teams, we've identified patterns that tend to succeed with each approach. For Sequential Lot, the most reliable pattern is to use it for work that has low variability in processing time and clear dependencies. For example, a content team that publishes a weekly newsletter with fixed sections: each article must be written, edited, and approved in a set order. The sequential lot keeps the pipeline predictable.

For Open Green, the winning pattern is to combine it with a 'pull' system and clear definition of ready. A team of designers working on independent landing pages can each pull the next item from a prioritized pool. The key is that the pool is continuously refreshed and items are independent.

Another effective pattern is hybrid: use Sequential Lot for the first few steps (where order is critical) and Open Green for later steps (where flexibility helps). For instance, a legal document might need sequential review by senior counsel first, then can be picked up by any available junior for formatting.

We've also seen success with time-boxed lots: process a sequential batch for a fixed period (say, one hour), then open the green for the rest of the day. This balances predictability with responsiveness.

Finally, teams that explicitly define 'done' for each step and have a visible board tend to make either pattern work. The pattern itself is less important than the discipline around handoffs.

Setting Up a Sequential Lot That Works

Start by mapping the exact sequence of steps for a typical item. Identify any steps that could be parallelized—those are candidates for Open Green later. Then enforce the order strictly for the first few cycles, and measure cycle time.

Setting Up an Open Green That Works

Define 'ready' criteria for each stage. Create a visible pool (e.g., a column on a board). Ensure each team member knows how to select the next item—by priority, by skill match, or by oldest first.

Anti-Patterns and Why Teams Revert

One common anti-pattern is applying Sequential Lot to work with highly variable processing times. If one item takes ten times longer than expected, the entire queue stalls. Teams then revert to Open Green out of frustration, but without readiness criteria, the new system feels chaotic.

Another anti-pattern: using Open Green without any prioritization. When everyone picks whatever they like, high-value items may languish while easy items get done. Teams revert to Sequential Lot to force order, but they lose flexibility.

We've also seen teams switch patterns mid-stream without updating their tooling or roles. A board designed for Sequential Lot (with strict lane order) gets used as an Open Green, leading to confusion about what 'next' means. Reverting to the original pattern often feels like relief, but the underlying mismatch remains.

Another revert trigger is when a new team member joins. If the pattern is not documented, the newcomer follows their own habit, creating inconsistency. The team then blames the pattern rather than the lack of onboarding.

Finally, teams often abandon a pattern when they hit a bottleneck that the pattern exposes. For example, Sequential Lot reveals that a particular review step is too slow, but instead of fixing the step, the team switches to Open Green, which just moves the bottleneck elsewhere.

The 'One Size Fits All' Trap

Assuming the same pattern works for all stages of a workflow is a mistake. The early stages might need sequential control, while later stages benefit from open pull.

Ignoring Feedback Loops

Both patterns need feedback on cycle time and quality. Without measuring, teams can't tell if the pattern is helping or hurting.

Maintenance, Drift, or Long-Term Costs

Every workflow pattern incurs maintenance costs over time. For Sequential Lot, the main cost is the effort to maintain the sequence. As new items arrive, the team must decide where to insert them. If the sequence is rigid, this causes friction; if it's flexible, the sequence loses meaning.

For Open Green, the cost is in maintaining the pool and readiness criteria. Over time, criteria drift—items that were once 'ready' may not be reviewed for completeness. The pool becomes a dumping ground. Teams then spend time grooming it, which feels like overhead.

Another long-term cost is skill erosion. In Sequential Lot, each team member may only work on a narrow part of the sequence, reducing cross-training. In Open Green, team members might cherry-pick tasks they already know, avoiding growth opportunities.

Drift also happens when tools are updated. A new version of a project management tool might change how columns work, subtly altering the pattern. Teams often don't notice until the workflow breaks.

Finally, both patterns require periodic review. We recommend a quarterly retrospective focused on the workflow pattern itself, not just the outcomes. Ask: Is the pattern still serving us? Are we following it consistently?

How to Audit Your Pattern

Map your actual workflow (not the ideal) for a week. Compare it to the intended pattern. Identify deviations and decide if they are improvements or drift.

Cost of Switching Patterns

Switching from one pattern to another is not free. It requires retraining, tool reconfiguration, and a period of lower throughput. Weigh this cost against the expected benefit.

When Not to Use This Approach

Sequential Lot is a poor fit when work items have highly unpredictable durations or when the order of completion matters more than the order of start. For example, a customer support ticket system where urgent issues must skip the queue—Sequential Lot would fail. Similarly, Open Green is a poor fit when there are strict regulatory or dependency orders that must be followed precisely.

Another situation to avoid Sequential Lot is when the team is distributed across time zones and handoffs happen asynchronously. The strict order can cause delays as each step waits for the previous person to finish, even if others are idle. Open Green can help, but only if the team has clear communication about what's available.

Avoid Open Green when the team lacks discipline to update statuses regularly. Without accurate status, the pool becomes unreliable, and people waste time checking what's actually ready.

Also avoid either pattern if the work itself is not well understood. If you don't know the steps or the criteria for readiness, no pattern will save you. First, define the process, then choose the pattern.

Finally, if the team is very small (one or two people), the distinction between patterns may be irrelevant. In that case, focus on clear prioritization rather than workflow structure.

Signs You're Using the Wrong Pattern

Frequent expedite requests, constant reprioritization, or long idle times are signs that the pattern is fighting the work.

When to Consider a Custom Hybrid

If your work has both sequential dependencies and independent tasks, design a hybrid that uses Sequential Lot for the dependent chain and Open Green for parallel steps.

Open Questions and FAQ

Can I use both patterns at the same time? Yes, many teams use a sequential lot for the initial stages (e.g., drafting and fact-checking) and an open green for later stages (e.g., design and formatting). The key is to define the handoff point clearly.

How do I decide which pattern to start with? Start by listing your work items and their dependencies. If most items depend on the previous one, start with Sequential Lot. If items are independent, start with Open Green. You can always adjust.

What if my team resists the pattern? Resistance often comes from lack of understanding. Run a short experiment (two weeks) with one pattern, measure the results, and discuss. Let the data guide the decision.

Does the pattern affect quality? Indirectly, yes. Sequential Lot can lead to rushed work if the sequence is too tight. Open Green can lead to uneven quality if items are picked by skill rather than need. Monitor quality metrics separately.

How often should I revisit the pattern? At least quarterly, or whenever there is a significant change in team size, work type, or tooling.

Is one pattern more 'agile' than the other? Neither is inherently agile. Agile is about responding to change; Open Green allows more flexibility in ordering, but Sequential Lot can be agile if the sequence is short and frequently replanned.

What about tools like Jira or Trello? Both can support either pattern with proper configuration. Jira's board columns can enforce a sequential workflow, while Trello's swimlanes can facilitate an open pool. The pattern is in the process, not the tool.

Common Misconceptions

One misconception is that Open Green always leads to faster throughput. In reality, if items have dependencies, Open Green can cause rework because later steps may reveal issues that should have been caught earlier.

Further Reading

Look into concepts from lean manufacturing and kanban, which heavily influenced these patterns. The ideas of 'pull' vs 'push' and 'flow' are directly relevant.

Summary and Next Experiments

Sequential Lot and Open Green are two fundamental patterns for sequencing work. Sequential Lot offers predictability and order at the cost of flexibility. Open Green offers flexibility and parallelism at the cost of coordination overhead. Neither is universally better; the right choice depends on your work's dependency structure, variability, and team dynamics.

To move forward, try these three experiments:

1. Map your current workflow for one week. Identify which pattern you are actually using and where it causes friction.
2. Run a two-week trial of the opposite pattern on a small subset of work. Compare cycle time, quality, and team satisfaction.
3. Design a hybrid that uses Sequential Lot for the first two steps and Open Green for the rest. Measure whether handoffs improve.

After each experiment, hold a brief retrospective. Ask: Did the pattern help us make decisions faster? Did it reduce waiting time? Did it make work more predictable? Use the answers to refine your approach. The goal is not to find the perfect pattern forever, but to build a practice of consciously choosing and adapting your workflow as your work evolves.