@@ -209,6 +209,7 @@ program
   .option('-i, --invert', 'inverts --grep matches')
   .option('-o, --override [value]', 'override current config options')
   .option('--suites', 'parallel execution of suites not single tests')
+  .option('--serial <pattern>', 'run tests matching <pattern> one by one after parallel workers finish')
   .option('--by <strategy>', 'test distribution strategy: "test" (pre-assign individual tests), "suite" (pre-assign test suites), or "pool" (dynamic distribution for optimal load balancing, recommended)')
   .option(commandFlags.debug.flag, commandFlags.debug.description)
   .option(commandFlags.verbose.flag, commandFlags.verbose.description)
 
@@ -157,6 +157,9 @@ npx codeceptjs run-workers 3 --by suite
 
 # Pool mode with filtering
 npx codeceptjs run-workers 4 --by pool --grep "@smoke"
+
+# Run tests tagged @serial one by one after parallel workers finish
+npx codeceptjs run-workers 3 --serial "@serial"
 ```
 
 **Test Distribution Strategies:**
@@ -165,6 +168,8 @@ npx codeceptjs run-workers 4 --by pool --grep "@smoke"
 - `--by suite`: Pre-assigns entire test suites to workers  
 - `--by pool`: Dynamic distribution for optimal load balancing (recommended for best performance)
 
+`--serial <pattern>` keeps tests matching the pattern out of parallel workers and runs them one by one in an extra worker once the others finish, within the same run. It overrides the `serial` config option. See [Serial tests](/parallel#serial-tests).
+
 The pool mode provides the best load balancing by maintaining tests in a shared pool and distributing them dynamically as workers become available. This prevents workers from sitting idle and ensures optimal CPU utilization, especially when tests have varying execution times.
 
 See [Parallel Execution](/parallel) documentation for more details.
 
@@ -44,6 +44,7 @@ export const config = {
 
 - `timeout` — default per-test timeout in seconds; a test is killed if it stops responding.
 - `mocha` — [Mocha options](https://mochajs.org/#configuring-mocha-nodejs), including extra reporters. See [Reporters](/reports).
+- `serial` — pattern for tests that must not run in parallel, e.g. `serial: '@serial'`. With `run-workers` they run one by one after all parallel workers finish. `--serial` overrides it. See [Serial tests](/parallel#serial-tests).
 - `workerInitializationDelay` — delay in milliseconds between spinning up parallel workers to prevent CPU spikes and stagger browser startup. Defaults to `200`. Set to `0` to disable.
 - `workerInitializationMaxDelay` — maximum total delay (in milliseconds) for worker initialization staggering. Defaults to `10000` (10 s). Set to `0` to disable capping.
 
 
@@ -40,6 +40,40 @@ npx codeceptjs run-workers 4 --by pool
 
 `--suites` is shorthand for `--by suite`.
 
+### Serial tests
+
+Some tests can't share the stage: they change global settings, reset data, or toggle a feature flag that other tests read. Mark them with a tag and set the `serial` pattern in config or pass it with `--serial`:
+
+```js
+// codecept.conf.js
+export const config = {
+  serial: '@serial',
+}
+```
+
+```js
+Scenario('change account timezone @serial', ({ I }) => {
+  // ...
+})
+```
+
+`run-workers` keeps matching tests out of the parallel workers. When those workers finish, one more worker starts and runs the serial tests one by one. It is still a single run: `bootstrapAll`, `teardownAll` and `event.workers.result` fire once, and the exit code covers both parts.
+
+```
+Test distribution:
+  Worker 1: 14 tests
+  Worker 2: 13 tests
+  Worker 3: 4 tests (serial)
+```
+
+Pass `--serial` to set or override the pattern for a single run:
+
+```sh
+npx codeceptjs run-workers 3 --serial "@serial"
+```
+
+`serial` is matched against the full test title the same way `--grep` is, so a tag on a `Feature` makes all its scenarios serial. It works with every `--by` strategy and combines with `--grep`: only serial tests that also match grep are run. With [multiple browsers](#multiple-browsers) each profile gets its own serial worker, started one after another.
+
 ### Multiple browsers
 
 Define browser profiles under `multiple` in `codecept.conf.js`:
 
@@ -55,7 +55,7 @@ export default async function (workerCount, selectedRuns, options) {
   output.print('Test distribution:')
   workerObjects.forEach((worker, index) => {
     const testCount = worker.tests.length
-    output.print(`  Worker ${index + 1}: ${testCount} test${testCount !== 1 ? 's' : ''}`)
+    output.print(`  Worker ${index + 1}: ${testCount} test${testCount !== 1 ? 's' : ''}${worker.serial ? ' (serial)' : ''}`)
   })
   output.print()
 
 
@@ -17,7 +17,7 @@ let stdout = ''
 
 const stderr = ''
 
-const { options, tests, testRoot, workerIndex, poolMode } = workerData
+const { options, tests, skipTests = [], testRoot, workerIndex, poolMode } = workerData
 
 // Global error handlers to catch critical errors but not test failures
 process.on('uncaughtException', (err) => {
@@ -287,6 +287,7 @@ async function runPoolTests() {
             // Load only the assigned test file
             mocha.files = [testIdentifier]
             await loadTests(mocha)
+            filterSuites(mocha.suite.suites, test => !skipTests.includes(test.uid))
 
             if (mocha.suite.total() > 0) {
               // Run only the tests in the current mocha suite
@@ -423,16 +424,14 @@ async function filterTests() {
   mocha.files = files
   await loadTests(mocha)
 
-  // Recursively filter tests in all suites (including nested ones)
-  const filterSuiteTests = (suite) => {
-    suite.tests = suite.tests.filter(test => tests.indexOf(test.uid) >= 0)
-    for (const childSuite of suite.suites) {
-      filterSuiteTests(childSuite)
-    }
-  }
+  filterSuites(mocha.suite.suites, test => tests.indexOf(test.uid) >= 0)
+}
 
-  for (const suite of mocha.suite.suites) {
-    filterSuiteTests(suite)
+// Recursively filter tests in all suites (including nested ones)
+function filterSuites(suites, keep) {
+  for (const suite of suites) {
+    suite.tests = suite.tests.filter(keep)
+    filterSuites(suite.suites, keep)
   }
 }
 
 
@@ -68,11 +68,12 @@ const withoutEmptyGroups = groups => {
   return nonEmpty.length ? nonEmpty : groups.slice(0, 1)
 }
 
-const createWorker = (workerObject, isPoolMode = false) => {
+const createWorker = (workerObject, isPoolMode = false, skipTests = []) => {
   const worker = new Worker(pathToWorker, {
     workerData: {
       options: simplifyObject(workerObject.options),
       tests: workerObject.tests,
+      skipTests,
       testRoot: workerObject.testRoot,
       workerIndex: workerObject.workerIndex + 1,
       poolMode: isPoolMode,
@@ -224,6 +225,7 @@ class WorkerObject {
    */
   constructor(workerIndex) {
     this.workerIndex = workerIndex
+    this.serial = false
     this.options = {}
     this.tests = []
     this.testRoot = getTestRoot()
@@ -299,6 +301,7 @@ class Workers extends EventEmitter {
     this.testGroups = []
     this.testPool = []
     this.testPoolInitialized = false
+    this.serialTests = []
     this.isPoolMode = config.by === 'pool'
     this.activeWorkers = new Map()
     this.maxWorkers = numberOfWorkers // Track original worker count for pool mode
@@ -323,9 +326,21 @@ class Workers extends EventEmitter {
 
   async _initWorkers(numberOfWorkers, config) {
     await this.splitTestsByGroups(numberOfWorkers, config)
+    this.serialTests = await this.createGroupOfSerialTests()
+    if (this.serialTests.length && !this.isPoolMode) {
+      this.testGroups = this.testGroups.map(group => group.filter(uid => !this.serialTests.includes(uid))).filter(group => group.length)
+    }
     // For function-based grouping, use the actual number of test groups created
     const actualNumberOfWorkers = isFunction(config.by) ? this.testGroups.length : numberOfWorkers
     this.workers = createWorkerObjects(this.testGroups, this.codecept.config, getTestRoot(config.testConfig), config.options, config.selectedRuns)
+    if (this.serialTests.length) {
+      const serialWorkers = createWorkerObjects([this.serialTests], this.codecept.config, getTestRoot(config.testConfig), config.options, config.selectedRuns)
+      for (const worker of serialWorkers) {
+        worker.workerIndex = this.workers.length
+        worker.serial = true
+        this.workers.push(worker)
+      }
+    }
     this.numberOfWorkers = this.workers.length
   }
 
@@ -408,6 +423,32 @@ class Workers extends EventEmitter {
     return groups
   }
 
+  /**
+   * Collects tests matching `--serial` option or `serial` config pattern.
+   * These tests are excluded from parallel workers and run one by one after them.
+   *
+   * @returns {Promise<string[]>}
+   */
+  async createGroupOfSerialTests() {
+    const pattern = this.options.serial || this.codecept?.config.serial
+    if (!pattern) return []
+    const serial = new RegExp(pattern)
+
+    Container.createMocha(this.codecept.config.mocha || {}, this.options)
+    const mocha = Container.mocha()
+    mocha.files = this.codecept.testFiles
+    await loadTests(mocha, { reload: true })
+
+    const group = []
+    mocha.suite.eachTest(test => {
+      if (test && serial.test(test.fullTitle()) && matchesGrep(mocha, test)) group.push(test.uid)
+    })
+
+    mocha.unloadFiles()
+
+    return group
+  }
+
   /**
    * @param {Number} numberOfWorkers
    */
@@ -534,7 +575,8 @@ class Workers extends EventEmitter {
       : 0
 
     for (const worker of this.workers) {
-      const workerThread = createWorker(worker, this.isPoolMode)
+      if (worker.serial) continue
+      const workerThread = createWorker(worker, this.isPoolMode, this.serialTests)
       this._listenWorkerEvents(workerThread)
       workerThreads.push(workerThread)
 
@@ -545,6 +587,8 @@ class Workers extends EventEmitter {
       }
     }
 
+    if (!workerThreads.length) this._runSerialWorker()
+
     recorder.add('workers started', () => {
       // Workers are already running, this is just a placeholder step
     })
@@ -556,6 +600,14 @@ class Workers extends EventEmitter {
     })
   }
 
+  _runSerialWorker() {
+    const parallelWorkers = this.workers.filter(worker => !worker.serial)
+    if (this.closedWorkers < parallelWorkers.length) return
+    const worker = this.workers[this.closedWorkers]
+    if (!worker) return
+    this._listenWorkerEvents(createWorker(worker))
+  }
+
   /**
    * @returns {Array<WorkerObject>}
    */
@@ -787,14 +839,10 @@ class Workers extends EventEmitter {
         process.exitCode = 1
       }
 
-      if (this.isPoolMode) {
-        // Pool mode: finish when all workers have exited and no more tests
-        if (this.closedWorkers === this.numberOfWorkers) {
-          this._finishRun()
-        }
-      } else if (this.closedWorkers === this.numberOfWorkers) {
-        // Regular mode: finish when all original workers have exited
+      if (this.closedWorkers === this.numberOfWorkers) {
         this._finishRun()
+      } else {
+        this._runSerialWorker()
       }
     })
   }
 
@@ -0,0 +1,12 @@
+export const config = {
+  tests: './workers-serial/*_test.js',
+  timeout: 10000,
+  output: './output',
+  helpers: {
+    FileSystem: {},
+  },
+  include: {},
+  serial: '@serial',
+  mocha: {},
+  name: 'sandbox',
+};
@@ -0,0 +1,11 @@
+import { track } from './timeline.js'
+
+Feature('Serial lane @serial')
+
+Scenario('serial one', async () => {
+  await track('serial one')
+})
+
+Scenario('serial two', async () => {
+  await track('serial two')
+})
@@ -0,0 +1,19 @@
+import { track } from './timeline.js'
+
+Feature('Parallel lane')
+
+Scenario('parallel one', async () => {
+  await track('parallel one')
+})
+
+Scenario('parallel two', async () => {
+  await track('parallel two')
+})
+
+Scenario('serial three @serial', async () => {
+  await track('serial three')
+})
+
+Scenario('parallel three', async () => {
+  await track('parallel three')
+})