@@ -27,19 +27,30 @@ Until `1.0.0`, breaking changes may appear in any release and are flagged with *
   default `REPEATABLE READ`, the claim's `FOR UPDATE SKIP LOCKED` took gap locks on
   `(status, created_at)`; with a backlog smaller than the batch, the gap ran to the end of the index,
   exactly where every `publish()` inserts, so business transactions waited for the whole HTTP/Kafka
-  delivery and could fail with `Lock wait timeout exceeded`. The scheduler transaction now runs at
-  `READ COMMITTED`, which takes no gap locks:
-  - Spring Boot: the autoconfigured `TransactionRunner` pins `READ COMMITTED` when its
-    `TransactionTemplate` leaves isolation at `DEFAULT`. It uses a copy, so a user's or Boot's
-    template bean is not mutated and its timeout/propagation/read-only settings carry over; a
-    template with an explicit isolation level is still used as-is.
-  - `ExposedTransactionRunner` gains a `transactionIsolation` parameter defaulting to
-    `READ_COMMITTED` (`null` restores the database default).
-
-  On Postgres `READ COMMITTED` is already the default, so behaviour there is unchanged. (#129)
+  delivery and could fail with `Lock wait timeout exceeded`. On MySQL and MariaDB the scheduler
+  transaction now runs at `READ COMMITTED`, which takes no gap locks:
+  - Spring Boot: the autoconfigured `TransactionRunner` pins `READ COMMITTED` when the store is
+    `MysqlOutboxStore` and its `TransactionTemplate` leaves isolation at `DEFAULT`. It uses a copy,
+    so a user's or Boot's template bean is not mutated and its timeout/propagation/read-only
+    settings carry over; a template with an explicit isolation level is still used as-is. Pinning is
+    skipped, with a startup WARN, for PTMs that reject custom isolation levels — a
+    `JtaTransactionManager`, or a `JpaTransactionManager` without the Hibernate/EclipseLink
+    `JpaDialect` — since every tick would otherwise throw `InvalidIsolationLevelException`.
+  - `ExposedTransactionRunner(database)` uses `READ COMMITTED` when the database's dialect is MySQL or
+    MariaDB. A new `ExposedTransactionRunner(database, transactionIsolation)` constructor sets the
+    level explicitly (`null` = the database default).
+
+  Other stores and databases are unchanged: Postgres already defaults to `READ COMMITTED`. MySQL at
+  `READ COMMITTED` needs `binlog_format=ROW` or `MIXED` (see the README). (#129)
 
 ### Changed
 
+- **`ExposedTransactionRunner` on MySQL/MariaDB now overrides `DatabaseConfig.defaultIsolationLevel`.**
+  Scheduler transactions run at `READ COMMITTED` even when the application configured another default
+  isolation (e.g. `SERIALIZABLE`) for its `Database`; business transactions keep that default. Pass
+  the level you want to `ExposedTransactionRunner(database, transactionIsolation)`, or `null` to keep
+  the database default, but note that `REPEATABLE READ` or stricter brings back the `publish()`
+  blocking described under *Fixed*. (#129)
 - **`CompositeMessageDeliverer.deliverBatch`** now dispatches transport groups concurrently — one
   virtual thread per group, with the last group run on the calling thread — instead of blocking on
   each group in turn. A batch spanning N transports costs ~`max(Tᵢ)` rather than `sum(Tᵢ)`; a batch
 
@@ -94,7 +94,7 @@ Runnable, self-contained applications live in [okapi-examples](https://github.co
 - **Duplicate delivery is possible.** A crash between a successful delivery and the status update means the message may be sent again after restart. If processing a message more than once would cause unwanted effects, make the consumer idempotent. okapi sends your payload, your configured headers, and an `x-outbox-id` header to deduplicate on — see [Deduplicating on `x-outbox-id`](#deduplicating-on-x-outbox-id).
 - **Best-effort ordering.** Rows are claimed by `created_at`, oldest first. However, parallel delivery and retries mean messages may reach consumers in a different order. Strict delivery ordering is not guaranteed.
 - **Failure classification is the transport's job.** Each deliverer decides what is retriable. HTTP: 5xx, 429, 408 and connection errors are retriable; other responses and TLS errors are permanent. Kafka: broker-side retriable exceptions are retried; authorization and configuration errors are not.
-- **Scheduler transactions run at `READ COMMITTED`.** The autoconfigured Spring `TransactionRunner` and `ExposedTransactionRunner` both use it. On MySQL this matters: at the default `REPEATABLE READ`, the claim's gap locks would block every concurrent `publish()` until delivery finishes. If you supply your own `TransactionRunner` or a `TransactionTemplate` with an explicit isolation level, keep it at `READ COMMITTED` on MySQL.
+- **On MySQL, scheduler transactions run at `READ COMMITTED`.** The autoconfigured Spring `TransactionRunner` (with `MysqlOutboxStore`) and `ExposedTransactionRunner` (on a MySQL/MariaDB dialect) both use it. At MySQL's default `REPEATABLE READ`, the claim's gap locks would block every concurrent `publish()` until delivery finishes. If you supply your own `TransactionRunner`, an `OutboxStore` of your own, or a `TransactionTemplate` with an explicit isolation level, keep it at `READ COMMITTED` on MySQL. With a `JtaTransactionManager`, or a `JpaTransactionManager` without the Hibernate/EclipseLink `JpaDialect`, okapi cannot set it (startup logs a WARN): configure `transaction_isolation = 'READ-COMMITTED'` on the server or in the JDBC URL instead. `READ COMMITTED` requires `binlog_format=ROW` (the default since MySQL 5.7.7) or `MIXED`; with `STATEMENT`, InnoDB rejects the scheduler's writes with `ERROR 1665`.
 - **Retry budget.** `okapi.processor.max-retries` (default 5) counts retries *after* the first attempt — six attempts in total before a row becomes `FAILED`. `FAILED` is terminal. Retriable messages become eligible again on the next processor poll; there is no per-message backoff.
 
 ### Deduplicating on `x-outbox-id`
 
@@ -17,6 +17,7 @@ slf4j = "2.0.20"
 logback = "1.6.5"
 assertj = "3.27.7"
 h2 = "2.5.252"
+jakartaTransaction = "2.0.1"
 micrometer = "1.17.2"
 jmh = "1.37"
 jmhGradlePlugin = "0.7.3"
@@ -66,6 +67,8 @@ slf4jApi = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }
 slf4jSimple = { module = "org.slf4j:slf4j-simple", version.ref = "slf4j" }
 logbackClassic = { module = "ch.qos.logback:logback-classic", version.ref = "logback" }
 h2 = { module = "com.h2database:h2", version.ref = "h2" }
+# Test-only: a fake UserTransaction for JtaTransactionManager in okapi-spring-boot tests.
+jakartaTransactionApi = { module = "jakarta.transaction:jakarta.transaction-api", version.ref = "jakartaTransaction" }
 jmhCore = { module = "org.openjdk.jmh:jmh-core", version.ref = "jmh" }
 jmhGeneratorAnnprocess = { module = "org.openjdk.jmh:jmh-generator-annprocess", version.ref = "jmh" }
 
 
@@ -1,6 +1,7 @@
 package com.softwaremill.okapi.exposed
 
 import com.softwaremill.okapi.core.TransactionRunner
+import org.jetbrains.exposed.v1.core.vendors.MysqlDialect
 import org.jetbrains.exposed.v1.jdbc.Database
 import org.jetbrains.exposed.v1.jdbc.transactions.transaction
 import java.sql.Connection
@@ -12,18 +13,36 @@ import java.sql.Connection
  * Used by the outbox scheduler/processor when running outside of
  * an existing transactional context (e.g., background processing thread).
  *
- * Runs at [transactionIsolation], READ COMMITTED by default (issue #129). Under MySQL's default
+ * On MySQL and MariaDB it runs at READ COMMITTED by default (issue #129). Under MySQL's default
  * REPEATABLE READ the claim's `FOR UPDATE SKIP LOCKED` takes gap locks at the end of the
  * `(status, created_at)` index -- where every `publish()` inserts -- so publishers block until the
- * claiming transaction, and with it delivery, finishes. On Postgres READ COMMITTED is already the
- * default. Pass `null` to use the [database]'s default isolation instead.
+ * claiming transaction, and with it delivery, finishes. This overrides a
+ * `DatabaseConfig.defaultIsolationLevel` set for the rest of the application. Other databases keep
+ * their default (Postgres already defaults to READ COMMITTED).
  *
  * @param database The [Database] instance where the outbox table resides.
- * @param transactionIsolation a `java.sql.Connection.TRANSACTION_*` level, or `null` for the database default.
  */
-class ExposedTransactionRunner @JvmOverloads constructor(
+class ExposedTransactionRunner private constructor(
     private val database: Database,
-    private val transactionIsolation: Int? = Connection.TRANSACTION_READ_COMMITTED,
+    explicitIsolation: Int?,
+    isolationIsExplicit: Boolean,
 ) : TransactionRunner {
+    constructor(database: Database) : this(database, null, isolationIsExplicit = false)
+
+    /**
+     * @param transactionIsolation a `java.sql.Connection.TRANSACTION_*` level, or `null` for the
+     *   [database]'s default isolation -- on every database, MySQL included.
+     */
+    constructor(database: Database, transactionIsolation: Int?) : this(database, transactionIsolation, isolationIsExplicit = true)
+
+    // Lazy: resolving the dialect may open a connection, which the constructor shouldn't do.
+    private val transactionIsolation: Int? by lazy {
+        when {
+            isolationIsExplicit -> explicitIsolation
+            database.dialect is MysqlDialect -> Connection.TRANSACTION_READ_COMMITTED // MariaDBDialect extends it
+            else -> null
+        }
+    }
+
     override fun <T> runInTransaction(block: () -> T): T = transaction(database, transactionIsolation = transactionIsolation) { block() }
 }
@@ -2,6 +2,7 @@ package com.softwaremill.okapi.exposed
 
 import io.kotest.core.spec.style.FunSpec
 import io.kotest.matchers.shouldBe
+import org.jetbrains.exposed.v1.core.DatabaseConfig
 import org.jetbrains.exposed.v1.jdbc.Database
 import org.jetbrains.exposed.v1.jdbc.transactions.TransactionManager
 import org.jetbrains.exposed.v1.jdbc.transactions.transactionManager
@@ -18,8 +19,21 @@ class ExposedTransactionRunnerTest : FunSpec({
         (TransactionManager.current().connection.connection as Connection).transactionIsolation
     }
 
-    test("runs at READ COMMITTED by default (no MySQL gap locks on the claim, #129)") {
-        isolationSeenBy(ExposedTransactionRunner(db)) shouldBe Connection.TRANSACTION_READ_COMMITTED
+    // The MySQL default (READ COMMITTED, #129) is covered against a real MySQL in
+    // okapi-integration-tests' MysqlClaimDoesNotBlockPublishersTest.
+    test("keeps the database's default isolation on a non-MySQL database") {
+        // H2's own default is already READ COMMITTED, so configure another one to tell them apart.
+        val serializableDb = Database.connect(
+            "jdbc:h2:mem:runner_test_serializable_${System.nanoTime()};DB_CLOSE_DELAY=-1",
+            driver = "org.h2.Driver",
+            databaseConfig = DatabaseConfig { defaultIsolationLevel = Connection.TRANSACTION_SERIALIZABLE },
+        )
+        isolationSeenBy(ExposedTransactionRunner(serializableDb)) shouldBe Connection.TRANSACTION_SERIALIZABLE
+    }
+
+    test("honours an explicit READ COMMITTED") {
+        isolationSeenBy(ExposedTransactionRunner(db, Connection.TRANSACTION_READ_COMMITTED)) shouldBe
+            Connection.TRANSACTION_READ_COMMITTED
     }
 
     test("honours an explicit isolation level") {