diff --git a/.gitignore b/.gitignore
index f5833c742..cb8ad9f7f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -29,4 +29,10 @@ hs_err_pid*
 *.iml
 target/
 .DS_Store
-*.versionsBackup
\ No newline at end of file
+*.versionsBackup
+
+# JENV
+.java-version
+
+delombok/
+**/*.releaseBackup
\ No newline at end of file
diff --git a/.idea/runConfigurations/All_examples.xml b/.idea/runConfigurations/All_examples.xml
index ae2384feb..8c82d61b5 100644
--- a/.idea/runConfigurations/All_examples.xml
+++ b/.idea/runConfigurations/All_examples.xml
@@ -7,7 +7,7 @@
         <option name="ENABLED" value="true" />
       </pattern>
     </extension>
-    <option name="PACKAGE_NAME" value="io.confluent.parallalconsumer.examples" />
+    <option name="PACKAGE_NAME" value="io.confluent.parallelconsumer.examples" />
     <option name="MAIN_CLASS_NAME" value="" />
     <option name="METHOD_NAME" value="" />
     <option name="TEST_OBJECT" value="package" />
diff --git a/README.adoc b/README.adoc
index 837e65eac..a4bc0a20c 100644
--- a/README.adoc
+++ b/README.adoc
@@ -38,7 +38,10 @@ ifdef::env-github[]
 :warning-caption: :warning:
 endif::[]
 
-image:https://travis-ci.com/astubbs/parallel-consumer.svg?branch=master["Build Status", link="https://travis-ci.com/astubbs/parallel-consumer"] image:https://codecov.io/gh/astubbs/parallel-consumer/branch/master/graph/badge.svg["Coverage",https://codecov.io/gh/astubbs/parallel-consumer]
+image:https://maven-badges.herokuapp.com/maven-central/io.confluent.parallelconsumer/parallel-consumer-parent/badge.svg?style=flat[link=https://mvnrepository.com/artifact/io.confluent.parallelconsumer/parallel-consumer-parent,Latest Parallel Consumer on Maven Central]
+
+// travis badges temporarily disabled as travis isn't running CI currently
+//image:https://travis-ci.com/astubbs/parallel-consumer.svg?branch=master["Build Status", link="https://travis-ci.com/astubbs/parallel-consumer"] image:https://codecov.io/gh/astubbs/parallel-consumer/branch/master/graph/badge.svg["Coverage",https://codecov.io/gh/astubbs/parallel-consumer]
 
 Parallel Apache Kafka client wrapper with client side queueing, a simpler consumer/producer API with *key concurrency* and *extendable non-blocking IO* processing.
 
@@ -113,10 +116,12 @@ This is effective in many situations, but falls short in a lot too.
 
 * Primarily: You cannot use more consumers than you have partitions available to read from.
 For example, if you have a topic with five partitions, you cannot use a group with more than five consumers to read from it.
-* Running more extra consumers has resource implications - each consumer takes up resources on both the client  and broker side
+* Running more extra consumers has resource implications - each consumer takes up resources on both the client  and broker side.
 Each consumer adds a lot of overhead in terms of memory, CPU, and network bandwidth.
 * Large consumer groups (especially many large groups) can cause a lot of strain on the consumer group coordination system, such as rebalance storms.
-* Even with several partitions, you cannot achieve the performance levels obtainable by *per-key* ordered or unordered concurrent processing
+* Even with several partitions, you cannot achieve the performance levels obtainable by *per-key* ordered or unordered concurrent processing.
+* A single slow or failing message will also still block all messages behind the problematic message, ie. the entire partition.
+The process may recover, but the latency of all the messages behind the problematic one will be negatively impacted severely.
 
 Why not run more consumers __within__ your application instance?::
 * This is in some respects a slightly easier way of running more consumer instances, and in others a more complicated way.
@@ -195,11 +200,12 @@ without operational burden or harming the clusters performance
 * Vert.x non-blocking library integration (HTTP currently)
 * Fair partition traversal
 * Zero~ dependencies (`Slf4j` and `Lombok`) for the core module
+* Java 8 compatibility
 * Throttle control and broker liveliness management
 * Clean draining shutdown cycle
 
-image:https://codecov.io/gh/astubbs/parallel-consumer/branch/master/graph/badge.svg["Coverage",https://codecov.io/gh/astubbs/parallel-consumer]
-image:https://travis-ci.com/astubbs/parallel-consumer.svg?branch=master["Build Status", link="https://travis-ci.com/astubbs/parallel-consumer"]
+//image:https://codecov.io/gh/astubbs/parallel-consumer/branch/master/graph/badge.svg["Coverage",https://codecov.io/gh/astubbs/parallel-consumer]
+//image:https://travis-ci.com/astubbs/parallel-consumer.svg?branch=master["Build Status", link="https://travis-ci.com/astubbs/parallel-consumer"]
 
 And more <<roadmap,to come>>!
 
@@ -342,6 +348,11 @@ Latest version can be seen https://search.maven.org/artifact/io.confluent.parall
 
 Where `${project.version}` is the version to be used:
 
+* group ID: `io.confluent.parallelconsumer`
+* artifact ID: `parallel-consumer-core`
+* version: image:https://maven-badges.herokuapp.com/maven-central/io.confluent.parallelconsumer/parallel-consumer-parent/badge.svg?style=flat[link=https://mvnrepository.com/artifact/io.confluent.parallelconsumer/parallel-consumer-parent,Latest Parallel Consumer on Maven Central]
+
+
 .Core Module Dependency
 [source,xml,indent=0]
         <dependency>
@@ -364,26 +375,31 @@ Where `${project.version}` is the version to be used:
 .Setup the client
 [source,java,indent=0]
 ----
-        var options = ParallelConsumerOptions.builder()
-                .ordering(KEY) // <1>
-                .maxConcurrency(1000) // <2>
-                .maxUncommittedMessagesToHandlePerPartition(10000) // <3>
+        Consumer<String, String> kafkaConsumer = getKafkaConsumer(); // <1>
+        Producer<String, String> kafkaProducer = getKafkaProducer();
+
+        var options = ParallelConsumerOptions.<String, String>builder()
+                .ordering(KEY) // <2>
+                .maxMessagesToQueue(1000) // <3>
+                .maxNumberMessagesBeyondBaseCommitOffset(1000) // <4>
+                .consumer(kafkaConsumer)
+                .producer(kafkaProducer)
                 .build();
 
-        Consumer<String, String> kafkaConsumer = getKafkaConsumer(); // <4>
-        if (!(kafkaConsumer instanceof MockConsumer)) {
-            kafkaConsumer.subscribe(UniLists.of(inputTopic)); // <5>
-        }
+        ParallelStreamProcessor<String, String> eosStreamProcessor =
+                ParallelStreamProcessor.createEosStreamProcessor(options);
+
+        eosStreamProcessor.subscribe(of(inputTopic)); // <5>
 
-        return ParallelStreamProcessor.createEosStreamProcessor(kafkaConsumer, getKafkaProducer(), options);
+        return eosStreamProcessor;
 ----
-<1> Choose your ordering type, `KEY` in this case.
+<1> Setup your clients as per normal. A Producer is only required if using the `produce` flows.
+<2> Choose your ordering type, `KEY` in this case.
 This ensures maximum concurrency, while ensuring messages are processed and committed in `KEY` order, making sure no offset is committed unless all offsets before it in it's partition, are completed also.
-<2> The maximum number of concurrent processing operations to be performing at any given time
-<3> Regardless of the level of concurrency, don't have more than this many messages uncommitted at any given time.
+<3> The maximum number of concurrent processing operations to be performing at any given time
+<4> Regardless of the level of concurrency, don't have more than this many messages uncommitted at any given time.
 Also, because the library coordinates offsets, `enable.auto.commit` must be disabled in your consumer.
-<4> Setup your consumer client as per normal
-<5> Setup your topic subscriptions - (when using the `MockConsumer` you must use the `MockConsumer#assign` method)
+<5> Subscribe to your topics
 
 NOTE: Because the library coordinates offsets, `enable.auto.commit` must be disabled.
 
@@ -433,15 +449,14 @@ You can also optionally provide a callback function to be run after the message(
 
 .Usage - print message content out to the console in parallel
 [source,java,indent=0]
-        this.parallelConsumer.pollAndProduce(record -> {
+        parallelConsumer.pollAndProduce(record -> {
                     var result = processBrokerRecord(record);
-                    ProducerRecord<String, String> produceRecord =
-                            new ProducerRecord<>(outputTopic, "a-key", result.payload);
-                    return UniLists.of(produceRecord);
-                }, consumeProduceResult ->
-                        log.info("Message {} saved to broker at offset {}",
-                                consumeProduceResult.getOut(),
-                                consumeProduceResult.getMeta().offset())
+                    return new ProducerRecord<>(outputTopic, record.key(), result.payload);
+                }, consumeProduceResult -> {
+                    log.debug("Message {} saved to broker at offset {}",
+                            consumeProduceResult.getOut(),
+                            consumeProduceResult.getMeta().offset());
+                }
         );
 
 
@@ -463,7 +478,7 @@ In future versions, we plan to look at supporting other streaming systems like h
         var resultStream = parallelConsumer.vertxHttpReqInfoStream(record -> {
             log.info("Concurrently constructing and returning RequestInfo from record: {}", record);
             Map<String, String> params = UniMaps.of("recordKey", record.key(), "payload", record.value());
-            return new RequestInfo("localhost", "/api", params); // <1>
+            return new RequestInfo("localhost", port, "/api", params); // <1>
         });
 ----
 <1> Simply return an object representing the request, the Vert.x HTTP engine will handle the rest, using it's non-blocking engine
@@ -504,7 +519,7 @@ image::https://lucid.app/publicSegments/view/43f2740c-2a7f-4b7f-909e-434a5bbe3fb
     }
 
     void concurrentProcess() {
-        setupConsumer();
+        setupParallelConsumer();
 
         parallelConsumer.poll(record -> {
             log.info("Concurrently processing a record: {}", record);
@@ -603,16 +618,33 @@ When your function is actually run, a result object will be streamed back to you
 After your operation completes, you can also choose to publish a result message back to Kafka.
 The message publishing metadata can be streamed back to your client code.
 
-== Apache Kafka EoS Transaction Model
+== Commit Mode
+
+The system gives you three choices for how to do offset commits.
+The simplest of the three are the two Consummer commits modes.
+They are of course, `sycnhronous` and `asynchronous` mode.
+The `transactional` mode is explained in the next section.
+
+`Asychornous` mode is faster, as it doesn't block the control loop.
+
+`Sycnhronous` will block the processing loop until a successful commit response is received, however, `asycnhronous` will still be capped by the max processing settings in the `Options` class.
 
-The system uses Kafka's Exactly Once Semantics (EoS) system.
+If you're used to using the auto commit mode in the normal Kafka consumer, you can think of the `Asychornous` mode being similar to this.
+We suggest starting with this mode, and it is the default.
+
+=== Apache Kafka EoS Transaction Model
+
+There is also the option to use Kafka's Exactly Once Semantics (EoS) system.
 This causes all messages produced as a result of processing a message to be committed within a transaction, along with their source offset.
 This means that even under failure, the results will exist exactly once in the Kafka output topic.
-If as a part of
-your processing, you create side effects in other systems, this pertains to the usual idempotency requirements when breaking of EoS Kafka boundaries.
+If as a part of your processing, you create side effects in other systems, this pertains to the usual idempotency requirements when breaking of EoS Kafka boundaries.
+
+NOTE:: As with the `synchronous` processing mode, this will also block the processing loop until a successful transaction completes
 
 CAUTION: This cannot be true for any externally integrated third party system, unless that system is __idempotent__.
 
+For implementations details, see the <<Transactional System Architecture>> section.
+
 [[streams-usage]]
 == Using with Kafka Streams
 
@@ -631,21 +663,20 @@ image::https://lucid.app/publicSegments/view/43f2740c-2a7f-4b7f-909e-434a5bbe3fb
 
 === Short Term - What we're working on nowish ⏰
 
-* Producer is optional
-* Transactions optional
 * Depth~ first or breadth first partition traversal
 * JavaRX and other streaming modules
 
 === Medium Term - What's up next ⏲
 
-* Automatic fanout (automatic selection of concurrency level based on downstream back pressure)
+* https://github.com/confluentinc/parallel-consumer/issues/21[Automatic fanout] (automatic selection of concurrency level based on downstream back pressure) (https://github.com/confluentinc/parallel-consumer/pull/22[draft PR])
 * Support for general Vert.x Verticles (non-blocking libraries)
 * Dead Letter Queue (DLQ) handling
 * Non-blocking I/O work management
 ** More customisable handling of HTTP interactions
 ** Chance to batch multiple consumer records into a single or multiple http request objects
-* Distributed tracing integration
-* Metrics
+* https://github.com/confluentinc/parallel-consumer/issues/28[Distributed tracing integration]
+* https://github.com/confluentinc/parallel-consumer/issues/24[Distributed rate limiting]
+* https://github.com/confluentinc/parallel-consumer/issues/27[Metrics]
 
 === Long Term - The future ☁️
 
@@ -799,6 +830,10 @@ Instead of the work thread pool count being the degree of concurrency, it is con
 .Vert.x Architecture
 image::https://lucid.app/publicSegments/view/509df410-5997-46be-98e7-ac7f241780b4/image.png[Vert.x Architecture, align="center"]
 
+=== Transactional System Architecture
+
+image::https://lucid.app/publicSegments/view/7480d948-ed7d-4370-a308-8ec12e6b453b/image.png[]
+
 === Offset Map
 
 ==== Storage
diff --git a/parallel-consumer-core/pom.xml b/parallel-consumer-core/pom.xml
index ae2be14c0..f2398e056 100644
--- a/parallel-consumer-core/pom.xml
+++ b/parallel-consumer-core/pom.xml
@@ -38,6 +38,12 @@
             <version>${junit.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.junit-pioneer</groupId>
+            <artifactId>junit-pioneer</artifactId>
+            <version>1.0.0</version>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.testcontainers</groupId>
             <artifactId>testcontainers</artifactId>
diff --git a/parallel-consumer-core/src/main/java/io/confluent/csid/utils/StringUtils.java b/parallel-consumer-core/src/main/java/io/confluent/csid/utils/StringUtils.java
index f78ebf8d2..219066bd0 100644
--- a/parallel-consumer-core/src/main/java/io/confluent/csid/utils/StringUtils.java
+++ b/parallel-consumer-core/src/main/java/io/confluent/csid/utils/StringUtils.java
@@ -9,7 +9,11 @@
 public class StringUtils {
 
     public static String msg(String s, Object... args) {
-        String message = MessageFormatter.basicArrayFormat(s, args);
-        return message;
+        return MessageFormatter.basicArrayFormat(s, args);
+    }
+
+    public static boolean isBlank(final String property) {
+        if (property == null) return true;
+        else return property.trim().isEmpty(); // isBlank @since 11
     }
 }
diff --git a/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/AbstractOffsetCommitter.java b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/AbstractOffsetCommitter.java
new file mode 100644
index 000000000..4f0167987
--- /dev/null
+++ b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/AbstractOffsetCommitter.java
@@ -0,0 +1,59 @@
+package io.confluent.parallelconsumer;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.kafka.clients.consumer.ConsumerGroupMetadata;
+import org.apache.kafka.clients.consumer.OffsetAndMetadata;
+import org.apache.kafka.common.TopicPartition;
+
+import java.util.Map;
+
+@Slf4j
+@RequiredArgsConstructor
+public abstract class AbstractOffsetCommitter<K, V> implements OffsetCommitter {
+
+    protected final ConsumerManager<K, V> consumerMgr;
+    protected final WorkManager<K, V> wm;
+
+    /**
+     * Get offsets from {@link WorkManager} that are ready to commit
+     */
+    @Override
+    public void retrieveOffsetsAndCommit() {
+        log.debug("Commit starting - find completed work to commit offsets");
+        // todo shouldn't be removed until commit succeeds (there's no harm in committing the same offset twice)
+        preAcquireWork();
+        try {
+            Map<TopicPartition, OffsetAndMetadata> offsetsToSend = wm.findCompletedEligibleOffsetsAndRemove();
+            if (offsetsToSend.isEmpty()) {
+                log.trace("No offsets ready");
+            } else {
+                log.debug("Will commit offsets for {} partition(s): {}", offsetsToSend.size(), offsetsToSend);
+                ConsumerGroupMetadata groupMetadata = consumerMgr.groupMetadata();
+
+                log.debug("Begin commit");
+                commitOffsets(offsetsToSend, groupMetadata);
+
+                log.debug("On commit success");
+                onOffsetCommitSuccess(offsetsToSend);
+            }
+        } finally {
+            postCommit();
+        }
+    }
+
+    protected void postCommit() {
+        // default noop
+    }
+
+    protected void preAcquireWork() {
+        // default noop
+    }
+
+    private void onOffsetCommitSuccess(final Map<TopicPartition, OffsetAndMetadata> offsetsToSend) {
+        wm.onOffsetCommitSuccess(offsetsToSend);
+    }
+
+    protected abstract void commitOffsets(final Map<TopicPartition, OffsetAndMetadata> offsetsToSend, final ConsumerGroupMetadata groupMetadata);
+
+}
diff --git a/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/BrokerPollSystem.java b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/BrokerPollSystem.java
index aab44f9e7..9649c4824 100644
--- a/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/BrokerPollSystem.java
+++ b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/BrokerPollSystem.java
@@ -4,14 +4,13 @@
  * Copyright (C) 2020 Confluent, Inc.
  */
 
+import io.confluent.parallelconsumer.ParallelConsumerOptions.CommitMode;
 import lombok.Getter;
 import lombok.Setter;
+import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.kafka.clients.consumer.Consumer;
 import org.apache.kafka.clients.consumer.ConsumerRecords;
 import org.apache.kafka.common.TopicPartition;
-import org.apache.kafka.common.errors.WakeupException;
-import pl.tlinkowski.unij.api.UniMaps;
 
 import java.time.Duration;
 import java.util.Optional;
@@ -20,8 +19,11 @@
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeoutException;
+import java.util.function.Consumer;
 
 import static io.confluent.csid.utils.BackportUtils.toSeconds;
+import static io.confluent.parallelconsumer.ParallelEoSStreamProcessor.State.closed;
+import static io.confluent.parallelconsumer.ParallelEoSStreamProcessor.State.running;
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
 
 /**
@@ -31,11 +33,11 @@
  * @param <V>
  */
 @Slf4j
-public class BrokerPollSystem<K, V> {
+public class BrokerPollSystem<K, V> implements OffsetCommitter {
 
-    private final org.apache.kafka.clients.consumer.Consumer<K, V> consumer;
+    private final ConsumerManager<K, V> consumerManager;
 
-    public ParallelEoSStreamProcessor.State state = ParallelEoSStreamProcessor.State.running;
+    private ParallelEoSStreamProcessor.State state = ParallelEoSStreamProcessor.State.running;
 
     private Optional<Future<Boolean>> pollControlThreadFuture;
 
@@ -43,20 +45,47 @@ public class BrokerPollSystem<K, V> {
 
     private final ParallelEoSStreamProcessor<K, V> pc;
 
+    private Optional<ConsumerOffsetCommitter<K, V>> committer = Optional.empty();
+
+    /**
+     * Note how this relates to {@link BrokerPollSystem#getLongPollTimeout()} - if longPollTimeout is high and loading
+     * factor is low, there may not be enough messages queued up to satisfy demand.
+     */
     @Setter
     @Getter
     private static Duration longPollTimeout = Duration.ofMillis(2000);
 
     private final WorkManager<K, V> wm;
 
-    public BrokerPollSystem(Consumer<K, V> consumer, WorkManager<K, V> wm, ParallelEoSStreamProcessor<K, V> pc) {
-        this.consumer = consumer;
+    public BrokerPollSystem(ConsumerManager<K, V> consumerMgr, WorkManager<K, V> wm, ParallelEoSStreamProcessor<K, V> pc, final ParallelConsumerOptions options) {
         this.wm = wm;
         this.pc = pc;
+
+        this.consumerManager = consumerMgr;
+        switch (options.getCommitMode()) {
+            case CONSUMER_SYNC, CONSUMER_ASYNCHRONOUS -> {
+                ConsumerOffsetCommitter<K, V> consumerCommitter = new ConsumerOffsetCommitter<>(consumerMgr, wm, options);
+                committer = Optional.of(consumerCommitter);
+            }
+        }
     }
 
     public void start() {
-        this.pollControlThreadFuture = Optional.of(Executors.newSingleThreadExecutor().submit(this::controlLoop));
+        Future<Boolean> submit = Executors.newSingleThreadExecutor().submit(this::controlLoop);
+        this.pollControlThreadFuture = Optional.of(submit);
+    }
+
+    public void supervise() {
+        if (pollControlThreadFuture.isPresent()) {
+            Future<Boolean> booleanFuture = pollControlThreadFuture.get();
+            if (booleanFuture.isCancelled() || booleanFuture.isDone()) {
+                try {
+                    booleanFuture.get();
+                } catch (Exception e) {
+                    throw new InternalError("Error in " + BrokerPollSystem.class.getSimpleName() + " system.", e);
+                }
+            }
+        }
     }
 
     /**
@@ -65,42 +94,70 @@ public void start() {
     private boolean controlLoop() {
         Thread.currentThread().setName("broker-poll");
         log.trace("Broker poll control loop start");
-        while (state != ParallelEoSStreamProcessor.State.closed) {
-            log.trace("Loop: Poll broker");
-            ConsumerRecords<K, V> polledRecords = pollBrokerForRecords();
-
-            if (!polledRecords.isEmpty()) {
-                log.trace("Loop: Register work");
-                wm.registerWork(polledRecords);
+        committer.ifPresent(x -> x.claim());
+        try {
+            while (state != closed) {
+                log.trace("Loop: Broker poller: ({})", state);
+                if (state == running) {
+                    ConsumerRecords<K, V> polledRecords = pollBrokerForRecords();
 
-                // notify control work has been registered
-                pc.notifyNewWorkRegistered();
-            }
+                    if (!polledRecords.isEmpty()) {
+                        log.trace("Loop: Register work");
+                        wm.registerWork(polledRecords);
 
-            switch (state) {
-                case draining -> {
-                    doPause();
-                    // transition to closing
-                    state = ParallelEoSStreamProcessor.State.closing;
+                        // notify control work has been registered
+                        pc.notifyNewWorkRegistered();
+                    }
                 }
-                case closing -> {
-                    if (polledRecords.isEmpty()) {
+
+                maybeDoCommit();
+
+                switch (state) {
+                    case draining -> {
+                        doPause();
+                        transitionToCloseMaybe();
+                    }
+                    case closing -> {
                         doClose();
-                    } else {
-                        log.info("Subscriptions are paused, but records are still being drained (count: {})", polledRecords.count());
                     }
                 }
             }
+            log.debug("Broker poll thread finished, returning true to future");
+            return true;
+        } catch (Exception e) {
+            log.error("Unknown error", e);
+            throw e;
+        }
+    }
+
+    private void transitionToCloseMaybe() {
+        // make sure everything is committed
+        if (isResponsibleForCommits() && !wm.isRecordsAwaitingToBeCommitted()) {
+            // transition to closing
+            state = ParallelEoSStreamProcessor.State.closing;
         }
-        log.trace("Broker poll thread returning true");
-        return true;
     }
 
     private void doClose() {
-        log.debug("Closing {}, first closing consumer...", this.getClass().getSimpleName());
-        this.consumer.close(DrainingCloseable.DEFAULT_TIMEOUT);
-        log.debug("Consumer closed.");
-        state = ParallelEoSStreamProcessor.State.closed;
+        doPause();
+        maybeCloseConsumer();
+        state = closed;
+    }
+
+    /**
+     * To keep things simple, make sure the correct thread which can make a commit, is the one to close the consumer.
+     * This way, if partitions are revoked, the commit can be made inline.
+     */
+    private void maybeCloseConsumer() {
+        if (isResponsibleForCommits()) {
+            log.debug("Closing {}, first closing consumer...", this.getClass().getSimpleName());
+            this.consumerManager.close(DrainingCloseable.DEFAULT_TIMEOUT);
+            log.debug("Consumer closed.");
+        }
+    }
+
+    private boolean isResponsibleForCommits() {
+        return committer.isPresent();
     }
 
     private ConsumerRecords<K, V> pollBrokerForRecords() {
@@ -108,16 +165,8 @@ private ConsumerRecords<K, V> pollBrokerForRecords() {
 
         Duration thisLongPollTimeout = (state == ParallelEoSStreamProcessor.State.running) ? BrokerPollSystem.longPollTimeout : Duration.ofMillis(1); // Can't use Duration.ZERO - this causes Object#wait to wait forever
 
-        log.debug("Long polling broker with timeout {} seconds, might appear to sleep here if no data available on broker.", toSeconds(thisLongPollTimeout)); // java 8
-        ConsumerRecords<K, V> records;
-        try {
-            records = this.consumer.poll(thisLongPollTimeout);
-            log.debug("Poll completed normally and returned {}...", records.count());
-        } catch (WakeupException w) {
-            log.warn("Awoken from poll. State? {}", state);
-            records = new ConsumerRecords<>(UniMaps.of());
-        }
-        return records;
+        log.debug("Long polling broker with timeout {} seconds, might appear to sleep here if subs are paused, or no data available on broker.", toSeconds(thisLongPollTimeout)); // java 8
+        return consumerManager.poll(thisLongPollTimeout);
     }
 
     /**
@@ -126,9 +175,9 @@ private ConsumerRecords<K, V> pollBrokerForRecords() {
     public void drain() {
         // idempotent
         if (state != ParallelEoSStreamProcessor.State.draining) {
-            log.debug("Poll system signaling to drain...");
+            log.debug("Signaling poll system to drain, waking up consumer...");
             state = ParallelEoSStreamProcessor.State.draining;
-            consumer.wakeup();
+            consumerManager.wakeup();
         }
     }
 
@@ -139,8 +188,8 @@ private void doPause() {
         } else {
             paused = true;
             log.debug("Pausing subs");
-            Set<TopicPartition> assignment = consumer.assignment();
-            consumer.pause(assignment);
+            Set<TopicPartition> assignment = consumerManager.assignment();
+            consumerManager.pause(assignment);
         }
     }
 
@@ -151,7 +200,7 @@ public void closeAndWait() throws TimeoutException, ExecutionException {
             log.debug("Wait for loop to finish ending...");
             Future<Boolean> pollControlResult = pollControlThreadFuture.get();
             boolean interrupted = true;
-            while(interrupted) {
+            while (interrupted) {
                 try {
                     Boolean pollShutdownSuccess = pollControlResult.get(DrainingCloseable.DEFAULT_TIMEOUT.toMillis(), MILLISECONDS);
                     interrupted = false;
@@ -159,9 +208,9 @@ public void closeAndWait() throws TimeoutException, ExecutionException {
                         log.warn("Broker poll control thread not closed cleanly.");
                     }
                 } catch (InterruptedException e) {
-                    log.debug("Interrupted", e);
+                    log.debug("Interrupted waiting for broker poller thread to finish", e);
                 } catch (ExecutionException | TimeoutException e) {
-                    log.error("Execution or timeout exception", e);
+                    log.error("Execution or timeout exception waiting for broker poller thread to finish", e);
                     throw e;
                 }
             }
@@ -170,8 +219,9 @@ public void closeAndWait() throws TimeoutException, ExecutionException {
     }
 
     private void transitionToClosing() {
+        log.debug("Poller transitioning to closing, waking up consumer");
         state = ParallelEoSStreamProcessor.State.closing;
-        consumer.wakeup();
+        consumerManager.wakeup();
     }
 
     /**
@@ -192,11 +242,11 @@ private void managePauseOfSubscription() {
     private void resumeIfPaused() {
         // idempotent
         if (paused) {
-            log.debug("Resuming consumer");
-            Set<TopicPartition> pausedTopics = consumer.paused();
-            consumer.resume(pausedTopics);
+            log.debug("Resuming consumer, waking up");
+            Set<TopicPartition> pausedTopics = consumerManager.paused();
+            consumerManager.resume(pausedTopics);
             // trigger consumer to perform a new poll without the assignments paused, otherwise it will continue to long poll on nothing
-            consumer.wakeup();
+            consumerManager.wakeup();
             paused = false;
         }
     }
@@ -204,4 +254,34 @@ private void resumeIfPaused() {
     private boolean shouldThrottle() {
         return wm.shouldThrottle();
     }
+
+    /**
+     * Optionally blocks. Threadsafe
+     *
+     * @see CommitMode
+     */
+    @SneakyThrows
+    @Override
+    public void retrieveOffsetsAndCommit() {
+        // {@link Optional#ifPresentOrElse} only @since 9
+        ConsumerOffsetCommitter<K, V> comitter = committer.orElseThrow(() -> {
+            // shouldn't be here
+            throw new IllegalStateException("No committer configured");
+        });
+        comitter.commit();
+    }
+
+    /**
+     * Will silently skip if not configured with a committer
+     */
+    private void maybeDoCommit() {
+        committer.ifPresent(ConsumerOffsetCommitter::maybeDoCommit);
+    }
+
+    /**
+     * Wakeup if colling the broker
+     */
+    public void wakeup() {
+        consumerManager.wakeup();
+    }
 }
diff --git a/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/ConsumerManager.java b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/ConsumerManager.java
new file mode 100644
index 000000000..e96663d8b
--- /dev/null
+++ b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/ConsumerManager.java
@@ -0,0 +1,114 @@
+package io.confluent.parallelconsumer;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.kafka.clients.consumer.*;
+import org.apache.kafka.common.TopicPartition;
+import org.apache.kafka.common.errors.WakeupException;
+import pl.tlinkowski.unij.api.UniMaps;
+
+import java.time.Duration;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * Delegate for {@link KafkaConsumer}
+ */
+@Slf4j
+@RequiredArgsConstructor
+public class ConsumerManager<K, V> {
+
+    private final Consumer<K, V> consumer;
+
+    private final AtomicBoolean pollingBroker = new AtomicBoolean(false);
+
+    private int erroneousWakups = 0;
+    private int correctPollWakeups = 0;
+    private int noWakeups = 0;
+
+    ConsumerRecords<K, V> poll(Duration thisLongPollTimeout) {
+        ConsumerRecords<K, V> records;
+        try {
+            pollingBroker.set(true);
+            records = consumer.poll(thisLongPollTimeout);
+            log.debug("Poll completed normally and returned {}...", records.count());
+        } catch (WakeupException w) {
+            correctPollWakeups++;
+            log.debug("Awoken from broker poll", w);
+            records = new ConsumerRecords<>(UniMaps.of());
+        } finally {
+            pollingBroker.set(false);
+        }
+        return records;
+    }
+
+    /**
+     * Wakes up the consumer, but only if it's polling.
+     * <p>
+     * Otherwise we can interrupt other operations like {@link KafkaConsumer#commitSync()}.
+     */
+    public void wakeup() {
+        // boolean reduces the chances of a mis-timed call to wakeup, but doesn't prevent all spurious wake up calls to other methods like #commit
+        // if the call to wakeup happens /after/ the check for a wake up state inside #poll, then the next call will through the wake up exception (i.e. #commit)
+        if (pollingBroker.get()) {
+            log.debug("Waking up consumer");
+            consumer.wakeup();
+        }
+    }
+
+    public void commitSync(final Map<TopicPartition, OffsetAndMetadata> offsetsToSend) {
+        // we dont' want to be woken up during a commit, only polls
+        boolean inProgress = true;
+        noWakeups++;
+        while (inProgress) {
+            try {
+                consumer.commitSync(offsetsToSend);
+                inProgress = false;
+            } catch (WakeupException w) {
+                log.debug("Got woken up, retry. errors: " + erroneousWakups + " none: " + noWakeups + " correct:" + correctPollWakeups, w);
+                erroneousWakups++;
+            }
+        }
+    }
+
+    public void commitAsync(Map<TopicPartition, OffsetAndMetadata> offsets, OffsetCommitCallback callback) {
+        // we dont' want to be woken up during a commit, only polls
+        boolean inProgress = true;
+        noWakeups++;
+        while (inProgress) {
+            try {
+                consumer.commitAsync(offsets, callback);
+                inProgress = false;
+            } catch (WakeupException w) {
+                log.debug("Got woken up, retry. errors: " + erroneousWakups + " none: " + noWakeups + " correct:" + correctPollWakeups, w);
+                erroneousWakups++;
+            }
+        }
+    }
+
+    public ConsumerGroupMetadata groupMetadata() {
+        return consumer.groupMetadata();
+    }
+
+    public void close(final Duration defaultTimeout) {
+        consumer.close(defaultTimeout);
+    }
+
+    public Set<TopicPartition> assignment() {
+        return consumer.assignment();
+    }
+
+    public void pause(final Set<TopicPartition> assignment) {
+        consumer.pause(assignment);
+    }
+
+    public Set<TopicPartition> paused() {
+        return consumer.paused();
+    }
+
+    public void resume(final Set<TopicPartition> pausedTopics) {
+        consumer.resume(pausedTopics);
+    }
+
+}
diff --git a/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/ConsumerOffsetCommitter.java b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/ConsumerOffsetCommitter.java
new file mode 100644
index 000000000..bbe525851
--- /dev/null
+++ b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/ConsumerOffsetCommitter.java
@@ -0,0 +1,203 @@
+package io.confluent.parallelconsumer;
+
+import io.confluent.parallelconsumer.ParallelConsumerOptions.CommitMode;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.kafka.clients.consumer.ConsumerGroupMetadata;
+import org.apache.kafka.clients.consumer.OffsetAndMetadata;
+import org.apache.kafka.common.TopicPartition;
+
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.ReentrantLock;
+
+import static io.confluent.parallelconsumer.ParallelConsumerOptions.CommitMode.CONSUMER_SYNC;
+import static io.confluent.parallelconsumer.ParallelConsumerOptions.CommitMode.TRANSACTIONAL_PRODUCER;
+
+/**
+ * Committer that uses the Kafka Consumer to commit either synchronously or asynchronously
+ *
+ * @see CommitMode
+ */
+@Slf4j
+public class ConsumerOffsetCommitter<K, V> extends AbstractOffsetCommitter<K, V> implements OffsetCommitter {
+
+    private final CommitMode commitMode;
+
+    /**
+     * Used to synchronise threads on changing {@link #commitCount}, {@link #commitPerformed} and constructing the
+     * {@link Condition} to wait on, that's all.
+     */
+    private final ReentrantLock commitLock = new ReentrantLock(true);
+
+    /**
+     * Used to signal to waiting threads, that their commit has been performed when requested.
+     *
+     * @see #commitPerformed
+     * @see #commitAndWaitForCondition()
+     */
+    private Condition commitPerformed = commitLock.newCondition();
+
+    /**
+     * The number of commits made. Use as a logical clock to sanity check expectations and synchronisation when commits
+     * are requested versus performed.
+     */
+    private final AtomicLong commitCount = new AtomicLong(0);
+
+    /**
+     * Set to true when a thread requests a commit to be performed, by the controling thread.
+     */
+    private final AtomicBoolean commitRequested = new AtomicBoolean(false);
+
+    private Optional<Thread> owningThread = Optional.empty();
+
+    public ConsumerOffsetCommitter(final ConsumerManager<K, V> newConsumer, final WorkManager<K, V> newWorkManager, final ParallelConsumerOptions options) {
+        super(newConsumer, newWorkManager);
+        commitMode = options.getCommitMode();
+        if (commitMode.equals(TRANSACTIONAL_PRODUCER)) {
+            throw new IllegalArgumentException("Cannot use " + commitMode + " when using " + this.getClass().getSimpleName());
+        }
+    }
+
+    // todo abstraction leak - find another way
+    private boolean direct = false;
+
+    /**
+     * Might block if using {@link CommitMode#CONSUMER_SYNC}
+     *
+     * @see CommitMode
+     */
+    void commit() {
+        if (isOwner()) {
+            // if owning thread is asking, then perform the commit directly (this is the thread that controls the consumer)
+            // this can happen when the system is closing, using Consumer commit mode, and partitions are revoked and we want to commit
+            direct = true;
+            retrieveOffsetsAndCommit();
+        } else if (isSync()) {
+            log.debug("Sync commit");
+            commitAndWaitForCondition();
+            log.debug("Finished waiting");
+        } else {
+            // async
+            // we just request the commit and hope
+            log.debug("Async commit to be requested");
+            requestCommitInternal();
+        }
+    }
+
+    @Override
+    protected void commitOffsets(final Map<TopicPartition, OffsetAndMetadata> offsetsToSend, final ConsumerGroupMetadata groupMetadata) {
+        if (offsetsToSend.isEmpty()) {
+            log.trace("Nothing to commit");
+            return;
+        }
+        switch (commitMode) {
+            case CONSUMER_SYNC -> {
+                log.debug("Committing offsets Sync");
+                consumerMgr.commitSync(offsetsToSend);
+            }
+            case CONSUMER_ASYNCHRONOUS -> {
+                //
+                log.debug("Committing offsets Async");
+                consumerMgr.commitAsync(offsetsToSend, (offsets, exception) -> {
+                    if (exception != null) {
+                        log.error("Error committing offsets", exception);
+                        // todo keep work in limbo until async response is received?
+                    }
+                });
+            }
+            default -> {
+                throw new IllegalArgumentException("Cannot use " + commitMode + " when using " + this.getClass().getSimpleName());
+            }
+        }
+    }
+
+    /**
+     * @see #commit()
+     */
+    @Override
+    protected void postCommit() {
+        // only signal if we are in sync mode, and current thread isn't the owner (if we are owner, then we are committing directly)
+        if (!direct && commitMode.equals(CONSUMER_SYNC))
+            signalCommitPerformed();
+    }
+
+    private boolean isOwner() {
+        return Thread.currentThread().equals(owningThread.orElse(null));
+    }
+
+    private void signalCommitPerformed() {
+        log.debug("Starting Signaling commit finished");
+        if (!commitLock.isHeldByCurrentThread())
+            throw new IllegalStateException("Lock already held");
+        commitLock.lock();
+        try {
+            commitCount.incrementAndGet();
+            log.debug("Signaling commit finished");
+            commitPerformed.signalAll();
+            log.debug("Finished Signaling commit finished");
+        } finally {
+            commitLock.unlock();
+        }
+    }
+
+    private void commitAndWaitForCondition() {
+        commitLock.lock();
+
+        try {
+            this.commitPerformed = commitLock.newCondition();
+            long currentCount = commitCount.get();
+            requestCommitInternal();
+            consumerMgr.wakeup();
+            while (currentCount == commitCount.get()) {
+                if (currentCount == commitCount.get()) {
+                    log.debug("Requesting commit again");
+                    requestCommitInternal();
+                } else {
+                    commitRequested.set(false);
+                }
+                try {
+                    log.debug("Waiting on commit");
+                    commitPerformed.await();
+                } catch (InterruptedException e) {
+                    log.debug("Interrupted waiting for commit condition", e);
+                }
+            }
+            log.debug("Signaled");
+        } finally {
+            commitLock.unlock();
+        }
+    }
+
+    private void requestCommitInternal() {
+        commitLock.lock();
+        try {
+            commitRequested.set(true);
+            consumerMgr.wakeup();
+        } finally {
+            commitLock.unlock();
+        }
+
+    }
+
+    void maybeDoCommit() {
+        commitLock.lock();
+        try {
+            if (commitRequested.get()) {
+                retrieveOffsetsAndCommit();
+            }
+        } finally {
+            commitLock.unlock();
+        }
+    }
+
+    public boolean isSync() {
+        return commitMode.equals(CONSUMER_SYNC);
+    }
+
+    public void claim() {
+        owningThread = Optional.of(Thread.currentThread());
+    }
+}
diff --git a/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/ErrorInUserFunctionException.java b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/ErrorInUserFunctionException.java
new file mode 100644
index 000000000..d41b51594
--- /dev/null
+++ b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/ErrorInUserFunctionException.java
@@ -0,0 +1,10 @@
+package io.confluent.parallelconsumer;
+
+/**
+ * This exception is only used when there is an exception thrown from code provided by the user.
+ */
+public class ErrorInUserFunctionException extends RuntimeException {
+    public ErrorInUserFunctionException(final String message, final Throwable cause) {
+        super(message, cause);
+    }
+}
diff --git a/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/InternalError.java b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/InternalError.java
new file mode 100644
index 000000000..71c15870d
--- /dev/null
+++ b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/InternalError.java
@@ -0,0 +1,20 @@
+package io.confluent.parallelconsumer;
+
+public class InternalError extends RuntimeException {
+
+    public InternalError(final String message) {
+        super(message);
+    }
+
+    public InternalError(final String message, final Throwable cause) {
+        super(message, cause);
+    }
+
+    public InternalError(final Throwable cause) {
+        super(cause);
+    }
+
+    public InternalError(final String message, final Throwable cause, final boolean enableSuppression, final boolean writableStackTrace) {
+        super(message, cause, enableSuppression, writableStackTrace);
+    }
+}
diff --git a/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/JStreamParallelEoSStreamProcessor.java b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/JStreamParallelEoSStreamProcessor.java
index c0d93c568..db76b98a2 100644
--- a/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/JStreamParallelEoSStreamProcessor.java
+++ b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/JStreamParallelEoSStreamProcessor.java
@@ -7,7 +7,6 @@
 import io.confluent.csid.utils.Java8StreamUtils;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.kafka.clients.consumer.ConsumerRecord;
-import org.apache.kafka.clients.producer.Producer;
 import org.apache.kafka.clients.producer.ProducerRecord;
 
 import java.util.List;
@@ -22,10 +21,8 @@ public class JStreamParallelEoSStreamProcessor<K, V> extends ParallelEoSStreamPr
 
     private final ConcurrentLinkedDeque<ConsumeProduceResult<K, V, K, V>> userProcessResultsStream;
 
-    public JStreamParallelEoSStreamProcessor(org.apache.kafka.clients.consumer.Consumer<K, V> consumer,
-                                             Producer<K, V> producer,
-                                             ParallelConsumerOptions parallelConsumerOptions) {
-        super(consumer, producer, parallelConsumerOptions);
+    public JStreamParallelEoSStreamProcessor(ParallelConsumerOptions parallelConsumerOptions) {
+        super(parallelConsumerOptions);
 
         this.userProcessResultsStream = new ConcurrentLinkedDeque<>();
 
@@ -34,7 +31,7 @@ public JStreamParallelEoSStreamProcessor(org.apache.kafka.clients.consumer.Consu
 
     @Override
     public Stream<ConsumeProduceResult<K, V, K, V>> pollProduceAndStream(Function<ConsumerRecord<K, V>, List<ProducerRecord<K, V>>> userFunction) {
-        super.pollAndProduce(userFunction, (result) -> {
+        super.pollAndProduceMany(userFunction, (result) -> {
             log.trace("Wrapper callback applied, sending result to stream. Input: {}", result);
             this.userProcessResultsStream.add(result);
         });
diff --git a/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/JStreamParallelStreamProcessor.java b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/JStreamParallelStreamProcessor.java
index 0a27e3ef1..afd5424b0 100644
--- a/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/JStreamParallelStreamProcessor.java
+++ b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/JStreamParallelStreamProcessor.java
@@ -13,15 +13,12 @@
 
 public interface JStreamParallelStreamProcessor<K, V> extends DrainingCloseable {
 
-    static <KK, VV> JStreamParallelStreamProcessor<KK, VV> createJStreamEosStreamProcessor(
-            org.apache.kafka.clients.consumer.Consumer<KK, VV> consumer,
-            org.apache.kafka.clients.producer.Producer<KK, VV> producer,
-            ParallelConsumerOptions options) {
-        return new JStreamParallelEoSStreamProcessor<>(consumer, producer, options);
+    static <KK, VV> JStreamParallelStreamProcessor<KK, VV> createJStreamEosStreamProcessor(ParallelConsumerOptions options) {
+        return new JStreamParallelEoSStreamProcessor<>(options);
     }
 
     /**
-     * Like {@link ParallelEoSStreamProcessor#pollAndProduce} but instead of callbacks, streams the results instead,
+     * Like {@link ParallelEoSStreamProcessor#pollAndProduceMany} but instead of callbacks, streams the results instead,
      * after the produce result is ack'd by Kafka.
      *
      * @return a stream of results of applying the function to the polled records
diff --git a/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/OffsetCommitter.java b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/OffsetCommitter.java
new file mode 100644
index 000000000..19d40baa0
--- /dev/null
+++ b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/OffsetCommitter.java
@@ -0,0 +1,5 @@
+package io.confluent.parallelconsumer;
+
+public interface OffsetCommitter {
+    void retrieveOffsetsAndCommit();
+}
diff --git a/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/ParallelConsumerOptions.java b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/ParallelConsumerOptions.java
index a1ea68039..361476010 100644
--- a/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/ParallelConsumerOptions.java
+++ b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/ParallelConsumerOptions.java
@@ -6,14 +6,41 @@
 
 import lombok.Builder;
 import lombok.Getter;
+import lombok.ToString;
+import org.apache.kafka.clients.consumer.Consumer;
+import org.apache.kafka.clients.producer.Producer;
+
+import java.util.Objects;
+
+import static io.confluent.csid.utils.StringUtils.msg;
+import static io.confluent.parallelconsumer.ParallelConsumerOptions.CommitMode.TRANSACTIONAL_PRODUCER;
 
 /**
  * The options for the {@link ParallelEoSStreamProcessor} system.
+ *
+ * @see #builder()
+ * @see ParallelConsumerOptions.ParallelConsumerOptionsBuilder
  */
 @Getter
-@Builder
-public class ParallelConsumerOptions {
+@Builder(toBuilder = true)
+@ToString
+public class ParallelConsumerOptions<K, V> {
+
+    /**
+     * Required parameter for all use.
+     */
+    private final Consumer<K, V> consumer;
+
+    /**
+     * Supplying a producer is only needed if using the produce flows.
+     *
+     * @see ParallelStreamProcessor
+     */
+    private final Producer<K, V> producer;
 
+    /**
+     * The ordering guarantee to use.
+     */
     public enum ProcessingOrder {
         /**
          * No ordering is guaranteed, not even partition order. Fastest. Concurrency is at most the max number of
@@ -21,8 +48,8 @@ public enum ProcessingOrder {
          */
         UNORDERED,
         /**
-         * Process messages within a partition in order, but process multiple partitions in parallel. Similar to
-         * running more consumer for a topic. Concurrency is at most the number of partitions.
+         * Process messages within a partition in order, but process multiple partitions in parallel. Similar to running
+         * more consumer for a topic. Concurrency is at most the number of partitions.
          */
         PARTITION,
         /**
@@ -32,27 +59,90 @@ public enum ProcessingOrder {
         KEY
     }
 
+    /**
+     * The type of commit to be made, with either a transactions configured Producer where messages produced are
+     * committed back to the Broker along with the offsets they originated from, or with the faster simpler Consumer
+     * offset system either synchronously or asynchronously
+     */
+    public enum CommitMode {
+        /**
+         * Commits through the Producer using transactions. Slowest fot he options, but no duplicates in Kafka
+         * guaranteed (message replay may cause duplicates in external systems which is unavoidable with Kafka).
+         * <p>
+         * This is separate from using an IDEMPOTENT Producer, which can be used, along with {@link
+         * CommitMode#CONSUMER_SYNC} or {@link CommitMode#CONSUMER_ASYNCHRONOUS}.
+         */
+        TRANSACTIONAL_PRODUCER,
+        /**
+         * Synchronous commits with the Consumer. Much faster than {@link #TRANSACTIONAL_PRODUCER}. Slower but
+         * potentially less duplicates than {@link #CONSUMER_ASYNCHRONOUS} upon replay.
+         */
+        CONSUMER_SYNC,
+        /**
+         * Fastest option, under normal conditions will have few of no duplicates. Under failure revocery may have more
+         * duplicates than {@link #CONSUMER_SYNC}.
+         */
+        CONSUMER_ASYNCHRONOUS
+    }
+
     /**
      * The order type to use
      */
     @Builder.Default
     private final ProcessingOrder ordering = ProcessingOrder.UNORDERED;
 
+    @Builder.Default
+    private final CommitMode commitMode = CommitMode.CONSUMER_ASYNCHRONOUS;
+
     /**
-     * Don't have more than this many uncommitted messages in process
-     * TODO change this to per topic? global?
+     * Total max number of messages to process beyond the base committed offsets.
+     * <p>
+     * This acts as a sort sort of upper limit on the number of messages we should allow our system to handle, when
+     * working with large quantities of messages that haven't been included in the normal Broker offset commit protocol.
+     * I.e. if there is a single message that is failing to process, without this limit we will continue on forever with
+     * our system, with the actual (normal) committed offset never moving, and relying totally on our {@link
+     * OffsetMapCodecManager} to encode the process status of our records and store in metadata next to the committed
+     * offset.
+     * <p>
+     * At the moment this is a sort of sanity check, and was chosen rather arbitriarly. However, one should consider
+     * that this is per client, and is a total across all assigned partitions.
      */
     @Builder.Default
-    private final int maxUncommittedMessagesToHandlePerPartition = 1000;
+    private final int maxNumberMessagesBeyondBaseCommitOffset = 1000;
 
     /**
-     * Don't process any more than this many messages concurrently
+     * Max number of messages to queue up in our execution system and attempt to process concurrently.
+     * <p>
+     * In the core module, this will be constrained by the {@link #numberOfThreads} setting, as that is the max actual
+     * concurrency for processing the messages. To actually get this degree of concurrency, you would need to have a
+     * matching number of threads in the pool.
+     * <p>
+     * However with the VertX engine, this will control how many messages at a time are being submitted to the Vert.x
+     * engine to process. As Vert.x isn't constrained by a thread count, this will be the actual degree of concurrency.
      */
     @Builder.Default
-    private final int maxConcurrency = 100;
+    private final int maxMessagesToQueue = 100;
 
+    /**
+     * Number of threads to use in the core's thread pool.
+     */
     @Builder.Default
     private final int numberOfThreads = 16;
 
+    public void validate() {
+        Objects.requireNonNull(consumer, "A consumer must be supplied");
+
+        if (isUsingTransactionalProducer() && producer == null) {
+            throw new IllegalArgumentException(msg("Wanting to use Transaction Producer mode ({}) without supplying a Producer instance",
+                    commitMode));
+        }
+    }
 
+    protected boolean isUsingTransactionalProducer() {
+        return commitMode.equals(TRANSACTIONAL_PRODUCER);
+    }
+
+    public boolean isProducerSupplied() {
+        return getProducer() != null;
+    }
 }
diff --git a/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/ParallelEoSStreamProcessor.java b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/ParallelEoSStreamProcessor.java
index 98ffa39e6..c54c6bd7a 100644
--- a/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/ParallelEoSStreamProcessor.java
+++ b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/ParallelEoSStreamProcessor.java
@@ -10,7 +10,6 @@
 import org.apache.kafka.clients.consumer.*;
 import org.apache.kafka.clients.consumer.internals.ConsumerCoordinator;
 import org.apache.kafka.clients.producer.*;
-import org.apache.kafka.common.KafkaException;
 import org.apache.kafka.common.TopicPartition;
 import org.apache.kafka.common.utils.Time;
 import org.slf4j.MDC;
@@ -32,6 +31,7 @@
 import static io.confluent.csid.utils.BackportUtils.toSeconds;
 import static io.confluent.csid.utils.Range.range;
 import static io.confluent.csid.utils.StringUtils.msg;
+import static io.confluent.parallelconsumer.UserFunctions.carefullyRun;
 import static java.time.Duration.ofSeconds;
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import static java.util.concurrent.TimeUnit.SECONDS;
@@ -42,6 +42,8 @@
 @Slf4j
 public class ParallelEoSStreamProcessor<K, V> implements ParallelStreamProcessor<K, V>, ConsumerRebalanceListener, Closeable {
 
+    private final ParallelConsumerOptions options;
+
     /**
      * Injectable clock for testing
      */
@@ -54,9 +56,8 @@ public class ParallelEoSStreamProcessor<K, V> implements ParallelStreamProcessor
 
     private Instant lastCommit = Instant.now();
 
-    private boolean inTransaction = false;
+    private final Optional<ProducerManager<K, V>> producerManager;
 
-    private final org.apache.kafka.clients.producer.Producer<K, V> producer;
     private final org.apache.kafka.clients.consumer.Consumer<K, V> consumer;
 
     /**
@@ -95,13 +96,32 @@ public class ParallelEoSStreamProcessor<K, V> implements ParallelStreamProcessor
      */
     private final AtomicBoolean currentlyPollingWorkCompleteMailBox = new AtomicBoolean();
 
+    private final OffsetCommitter committer;
+
+    /**
+     * Used to request a commit asap
+     */
+    private final AtomicBoolean commitCommand = new AtomicBoolean(false);
+
     /**
      * The run state of the controller.
      *
      * @see #state
      */
     enum State {
-        unused, running, draining, closing, closed;
+        unused,
+        running,
+        /**
+         * When draining, the system will stop polling for more records, but will attempt to process all already
+         * downloaded records. Note that if you choose to close without draining, records already processed will still
+         * be committed first before closing.
+         *
+         * @see #closeDrainFirst()
+         * @see #close()
+         */
+        draining,
+        closing,
+        closed;
     }
 
     /**
@@ -122,47 +142,46 @@ enum State {
      *
      * @see ParallelConsumerOptions
      */
-    public ParallelEoSStreamProcessor(org.apache.kafka.clients.consumer.Consumer<K, V> consumer,
-                                      org.apache.kafka.clients.producer.Producer<K, V> producer,
-                                      ParallelConsumerOptions options) {
-        log.debug("Confluent async consumer initialise");
+    public ParallelEoSStreamProcessor(ParallelConsumerOptions newOptions) {
+        Objects.requireNonNull(newOptions, "Options must be supplied");
+
+        log.info("Confluent Parallel Consumer initialise... Options: {}", newOptions);
 
-        Objects.requireNonNull(consumer);
-        Objects.requireNonNull(producer);
-        Objects.requireNonNull(options);
+        options = newOptions;
+        options.validate();
+
+        this.consumer = options.getConsumer();
 
         checkNotSubscribed(consumer);
         checkAutoCommitIsDisabled(consumer);
 
-        //
-        this.producer = producer;
-        this.consumer = consumer;
+        this.workerPool = Executors.newFixedThreadPool(newOptions.getNumberOfThreads());
 
-        workerPool = Executors.newFixedThreadPool(options.getNumberOfThreads());
+        this.wm = new WorkManager<>(newOptions, consumer);
 
-        //
-        this.wm = new WorkManager<>(options, consumer);
+        ConsumerManager<K, V> consumerMgr = new ConsumerManager<>(consumer);
 
-        //
-        this.brokerPollSubsystem = new BrokerPollSystem<>(consumer, wm, this);
+        this.brokerPollSubsystem = new BrokerPollSystem<>(consumerMgr, wm, this, newOptions);
 
-        //
-        try {
-            log.debug("Initialising producer transaction session...");
-            producer.initTransactions();
-        } catch (KafkaException e) {
-            log.error("Make sure your producer is setup for transactions - specifically make sure it's {} is set.", ProducerConfig.TRANSACTIONAL_ID_CONFIG, e);
-            throw e;
+        if (options.isProducerSupplied()) {
+            this.producerManager = Optional.of(new ProducerManager<>(options.getProducer(), consumerMgr, this.wm, options));
+            if (options.isUsingTransactionalProducer())
+                this.committer = this.producerManager.get();
+            else
+                this.committer = this.brokerPollSubsystem;
+        } else {
+            this.producerManager = Optional.empty();
+            this.committer = this.brokerPollSubsystem;
         }
     }
 
-    private void checkNotSubscribed(org.apache.kafka.clients.consumer.Consumer<K, V> consumer) {
-        if (consumer instanceof MockConsumer)
+    private void checkNotSubscribed(org.apache.kafka.clients.consumer.Consumer<K, V> consumerToCheck) {
+        if (consumerToCheck instanceof MockConsumer)
             // disabled for unit tests which don't test rebalancing
             return;
-        Set<String> subscription = consumer.subscription();
-        Set<TopicPartition> assignment = consumer.assignment();
-        if (subscription.size() != 0 || assignment.size() != 0) {
+        Set<String> subscription = consumerToCheck.subscription();
+        Set<TopicPartition> assignment = consumerToCheck.assignment();
+        if (!subscription.isEmpty() || !assignment.isEmpty()) {
             throw new IllegalStateException("Consumer subscription must be managed by this class. Use " + this.getClass().getName() + "#subcribe methods instead.");
         }
     }
@@ -195,12 +214,19 @@ public void subscribe(Pattern pattern, ConsumerRebalanceListener callback) {
 
     /**
      * Commit our offsets
+     * <p>
+     * Make sure the calling thread is the thread which performs commit - i.e. is the {@link OffsetCommitter}.
      */
     @Override
     public void onPartitionsRevoked(Collection<TopicPartition> partitions) {
-        commitOffsetsThatAreReady();
-        wm.onPartitionsRevoked(partitions);
-        usersConsumerRebalanceListener.ifPresent(x -> x.onPartitionsRevoked(partitions));
+        try {
+            log.debug("Partitions revoked (onPartitionsRevoked), state: {}", state);
+            commitOffsetsThatAreReady();
+            wm.onPartitionsRevoked(partitions);
+            usersConsumerRebalanceListener.ifPresent(x -> x.onPartitionsRevoked(partitions));
+        } catch (Exception e) {
+            throw new InternalError("onPartitionsRevoked event error", e);
+        }
     }
 
     /**
@@ -255,7 +281,10 @@ private void checkAutoCommitIsDisabled(org.apache.kafka.clients.consumer.Consume
     public void poll(Consumer<ConsumerRecord<K, V>> usersVoidConsumptionFunction) {
         Function<ConsumerRecord<K, V>, List<Object>> wrappedUserFunc = (record) -> {
             log.trace("asyncPoll - Consumed a record ({}), executing void function...", record.offset());
-            usersVoidConsumptionFunction.accept(record);
+
+            carefullyRun(usersVoidConsumptionFunction, record);
+
+            log.trace("asyncPoll - user function finished ok.");
             return UniLists.of(); // user function returns no produce records, so we satisfy our api
         };
         Consumer<Object> voidCallBack = (ignore) -> log.trace("Void callback applied.");
@@ -264,19 +293,26 @@ public void poll(Consumer<ConsumerRecord<K, V>> usersVoidConsumptionFunction) {
 
     @Override
     @SneakyThrows
-    public void pollAndProduce(Function<ConsumerRecord<K, V>, List<ProducerRecord<K, V>>> userFunction,
-                               Consumer<ConsumeProduceResult<K, V, K, V>> callback) {
+    public void pollAndProduceMany(Function<ConsumerRecord<K, V>, List<ProducerRecord<K, V>>> userFunction,
+                                   Consumer<ConsumeProduceResult<K, V, K, V>> callback) {
+        // todo refactor out the producer system to a sub class
+        if (!options.isProducerSupplied()) {
+            throw new IllegalArgumentException("To use the produce flows you must supply a Producer in the options");
+        }
+
         // wrap user func to add produce function
         Function<ConsumerRecord<K, V>, List<ConsumeProduceResult<K, V, K, V>>> wrappedUserFunc = (consumedRecord) -> {
-            List<ProducerRecord<K, V>> recordListToProduce = userFunction.apply(consumedRecord);
+
+            List<ProducerRecord<K, V>> recordListToProduce = carefullyRun(userFunction, consumedRecord);
+
             if (recordListToProduce.isEmpty()) {
                 log.warn("No result returned from function to send.");
             }
-            log.trace("asyncPoll and Stream - Consumed and a record ({}), and returning a derivative result record to be produced: {}", consumedRecord, recordListToProduce);
+            log.trace("asyncPoll and Stream - Consumed a record ({}), and returning a derivative result record to be produced: {}", consumedRecord, recordListToProduce);
 
             List<ConsumeProduceResult<K, V, K, V>> results = new ArrayList<>();
             for (ProducerRecord<K, V> toProduce : recordListToProduce) {
-                RecordMetadata produceResultMeta = produceMessage(toProduce);
+                RecordMetadata produceResultMeta = producerManager.get().produceMessage(toProduce);
                 var result = new ConsumeProduceResult<>(consumedRecord, toProduce, produceResultMeta);
                 results.add(result);
             }
@@ -286,35 +322,41 @@ public void pollAndProduce(Function<ConsumerRecord<K, V>, List<ProducerRecord<K,
         supervisorLoop(wrappedUserFunc, callback);
     }
 
+    @Override
+    @SneakyThrows
+    public void pollAndProduceMany(Function<ConsumerRecord<K, V>, List<ProducerRecord<K, V>>> userFunction) {
+        pollAndProduceMany(userFunction, (record) -> {
+            // no op call back
+            log.trace("No-op user callback");
+        });
+    }
+
+    @Override
+    @SneakyThrows
+    public void pollAndProduce(Function<ConsumerRecord<K, V>, ProducerRecord<K, V>> userFunction) {
+        pollAndProduce(userFunction, (record) -> {
+            // no op call back
+            log.trace("No-op user callback");
+        });
+    }
+
+    @Override
+    @SneakyThrows
+    public void pollAndProduce(Function<ConsumerRecord<K, V>, ProducerRecord<K, V>> userFunction,
+                               Consumer<ConsumeProduceResult<K, V, K, V>> callback) {
+        pollAndProduceMany((record) -> UniLists.of(userFunction.apply(record)), callback);
+    }
+
     /**
-     * Produce a message back to the broker.
-     * <p>
-     * Implementation uses the blocking API, performance upgrade in later versions, is not an issue for the common use
-     * case ({@link #poll(Consumer)}).
+     * Close the system, without draining.
      *
-     * @see #pollAndProduce(Function, Consumer)
+     * @see State#draining
      */
-    RecordMetadata produceMessage(ProducerRecord<K, V> outMsg) {
-        // only needed if not using tx
-        Callback callback = (RecordMetadata metadata, Exception exception) -> {
-            if (exception != null) {
-                log.error("Error producing result message", exception);
-                throw new RuntimeException("Error producing result message", exception);
-            }
-        };
-        Future<RecordMetadata> send = producer.send(outMsg, callback);
-        try {
-            return send.get();
-        } catch (Exception e) {
-            throw new RuntimeException(e);
-        }
-    }
-
     @Override
     public void close() {
         // use a longer timeout, to cover for evey other step using the default
         Duration timeout = DrainingCloseable.DEFAULT_TIMEOUT.multipliedBy(2);
-        closeDrainFirst(timeout);
+        closeDontDrainFirst(timeout);
     }
 
     @Override
@@ -325,20 +367,22 @@ public void close(Duration timeout, DrainingMode drainMode) {
         } else {
             log.info("Signaling to close...");
 
-            switch (drainMode){
-                case DRAIN:
+            switch (drainMode) {
+                case DRAIN -> {
                     log.info("Will wait for all in flight to complete before");
                     transitionToDraining();
-                case DONT_DRAIN:
+                }
+                case DONT_DRAIN -> {
                     log.info("Not waiting for in flight to complete, will transition directly to closing");
                     transitionToClosing();
+                }
             }
 
             waitForClose(timeout);
         }
 
         if (controlThreadFuture.isPresent()) {
-            log.trace("Checking for control thread exception...");
+            log.debug("Checking for control thread exception...");
             Future<?> future = controlThreadFuture.get();
             future.get(toSeconds(timeout), SECONDS); // throws exception if supervisor saw one
         }
@@ -349,18 +393,22 @@ public void close(Duration timeout, DrainingMode drainMode) {
     private void waitForClose(Duration timeout) throws TimeoutException, ExecutionException {
         log.info("Waiting on closed state...");
         while (!state.equals(closed)) {
-            log.trace("Still waiting for system to close...");
             try {
-                boolean signaled = this.controlThreadFuture.get().get(toSeconds(timeout), SECONDS);
+                Future<Boolean> booleanFuture = this.controlThreadFuture.get();
+                log.debug("Blocking on control future");
+                boolean signaled = booleanFuture.get(toSeconds(timeout), SECONDS);
                 if (!signaled)
                     throw new TimeoutException("Timeout waiting for system to close (" + timeout + ")");
             } catch (InterruptedException e) {
                 // ignore
                 log.trace("Interrupted", e);
             } catch (ExecutionException | TimeoutException e) {
-                log.error("Execution or timeout exception", e);
+                log.error("Execution or timeout exception while waiting for the control thread to close cleanly " +
+                        "(state was {}). Try increasing your time-out to allow the system to drain, or close withing " +
+                        "draining.", state, e);
                 throw e;
             }
+            log.trace("Still waiting for system to close...");
         }
     }
 
@@ -371,12 +419,9 @@ private void doClose(Duration timeout) throws TimeoutException, ExecutionExcepti
         log.debug("Closing and waiting for broker poll system...");
         brokerPollSubsystem.closeAndWait();
 
-        log.debug("Closing producer, assuming no more in flight...");
-        if (this.inTransaction) {
-            // close started after tx began, but before work was done, otherwise a tx wouldn't have been started
-            producer.abortTransaction();
-        }
-        producer.close(timeout);
+        maybeCloseConsumer();
+
+        producerManager.ifPresent(x -> x.close(timeout));
 
         log.debug("Shutting down execution pool...");
         List<Runnable> unfinished = workerPool.shutdownNow();
@@ -387,7 +432,7 @@ private void doClose(Duration timeout) throws TimeoutException, ExecutionExcepti
         log.trace("Awaiting worker pool termination...");
         boolean interrupted = true;
         while (interrupted) {
-            log.warn("Still interrupted");
+            log.debug("Still interrupted");
             try {
                 boolean terminationFinishedWithoutTimeout = workerPool.awaitTermination(toSeconds(DrainingCloseable.DEFAULT_TIMEOUT), SECONDS);
                 interrupted = false;
@@ -406,26 +451,43 @@ private void doClose(Duration timeout) throws TimeoutException, ExecutionExcepti
         this.state = closed;
     }
 
+    /**
+     * To keep things simple, make sure the correct thread which can make a commit, is the one to close the consumer.
+     * This way, if partitions are revoked, the commit can be made inline.
+     */
+    private void maybeCloseConsumer() {
+        if (isResponsibleForCommits()) {
+            consumer.close();
+        }
+    }
+
+    private boolean isResponsibleForCommits() {
+        return (committer instanceof ProducerManager);
+    }
+
     /**
      * Block the calling thread until no more messages are being processed.
      */
     @SneakyThrows
-    public void waitForNoInFlight(Duration timeout) {
-        log.debug("Waiting for no in flight...");
+    public void waitForProcessedNotCommitted(Duration timeout) {
+        log.debug("Waiting processed but not committed...");
         var timer = Time.SYSTEM.timer(timeout);
-        while (!noInFlight()) {
-            log.trace("Waiting for no in flight...");
+        while (wm.isRecordsAwaitingToBeCommitted()) {
+            log.trace("Waiting for no in processing...");
             Thread.sleep(100);
             timer.update();
             if (timer.isExpired()) {
-                throw new TimeoutException("Waiting for no more records in-flight");
+                throw new TimeoutException("Waiting for no more records in processing");
             }
         }
         log.debug("No longer anything in flight.");
     }
 
-    private boolean noInFlight() {
-        return !wm.isWorkRemaining() || areMyThreadsDone();
+    private boolean isRecordsAwaitingProcessing() {
+        boolean isRecordsAwaitingProcessing = wm.isRecordsAwaitingProcessing();
+        boolean threadsDone = areMyThreadsDone();
+        log.trace("isRecordsAwaitingProcessing {} || threadsDone {}", isRecordsAwaitingProcessing, threadsDone);
+        return isRecordsAwaitingProcessing || threadsDone;
     }
 
     private void transitionToDraining() {
@@ -462,6 +524,8 @@ private boolean areMyThreadsDone() {
      */
     protected <R> void supervisorLoop(Function<ConsumerRecord<K, V>, List<R>> userFunction,
                                       Consumer<R> callback) {
+        log.info("Control loop starting up...");
+
         if (state != State.unused) {
             throw new IllegalStateException(msg("Invalid state - the consumer cannot be used more than once (current " +
                     "state is {})", state));
@@ -469,26 +533,22 @@ protected <R> void supervisorLoop(Function<ConsumerRecord<K, V>, List<R>> userFu
             state = running;
         }
 
-        //
-        producer.beginTransaction();
-        this.inTransaction = true;
-
         // run main pool loop in thread
         Callable<Boolean> controlTask = () -> {
-            log.trace("Control task scheduled");
             Thread controlThread = Thread.currentThread();
             controlThread.setName("control");
+            log.trace("Control task scheduled");
             this.blockableControlThread = controlThread;
             while (state != closed) {
                 try {
                     controlLoop(userFunction, callback);
                 } catch (Exception e) {
-                    log.error("Error from poll control thread ({}), will attempt controlled shutdown, then rethrow...", e.getMessage(), e);
+                    log.error("Error from poll control thread, will attempt controlled shutdown, then rethrow. Error: " + e.getMessage(), e);
                     doClose(DrainingCloseable.DEFAULT_TIMEOUT); // attempt to close
                     throw new RuntimeException("Error from poll control thread: " + e.getMessage(), e);
                 }
             }
-            log.trace("Poll task ended (state:{}).", state);
+            log.info("Control loop ending clean (state:{})...", state);
             return true;
         };
 
@@ -503,8 +563,8 @@ protected <R> void supervisorLoop(Function<ConsumerRecord<K, V>, List<R>> userFu
      * Main control loop
      */
     private <R> void controlLoop(Function<ConsumerRecord<K, V>, List<R>> userFunction,
-                                 Consumer<R> callback) throws TimeoutException, ExecutionException {
-        if (state == running) {
+                                 Consumer<R> callback) throws TimeoutException, ExecutionException, InterruptedException {
+        if (state == running || state == draining) {
             log.trace("Loop: Get work");
             var records = wm.<R>maybeGetWork();
 
@@ -512,11 +572,21 @@ private <R> void controlLoop(Function<ConsumerRecord<K, V>, List<R>> userFunctio
             submitWorkToPool(userFunction, callback, records);
         }
 
+        if (state == running) {
+            if (!wm.isSufficientlyLoaded()) {
+                log.debug("Found not enough messages queued up, ensuring poller is awake");
+                brokerPollSubsystem.wakeup();
+            }
+        }
+
         log.trace("Loop: Process mailbox");
         processWorkCompleteMailBox();
 
-        log.trace("Loop: Maybe commit");
-        commitOffsetsMaybe();
+        if (state == running) {
+            // offsets will be committed when the consumer has its partitions revoked
+            log.trace("Loop: Maybe commit");
+            commitOffsetsMaybe();
+        }
 
         // run call back
         log.trace("Loop: Running {} loop end plugin(s)", controlLoopHooks.size());
@@ -524,10 +594,17 @@ private <R> void controlLoop(Function<ConsumerRecord<K, V>, List<R>> userFunctio
 
         log.debug("Current state: {}", state);
         switch (state) {
-            case draining -> drain();
-            case closing -> doClose(DrainingCloseable.DEFAULT_TIMEOUT);
+            case draining -> {
+                drain();
+            }
+            case closing -> {
+                doClose(DrainingCloseable.DEFAULT_TIMEOUT);
+            }
         }
 
+        // sanity - supervise the poller
+        brokerPollSubsystem.supervise();
+
         // end of loop
         log.trace("End of control loop, {} remaining in work manager. In state: {}", wm.getPartitionWorkRemainingCount(), state);
     }
@@ -535,7 +612,7 @@ private <R> void controlLoop(Function<ConsumerRecord<K, V>, List<R>> userFunctio
     private void drain() {
         log.debug("Signaling to drain...");
         brokerPollSubsystem.drain();
-        if (noInFlight()) {
+        if (!isRecordsAwaitingProcessing()) {
             transitionToClosing();
         }
     }
@@ -563,7 +640,7 @@ private void processWorkCompleteMailBox() {
         // blocking get the head of the queue
         WorkContainer<K, V> firstBlockingPoll = null;
         try {
-            log.debug("Blocking until next scheduled offset commit attempt for {}", timeout);
+            log.debug("Blocking poll on work until next scheduled offset commit attempt for {}", timeout);
             currentlyPollingWorkCompleteMailBox.getAndSet(true);
             // wait for work, with a timeout for sanity
             firstBlockingPoll = workMailBox.poll(timeout.toMillis(), MILLISECONDS);
@@ -587,7 +664,7 @@ private void processWorkCompleteMailBox() {
             try {
                 secondPollNonBlocking = workMailBox.poll(0, SECONDS);
             } catch (InterruptedException e) {
-                log.warn("Interrupted waiting on work results", e);
+                log.debug("Interrupted waiting on work results", e);
             }
             if (secondPollNonBlocking != null) {
                 results.add(secondPollNonBlocking);
@@ -608,9 +685,10 @@ private void processWorkCompleteMailBox() {
     private void commitOffsetsMaybe() {
         Duration elapsedSinceLast = getTimeSinceLastCommit();
         boolean commitFrequencyOK = toSeconds(elapsedSinceLast) >= toSeconds(timeBetweenCommits);
-        if (commitFrequencyOK || lingeringOnCommitWouldBeBeneficial()) {
+        boolean shouldCommitNow = commitFrequencyOK || !lingeringOnCommitWouldBeBeneficial() || isCommandedToCommit();
+        if (shouldCommitNow) {
             if (!commitFrequencyOK) {
-                log.trace("Commit too frequent, but no benefit in lingering");
+                log.debug("Commit too frequent, but no benefit in lingering");
             }
             commitOffsetsThatAreReady();
             lastCommit = Instant.now();
@@ -629,21 +707,22 @@ private void commitOffsetsMaybe() {
      * @return
      */
     private boolean lingeringOnCommitWouldBeBeneficial() {
-        // no work is waiting to be done
+        // work is waiting to be done
         boolean workIsWaitingToBeCompletedSuccessfully = wm.workIsWaitingToBeCompletedSuccessfully();
         // no work is currently being done
-        boolean noWorkInFlight = wm.hasWorkInFlight();
+        boolean noWorkInFlight = !wm.hasWorkInFlight();
         // work mailbox is empty
-        boolean workMailBoxEmpty = workMailBox.isEmpty();
-
-        return workIsWaitingToBeCompletedSuccessfully || noWorkInFlight || workMailBoxEmpty;
+        boolean workWaitingInMailbox = !workMailBox.isEmpty();
+        log.trace("workIsWaitingToBeCompletedSuccessfully {} || noWorkInFlight {} || workWaitingInMailbox {};", workIsWaitingToBeCompletedSuccessfully, noWorkInFlight, workWaitingInMailbox);
+        return workIsWaitingToBeCompletedSuccessfully || noWorkInFlight || workWaitingInMailbox;
     }
 
     private Duration getTimeToNextCommit() {
-        if (state == running) {
+        // draining is a normal running mode for the controller
+        if (state == running || state == draining) {
             return getTimeBetweenCommits().minus(getTimeSinceLastCommit());
         } else {
-            log.debug("System not {}, so don't wait to commit", running);
+            log.debug("System not {} (state: {}), so don't wait to commit, only a small thread yield time", running, state);
             return Duration.ZERO;
         }
     }
@@ -653,61 +732,8 @@ private Duration getTimeSinceLastCommit() {
         return Duration.between(lastCommit, now);
     }
 
-    /**
-     * Get offsets from {@link WorkManager} that are ready to commit
-     */
     private void commitOffsetsThatAreReady() {
-        log.trace("Loop: Find completed work to commit offsets");
-        // todo shouldn't be removed until commit succeeds (there's no harm in committing the same offset twice)
-        Map<TopicPartition, OffsetAndMetadata> offsetsToSend = wm.findCompletedEligibleOffsetsAndRemove();
-        if (offsetsToSend.isEmpty()) {
-            log.trace("No offsets ready");
-        } else {
-            log.debug("Committing offsets for {} partition(s): {}", offsetsToSend.size(), offsetsToSend);
-            ConsumerGroupMetadata groupMetadata = consumer.groupMetadata();
-
-            producer.sendOffsetsToTransaction(offsetsToSend, groupMetadata);
-            // see {@link KafkaProducer#commit} this can be interrupted and is safe to retry
-            boolean notCommitted = true;
-            int retryCount = 0;
-            int arbitrarilyChosenLimitForArbitraryErrorSituation = 200;
-            Exception lastErrorSavedForRethrow = null;
-            while (notCommitted) {
-                if (retryCount > arbitrarilyChosenLimitForArbitraryErrorSituation) {
-                    String msg = msg("Retired too many times ({} > limit of {}), giving up. See error above.", retryCount, arbitrarilyChosenLimitForArbitraryErrorSituation);
-                    log.error(msg, lastErrorSavedForRethrow);
-                    throw new RuntimeException(msg, lastErrorSavedForRethrow);
-                }
-                try {
-                    if (producer instanceof MockProducer) {
-                        // see bug https://issues.apache.org/jira/browse/KAFKA-10382
-                        // KAFKA-10382 - MockProducer is not ThreadSafe, ideally it should be as the implementation it mocks is
-                        synchronized (producer) {
-                            producer.commitTransaction();
-                        }
-                    } else {
-                        producer.commitTransaction();
-                    }
-
-                    this.inTransaction = false;
-
-                    wm.onOffsetCommitSuccess(offsetsToSend);
-
-                    notCommitted = false;
-                    if (retryCount > 0) {
-                        log.warn("Commit success, but took {} tries.", retryCount);
-                    }
-                } catch (Exception e) {
-                    log.warn("Commit exception, will retry, have tried {} times (see KafkaProducer#commit)", retryCount, e);
-                    lastErrorSavedForRethrow = e;
-                    retryCount++;
-                }
-            }
-
-            // begin tx for next cycle
-            producer.beginTransaction();
-            this.inTransaction = true;
-        }
+        committer.retrieveOffsetsAndCommit();
     }
 
     protected void handleFutureResult(WorkContainer<K, V> wc) {
@@ -737,14 +763,16 @@ protected void onSuccess(WorkContainer<K, V> wc) {
     private <R> void submitWorkToPool(Function<ConsumerRecord<K, V>, List<R>> usersFunction,
                                       Consumer<R> callback,
                                       List<WorkContainer<K, V>> workToProcess) {
-
-        for (var work : workToProcess) {
-            // for each record, construct dispatch to the executor and capture a Future
-            log.trace("Sending work ({}) to pool", work);
-            Future outputRecordFuture = workerPool.submit(() -> {
-                return userFunctionRunner(usersFunction, callback, work);
-            });
-            work.setFuture(outputRecordFuture);
+        if (!workToProcess.isEmpty()) {
+            log.debug("New work incoming: {}, Pool stats: {}", workToProcess.size(), workerPool);
+            for (var work : workToProcess) {
+                // for each record, construct dispatch to the executor and capture a Future
+                log.trace("Sending work ({}) to pool", work);
+                Future outputRecordFuture = workerPool.submit(() -> {
+                    return userFunctionRunner(usersFunction, callback, work);
+                });
+                work.setFuture(outputRecordFuture);
+            }
         }
     }
 
@@ -777,14 +805,13 @@ protected <R> List<Tuple<ConsumerRecord<K, V>, R>> userFunctionRunner(Function<C
             return intermediateResults;
         } catch (Exception e) {
             // handle fail
-            log.debug("Error in user function", e);
+            log.debug("Error processing record", e);
             wc.onUserFunctionFailure();
             addToMailbox(wc); // always add on error
             throw e; // trow again to make the future failed
         }
     }
 
-
     protected void addToMailBoxOnUserFunctionSuccess(WorkContainer<K, V> wc, List<?> resultsFromUserFunction) {
         addToMailbox(wc);
     }
@@ -797,6 +824,7 @@ protected void onUserFunctionSuccess(WorkContainer<K, V> wc, List<?> resultsFrom
     protected void addToMailbox(WorkContainer<K, V> wc) {
         log.trace("Adding {} to mailbox...", wc);
         workMailBox.add(wc);
+        log.trace("Finished adding. {}", wc);
     }
 
     /**
@@ -809,8 +837,12 @@ protected void addToMailbox(WorkContainer<K, V> wc) {
      */
     void notifyNewWorkRegistered() {
         if (currentlyPollingWorkCompleteMailBox.get()) {
-            log.trace("Interrupting control thread: Knock knock, wake up! You've got mail (tm)!");
-            this.blockableControlThread.interrupt();
+            if (producerManager.isPresent() && !producerManager.get().isTransactionInProgress()) {
+                log.trace("Interrupting control thread: Knock knock, wake up! You've got mail (tm)!");
+                this.blockableControlThread.interrupt();
+            } else {
+                log.trace("Would have interrupted control thread, but TX in progress");
+            }
         } else {
             log.trace("Work box not being polled currently, so thread not blocked, will come around to the bail box in the next looop.");
         }
@@ -834,4 +866,25 @@ public void setLongPollTimeout(Duration ofMillis) {
         BrokerPollSystem.setLongPollTimeout(ofMillis);
     }
 
+    /**
+     * Request a commit as soon as possible (ASAP), overriding other constraints.
+     */
+    public void requestCommitAsap() {
+        log.debug("Registering command to commit next chance");
+        synchronized (commitCommand) {
+            this.commitCommand.set(true);
+        }
+    }
+
+    private boolean isCommandedToCommit() {
+        synchronized (commitCommand) {
+            boolean commitAsap = this.commitCommand.get();
+            if (commitAsap) {
+                log.debug("Command to commit asap received, clearing");
+                this.commitCommand.set(false);
+            }
+            return commitAsap;
+        }
+    }
+
 }
diff --git a/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/ParallelStreamProcessor.java b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/ParallelStreamProcessor.java
index 79c6ee17f..902580931 100644
--- a/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/ParallelStreamProcessor.java
+++ b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/ParallelStreamProcessor.java
@@ -18,17 +18,39 @@
  * Parallel message consumer which also can optionally produce 0 or many {@link ProducerRecord} results to be published
  * back to Kafka.
  *
- * @see #pollAndProduce(Function, Consumer)
+ * @see #pollAndProduce 
+ * @see #pollAndProduceMany
  */
 public interface ParallelStreamProcessor<K, V> extends ParallelConsumer<K, V>, DrainingCloseable {
 
-    static <KK, VV> ParallelStreamProcessor<KK, VV> createEosStreamProcessor(
-            org.apache.kafka.clients.consumer.Consumer<KK, VV> consumer,
-            org.apache.kafka.clients.producer.Producer<KK, VV> producer,
-            ParallelConsumerOptions options) {
-        return new ParallelEoSStreamProcessor<>(consumer, producer, options);
+    static <KK, VV> ParallelStreamProcessor<KK, VV> createEosStreamProcessor(ParallelConsumerOptions<KK, VV> options) {
+        return new ParallelEoSStreamProcessor(options);
     }
 
+    /**
+     * Register a function to be applied in parallel to each received message, which in turn returns one or more {@link
+     * ProducerRecord}s to be sent back to the broker.
+     *
+     * @param callback applied after the produced message is acknowledged by kafka
+     */
+    @SneakyThrows
+    void pollAndProduceMany(Function<ConsumerRecord<K, V>, List<ProducerRecord<K, V>>> userFunction,
+                            Consumer<ConsumeProduceResult<K, V, K, V>> callback);
+
+    /**
+     * Register a function to be applied in parallel to each received message, which in turn returns one or many {@link
+     * ProducerRecord}s to be sent back to the broker.
+     */
+    @SneakyThrows
+    void pollAndProduceMany(Function<ConsumerRecord<K, V>, List<ProducerRecord<K, V>>> userFunction);
+
+    /**
+     * Register a function to be applied in parallel to each received message, which in turn returns a {@link
+     * ProducerRecord} to be sent back to the broker.
+     */
+    @SneakyThrows
+    void pollAndProduce(Function<ConsumerRecord<K, V>, ProducerRecord<K, V>> userFunction);
+
     /**
      * Register a function to be applied in parallel to each received message, which in turn returns a {@link
      * ProducerRecord} to be sent back to the broker.
@@ -36,7 +58,7 @@ static <KK, VV> ParallelStreamProcessor<KK, VV> createEosStreamProcessor(
      * @param callback applied after the produced message is acknowledged by kafka
      */
     @SneakyThrows
-    void pollAndProduce(Function<ConsumerRecord<K, V>, List<ProducerRecord<K, V>>> userFunction,
+    void pollAndProduce(Function<ConsumerRecord<K, V>, ProducerRecord<K, V>> userFunction,
                         Consumer<ConsumeProduceResult<K, V, K, V>> callback);
 
     /**
diff --git a/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/ProducerManager.java b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/ProducerManager.java
new file mode 100644
index 000000000..cab36250e
--- /dev/null
+++ b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/ProducerManager.java
@@ -0,0 +1,313 @@
+package io.confluent.parallelconsumer;
+
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.kafka.clients.consumer.ConsumerGroupMetadata;
+import org.apache.kafka.clients.consumer.OffsetAndMetadata;
+import org.apache.kafka.clients.producer.*;
+import org.apache.kafka.clients.producer.internals.TransactionManager;
+import org.apache.kafka.common.KafkaException;
+import org.apache.kafka.common.TopicPartition;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.time.Duration;
+import java.util.ConcurrentModificationException;
+import java.util.Map;
+import java.util.concurrent.Future;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+import static io.confluent.csid.utils.StringUtils.msg;
+import static io.confluent.parallelconsumer.ParallelEoSStreamProcessor.State.closing;
+
+@Slf4j
+public class ProducerManager<K, V> extends AbstractOffsetCommitter<K, V> implements OffsetCommitter {
+
+    protected final Producer<K, V> producer;
+
+    private final ParallelConsumerOptions options;
+
+    private final boolean producerIsConfiguredForTransactions;
+
+    /**
+     * The {@link KafkaProducer) isn't actually completely thread safe, at least when using it transactionally. We must
+     * be careful not to send messages to the producer, while we are committing a transaction - "Cannot call send in
+     * state COMMITTING_TRANSACTION".
+     */
+    private ReentrantReadWriteLock producerTransactionLock;
+
+    // nasty reflection
+    private Field txManagerField;
+    private Method txManagerMethodIsCompleting;
+    private Method txManagerMethodIsReady;
+
+    public ProducerManager(final Producer<K, V> newProducer, final ConsumerManager<K, V> newConsumer, final WorkManager<K, V> wm, ParallelConsumerOptions options) {
+        super(newConsumer, wm);
+        this.producer = newProducer;
+        this.options = options;
+
+        producerIsConfiguredForTransactions = setupReflection();
+
+        initProducer();
+    }
+
+    private void initProducer() {
+        producerTransactionLock = new ReentrantReadWriteLock(true);
+
+        // String transactionIdProp = options.getProducerConfig().getProperty(ProducerConfig.TRANSACTIONAL_ID_CONFIG);
+        // boolean txIdSupplied = isBlank(transactionIdProp);
+        if (options.isUsingTransactionalProducer()) {
+            if (!producerIsConfiguredForTransactions) {
+                throw new IllegalArgumentException("Using transactional option, yet Producer doesn't have a transaction ID - Producer needs a transaction id");
+            }
+            try {
+                log.debug("Initialising producer transaction session...");
+                producer.initTransactions();
+                producer.beginTransaction();
+            } catch (KafkaException e) {
+                log.error("Make sure your producer is setup for transactions - specifically make sure it's {} is set.", ProducerConfig.TRANSACTIONAL_ID_CONFIG, e);
+                throw e;
+            }
+        } else {
+            if (producerIsConfiguredForTransactions) {
+                throw new IllegalArgumentException("Using non-transactional producer option, but Producer has a transaction ID - " +
+                        "the Producer must not have a transaction ID for this option. This is because having such an ID forces the " +
+                        "Producer into transactional mode - i.e. you cannot use it without using transactions.");
+            }
+        }
+    }
+
+    /**
+     * Nasty reflection but better than relying on user supplying their config
+     *
+     * @see ParallelEoSStreamProcessor#checkAutoCommitIsDisabled
+     */
+    @SneakyThrows
+    private boolean getProducerIsTransactional() {
+        if (producer instanceof MockProducer) {
+            // can act as both, delegate to user selection
+            return options.isUsingTransactionalProducer();
+        } else {
+            TransactionManager transactionManager = getTransactionManager();
+            if (transactionManager == null) {
+                return false;
+            } else {
+                return transactionManager.isTransactional();
+            }
+        }
+    }
+
+    @SneakyThrows
+    private TransactionManager getTransactionManager() {
+        if (txManagerField == null) return null;
+        TransactionManager transactionManager = (TransactionManager) txManagerField.get(producer);
+        return transactionManager;
+    }
+
+    /**
+     * Produce a message back to the broker.
+     * <p>
+     * Implementation uses the blocking API, performance upgrade in later versions, is not an issue for the more common
+     * use case where messages aren't produced.
+     *
+     * @see ParallelConsumer#poll
+     * @see ParallelStreamProcessor#pollAndProduceMany
+     */
+    RecordMetadata produceMessage(ProducerRecord<K, V> outMsg) {
+        // only needed if not using tx
+        Callback callback = (RecordMetadata metadata, Exception exception) -> {
+            if (exception != null) {
+                log.error("Error producing result message", exception);
+                throw new RuntimeException("Error producing result message", exception);
+            }
+        };
+
+        ReentrantReadWriteLock.ReadLock readLock = producerTransactionLock.readLock();
+        readLock.lock();
+        Future<RecordMetadata> send;
+        try {
+            send = producer.send(outMsg, callback);
+        } finally {
+            readLock.unlock();
+        }
+
+        // wait on the send results
+        try {
+            return send.get();
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    protected void preAcquireWork() {
+        acquireCommitLock();
+    }
+
+    @Override
+    protected void postCommit() {
+        // only release lock when commit successful
+        if (producerTransactionLock.getWriteHoldCount() > 1) // sanity
+            throw new ConcurrentModificationException("Lock held too many times, won't be released problem and will cause deadlock");
+
+        releaseCommitLock();
+    }
+
+    @Override
+    protected void commitOffsets(final Map<TopicPartition, OffsetAndMetadata> offsetsToSend, final ConsumerGroupMetadata groupMetadata) {
+        log.debug("Transactional offset commit starting");
+        if (!options.isUsingTransactionalProducer()) {
+            throw new IllegalStateException("Bug: cannot use if not using transactional producer");
+        }
+
+        producer.sendOffsetsToTransaction(offsetsToSend, groupMetadata);
+        // see {@link KafkaProducer#commit} this can be interrupted and is safe to retry
+        boolean committed = false;
+        int retryCount = 0;
+        int arbitrarilyChosenLimitForArbitraryErrorSituation = 200;
+        Exception lastErrorSavedForRethrow = null;
+        while (!committed) {
+            if (retryCount > arbitrarilyChosenLimitForArbitraryErrorSituation) {
+                String msg = msg("Retired too many times ({} > limit of {}), giving up. See error above.", retryCount, arbitrarilyChosenLimitForArbitraryErrorSituation);
+                log.error(msg, lastErrorSavedForRethrow);
+                throw new RuntimeException(msg, lastErrorSavedForRethrow);
+            }
+            try {
+                if (producer instanceof MockProducer) {
+                    // see bug https://issues.apache.org/jira/browse/KAFKA-10382
+                    // KAFKA-10382 - MockProducer is not ThreadSafe, ideally it should be as the implementation it mocks is
+                    synchronized (producer) {
+                        producer.commitTransaction();
+                        producer.beginTransaction();
+                    }
+                } else {
+
+                    // producer commit lock should already be acquired at this point, before work was retrieved to commit,
+                    // so that more messages don't sneak into this tx block - the consumer records of which won't yet be
+                    // in this offset collection
+                    ensureLockHeld();
+
+                    boolean retrying = retryCount > 0;
+                    if (retrying) {
+                        if (isTransactionCompleting()) {
+                            // try wait again
+                            producer.commitTransaction();
+                        }
+                        if (isTransactionReady()) {
+                            // tx has completed since we last tried, start a new one
+                            producer.beginTransaction();
+                        }
+                        boolean ready = (lastErrorSavedForRethrow != null) ? !lastErrorSavedForRethrow.getMessage().contains("Invalid transition attempted from state READY to state COMMITTING_TRANSACTION") : true;
+                        if (ready) {
+                            // try again
+                            log.error("Was already ready - tx completed between interrupt and retry");
+                        }
+                    } else {
+                        // happy path
+                        producer.commitTransaction();
+                        producer.beginTransaction();
+                    }
+                }
+
+                committed = true;
+                if (retryCount > 0) {
+                    log.warn("Commit success, but took {} tries.", retryCount);
+                }
+            } catch (Exception e) {
+                log.warn("Commit exception, will retry, have tried {} times (see KafkaProducer#commit)", retryCount, e);
+                lastErrorSavedForRethrow = e;
+                retryCount++;
+            }
+        }
+    }
+
+    /**
+     * @return boolean which shows if we are setup for transactions or now
+     */
+    @SneakyThrows
+    private boolean setupReflection() {
+        if (producer instanceof KafkaProducer) {
+            txManagerField = producer.getClass().getDeclaredField("transactionManager");
+            txManagerField.setAccessible(true);
+
+            boolean producerIsConfiguredForTransactions = getProducerIsTransactional();
+            if (producerIsConfiguredForTransactions) {
+                TransactionManager transactionManager = getTransactionManager();
+                txManagerMethodIsCompleting = transactionManager.getClass().getDeclaredMethod("isCompleting");
+                txManagerMethodIsCompleting.setAccessible(true);
+
+                txManagerMethodIsReady = transactionManager.getClass().getDeclaredMethod("isReady");
+                txManagerMethodIsReady.setAccessible(true);
+            }
+            return producerIsConfiguredForTransactions;
+        } else if (producer instanceof MockProducer) {
+            // can act as both, delegate to user selection
+            return options.isUsingTransactionalProducer();
+        } else {
+            // unknown
+            return false;
+        }
+    }
+
+    /**
+     * TODO talk about alternatives to this brute force approach for retrying committing transactions
+     */
+    @SneakyThrows
+    private boolean isTransactionCompleting() {
+        if (producer instanceof MockProducer) return false;
+        return (boolean) txManagerMethodIsCompleting.invoke(getTransactionManager());
+    }
+
+    /**
+     * TODO talk about alternatives to this brute force approach for retrying committing transactions
+     */
+    @SneakyThrows
+    private boolean isTransactionReady() {
+        if (producer instanceof MockProducer) return true;
+        return (boolean) txManagerMethodIsReady.invoke(getTransactionManager());
+    }
+
+    /**
+     * Assumes the system is drained at this point, or draining is not desired.
+     */
+    public void close(final Duration timeout) {
+        log.debug("Closing producer, assuming no more in flight...");
+        if (options.isUsingTransactionalProducer() && !isTransactionReady()) {
+            acquireCommitLock();
+            try {
+                // close started after tx began, but before work was done, otherwise a tx wouldn't have been started
+                producer.abortTransaction();
+            } finally {
+                releaseCommitLock();
+            }
+        }
+        producer.close(timeout);
+    }
+
+    private void acquireCommitLock() {
+        if (producerTransactionLock.getWriteHoldCount() > 0)
+            throw new ConcurrentModificationException("Lock already held");
+        ReentrantReadWriteLock.WriteLock writeLock = producerTransactionLock.writeLock();
+        if (producerTransactionLock.isWriteLocked() && !producerTransactionLock.isWriteLockedByCurrentThread()) {
+            throw new ConcurrentModificationException(this.getClass().getSimpleName() + " is not safe for multi-threaded access");
+        }
+        writeLock.lock();
+    }
+
+    private void releaseCommitLock() {
+        log.trace("Release commit lock");
+        ReentrantReadWriteLock.WriteLock writeLock = producerTransactionLock.writeLock();
+        if (!producerTransactionLock.isWriteLockedByCurrentThread())
+            throw new IllegalStateException("Not held be me");
+        writeLock.unlock();
+    }
+
+    private void ensureLockHeld() {
+        if (!producerTransactionLock.isWriteLockedByCurrentThread())
+            throw new IllegalStateException("Expected commit lock to be held");
+    }
+
+    public boolean isTransactionInProgress() {
+        return producerTransactionLock.isWriteLocked();
+    }
+}
diff --git a/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/UserFunctions.java b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/UserFunctions.java
new file mode 100644
index 000000000..45c26cb8b
--- /dev/null
+++ b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/UserFunctions.java
@@ -0,0 +1,38 @@
+package io.confluent.parallelconsumer;
+
+import lombok.experimental.UtilityClass;
+
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+@UtilityClass
+public class UserFunctions {
+
+    public static final String MSG = "Error occurred in code supplied by user";
+
+    public static <T, U, R> R carefullyRun(BiFunction<T, U, R> wrappedFunction, T t, U u) {
+        try {
+            return wrappedFunction.apply(t, u);
+        } catch (Exception e) {
+            throw new ErrorInUserFunctionException(MSG, e);
+        }
+    }
+
+    public static <A, B> B carefullyRun(Function<A, B> wrappedFunction, A a) {
+        try {
+            return wrappedFunction.apply(a);
+        } catch (Exception e) {
+            throw new ErrorInUserFunctionException(MSG, e);
+        }
+    }
+
+    public static <A> void carefullyRun(Consumer<A> wrappedFunction, A a) {
+        try {
+            wrappedFunction.accept(a);
+        } catch (Exception e) {
+            throw new ErrorInUserFunctionException(MSG, e);
+        }
+    }
+
+}
diff --git a/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/WorkManager.java b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/WorkManager.java
index 0f360ddae..a1ff0353d 100644
--- a/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/WorkManager.java
+++ b/parallel-consumer-core/src/main/java/io/confluent/parallelconsumer/WorkManager.java
@@ -73,10 +73,13 @@ public class WorkManager<K, V> implements ConsumerRebalanceListener {
     private int inFlightCount = 0;
 
     /**
-     * The multiple of {@link ParallelConsumerOptions#getMaxConcurrency()} that should be pre-loaded awaiting processing.
-     * Consumer already pipelines, so we shouldn't need to pipeline ourselves too much.
+     * The multiple of {@link ParallelConsumerOptions#getMaxMessagesToQueue()} that should be pre-loaded awaiting
+     * processing. Consumer already pipelines, so we shouldn't need to pipeline ourselves too much.
+     * <p>
+     * Note how this relates to {@link BrokerPollSystem#getLongPollTimeout()} - if longPollTimeout is high and loading
+     * factor is low, there may not be enough messages queued up to satisfy demand.
      */
-    private final int loadingFactor = 2;
+    private final int loadingFactor = 3;
 
     /**
      * Useful for testing
@@ -253,7 +256,7 @@ private Object computeShardKey(ConsumerRecord<K, V> rec) {
     }
 
     public <R> List<WorkContainer<K, V>> maybeGetWork() {
-        return maybeGetWork(options.getMaxConcurrency());
+        return maybeGetWork(options.getMaxMessagesToQueue());
     }
 
     /**
@@ -262,7 +265,7 @@ public <R> List<WorkContainer<K, V>> maybeGetWork() {
      * @param requestedMaxWorkToRetrieve ignored unless less than {@link ParallelConsumerOptions#maxConcurrency}
      */
     public List<WorkContainer<K, V>> maybeGetWork(int requestedMaxWorkToRetrieve) {
-        int minWorkToGetSetting = min(min(requestedMaxWorkToRetrieve, options.getMaxConcurrency()), options.getMaxUncommittedMessagesToHandlePerPartition());
+        int minWorkToGetSetting = min(min(requestedMaxWorkToRetrieve, options.getMaxMessagesToQueue()), options.getMaxNumberMessagesBeyondBaseCommitOffset());
         int workToGetDelta = minWorkToGetSetting - getInFlightCount();
 
         // optimise early
@@ -321,8 +324,9 @@ public List<WorkContainer<K, V>> maybeGetWork(int requestedMaxWorkToRetrieve) {
             work.addAll(shardWork);
         }
 
-        log.debug("Returning {} records of work", work.size());
+        log.debug("Got {} records of work", work.size());
         inFlightCount += work.size();
+
         return work;
     }
 
@@ -367,8 +371,14 @@ public int getShardWorkRemainingCount() {
         return count;
     }
 
-    boolean isWorkRemaining() {
-        return getPartitionWorkRemainingCount() > 0;
+    boolean isRecordsAwaitingProcessing() {
+        int partitionWorkRemainingCount = getShardWorkRemainingCount();
+        return partitionWorkRemainingCount > 0;
+    }
+
+    boolean isRecordsAwaitingToBeCommitted() {
+        int partitionWorkRemainingCount = getPartitionWorkRemainingCount();
+        return partitionWorkRemainingCount > 0;
     }
 
     public WorkContainer<K, V> getWorkContainerForRecord(ConsumerRecord<K, V> rec) {
@@ -388,7 +398,8 @@ boolean hasComittableOffsets() {
     }
 
     /**
-     * TODO: This entire loop could be possibly redundant, if we instead track low water mark, and incomplete offsets as work is submitted and returned.
+     * TODO: This entire loop could be possibly redundant, if we instead track low water mark, and incomplete offsets as
+     * work is submitted and returned.
      */
     @SneakyThrows
     <R> Map<TopicPartition, OffsetAndMetadata> findCompletedEligibleOffsetsAndRemove(boolean remove) {
@@ -480,7 +491,8 @@ <R> Map<TopicPartition, OffsetAndMetadata> findCompletedEligibleOffsetsAndRemove
     /**
      * Once all the offset maps have been calculated, check if they're too big, and if so, remove all of them.
      * <p>
-     * Implication of this is that if the system has to recover from this offset, then it will have to replay all the messages that were otherwise complete.
+     * Implication of this is that if the system has to recover from this offset, then it will have to replay all the
+     * messages that were otherwise complete.
      *
      * @see OffsetMapCodecManager#DefaultMaxMetadataSize
      */
@@ -491,7 +503,7 @@ private void maybeStripOffsetPayload(Map<TopicPartition, OffsetAndMetadata> offs
         //  retaining the offset map feature, at the cost of potential performance by hitting a soft maximum in our uncommitted concurrent processing.
         if (totalOffsetMetaSize > OffsetMapCodecManager.DefaultMaxMetadataSize) {
             log.warn("Offset map data too large (size: {}) to fit in metadata payload - stripping offset map out. " +
-                    "See kafka.coordinator.group.OffsetConfig#DefaultMaxMetadataSize = 4096",
+                            "See kafka.coordinator.group.OffsetConfig#DefaultMaxMetadataSize = 4096",
                     totalOffsetMetaSize);
             // strip payload
             for (var entry : offsetsToSend.entrySet()) {
@@ -507,7 +519,8 @@ private void maybeStripOffsetPayload(Map<TopicPartition, OffsetAndMetadata> offs
      * Truncate our tracked offsets as a commit was successful, so the low water mark rises, and we dont' need to track
      * as much anymore.
      * <p>
-     * When commits are made to broker, we can throw away all the individually tracked offsets before the committed offset.
+     * When commits are made to broker, we can throw away all the individually tracked offsets before the committed
+     * offset.
      */
     public void onOffsetCommitSuccess(Map<TopicPartition, OffsetAndMetadata> offsetsToSend) {
         // partitionOffsetHighWaterMarks this will get overwritten in due course
@@ -522,18 +535,18 @@ public void onOffsetCommitSuccess(Map<TopicPartition, OffsetAndMetadata> offsets
     }
 
     public boolean shouldThrottle() {
-        return isOverMax();
+        return isSufficientlyLoaded();
     }
 
-    private boolean isOverMax() {
+    boolean isSufficientlyLoaded() {
         int remaining = getPartitionWorkRemainingCount();
-        boolean loadedEnough = remaining > options.getMaxConcurrency() * loadingFactor;
-        boolean overMaxInFlight = remaining > options.getMaxUncommittedMessagesToHandlePerPartition();
-        boolean isOverMax = loadedEnough || overMaxInFlight;
-        if (isOverMax) {
-            log.debug("loadedEnough {} || overMaxInFlight {}", loadedEnough, overMaxInFlight);
+        boolean loadedEnoughInPipeline = remaining > options.getMaxMessagesToQueue() * loadingFactor;
+        boolean overMaxUncommitted = remaining > options.getMaxNumberMessagesBeyondBaseCommitOffset();
+        boolean remainingIsSufficient = loadedEnoughInPipeline || overMaxUncommitted;
+        if (remainingIsSufficient) {
+            log.debug("loadedEnoughInPipeline {} || overMaxUncommitted {}", loadedEnoughInPipeline, overMaxUncommitted);
         }
-        return isOverMax;
+        return remainingIsSufficient;
     }
 
     public int getInFlightCount() {
diff --git a/parallel-consumer-core/src/test-integration/java/io/confluent/parallelconsumer/integrationTests/CloseAndOpenOffsetTest.java b/parallel-consumer-core/src/test-integration/java/io/confluent/parallelconsumer/integrationTests/CloseAndOpenOffsetTest.java
index bb19351af..033279ee0 100644
--- a/parallel-consumer-core/src/test-integration/java/io/confluent/parallelconsumer/integrationTests/CloseAndOpenOffsetTest.java
+++ b/parallel-consumer-core/src/test-integration/java/io/confluent/parallelconsumer/integrationTests/CloseAndOpenOffsetTest.java
@@ -4,6 +4,8 @@
  */
 package io.confluent.parallelconsumer.integrationTests;
 
+import io.confluent.csid.utils.KafkaTestUtils;
+import io.confluent.parallelconsumer.ParallelConsumer;
 import io.confluent.parallelconsumer.ParallelEoSStreamProcessor;
 import io.confluent.parallelconsumer.ParallelConsumerOptions;
 import io.confluent.parallelconsumer.OffsetMapCodecManager;
@@ -11,12 +13,11 @@
 import io.confluent.csid.utils.Range;
 import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.kafka.clients.consumer.ConsumerConfig;
-import org.apache.kafka.clients.consumer.ConsumerRecord;
-import org.apache.kafka.clients.consumer.KafkaConsumer;
+import org.apache.kafka.clients.consumer.*;
 import org.apache.kafka.clients.producer.KafkaProducer;
 import org.apache.kafka.clients.producer.ProducerRecord;
 import org.apache.kafka.clients.producer.RecordMetadata;
+import org.apache.kafka.common.TopicPartition;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.Timeout;
@@ -25,12 +26,16 @@
 import pl.tlinkowski.unij.api.UniSets;
 
 import java.time.Duration;
-import java.util.ArrayList;
-import java.util.Set;
+import java.util.*;
+import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.ConcurrentSkipListSet;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
+import static io.confluent.parallelconsumer.ParallelConsumerOptions.CommitMode.TRANSACTIONAL_PRODUCER;
+import static io.confluent.parallelconsumer.ParallelConsumerOptions.ProcessingOrder.UNORDERED;
 import static java.time.Duration.ofSeconds;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.awaitility.Awaitility.await;
@@ -43,7 +48,7 @@
 public class CloseAndOpenOffsetTest extends KafkaTest<String, String> {
 
     Duration normalTimeout = ofSeconds(5);
-    Duration debugTimeout = Duration.ofMinutes(10);
+    Duration debugTimeout = Duration.ofMinutes(1);
 
     // use debug timeout while debugging
 //    Duration timeoutToUse = debugTimeout;
@@ -56,6 +61,14 @@ void setup() {
         rebalanceTopic = "close-and-open-" + RandomUtils.nextInt();
     }
 
+    /**
+     * publish some messages some fail shutdown startup again consume again - check we only consume the failed messages
+     * <p>
+     * Sometimes fails as 5 is not comitted in the first run and comes out in the 2nd
+     * <p>
+     * NB: messages 4 and 2 are made to fail
+     */
+    @Timeout(value = 60)
     @SneakyThrows
     @Test
     void offsetsOpenClose() {
@@ -67,19 +80,24 @@ void offsetsOpenClose() {
         }
 
         // 1 client
-        ParallelConsumerOptions options = ParallelConsumerOptions.builder().ordering(ParallelConsumerOptions.ProcessingOrder.UNORDERED).build();
-        kcu.props.put(ConsumerConfig.CLIENT_ID_CONFIG, "ONE-my-client");
         KafkaConsumer<String, String> newConsumerOne = kcu.createNewConsumer();
+        KafkaProducer<String, String> producerOne = kcu.createNewProducer(true);
+        var options = ParallelConsumerOptions.<String, String>builder()
+                .ordering(UNORDERED)
+                .commitMode(TRANSACTIONAL_PRODUCER)
+                .consumer(newConsumerOne)
+                .producer(producerOne)
+                .build();
+        kcu.props.put(ConsumerConfig.CLIENT_ID_CONFIG, "ONE-my-client");
 
         //
-        KafkaProducer<String, String> producerOne = kcu.createNewProducer(true);
-        var asyncOne = new ParallelEoSStreamProcessor<>(newConsumerOne, producerOne, options);
+        var asyncOne = new ParallelEoSStreamProcessor<String, String>(options);
 
         //
         asyncOne.subscribe(UniLists.of(rebalanceTopic));
 
         // read some messages
-        var readByOne = new ArrayList<ConsumerRecord<String, String>>();
+        var readByOne = new ConcurrentLinkedQueue<ConsumerRecord<String, String>>();
         asyncOne.poll(x -> {
             log.info("Read by consumer ONE: {}", x);
             if (x.value().equals("4")) {
@@ -93,6 +111,9 @@ void offsetsOpenClose() {
             readByOne.add(x);
         });
 
+        // wait for initial 0 commit
+        Thread.sleep(500);
+
         //
         send(rebalanceTopic, 0, 0);
         send(rebalanceTopic, 0, 1);
@@ -102,28 +123,52 @@ void offsetsOpenClose() {
         send(rebalanceTopic, 0, 5);
 
         // all are processed except msg 2 and 4, which holds up the queue
-        await().atMost(debugTimeout).untilAsserted(() -> assertThat(readByOne).hasSize(4));
+        await().alias("check all except 2 and 4 are processed").atMost(normalTimeout).untilAsserted(() -> {
+                    ArrayList<ConsumerRecord<String, String>> copy = new ArrayList<>(readByOne);
+                    assertThat(copy.stream()
+                            .map(x -> x.value()).collect(Collectors.toList()))
+                            .containsOnly("0", "1", "3", "5");
+                }
+        );
+
+        // wait until all expected records have been processed and committed
+        // need to wait for final message processing's offset data to be committed
+        // TODO test for event/trigger instead - could consume offsets topic but have to decode the binary
+        // could listen to a produce topic, but currently it doesn't use the produce flow
+        // could add a commit listener to the api, but that's heavy just for this?
+        // could use Consumer#committed to check and decode, but it's not thread safe
+        // sleep is lazy but much much simpler
+        Thread.sleep(500);
 
         // commit what we've done so far, don't wait for failing messages to be retried (message 4)
         log.info("Closing consumer, committing offset map");
         asyncOne.closeDontDrainFirst();
 
+        await().alias("check all except 2 and 4 are processed").atMost(normalTimeout).untilAsserted(() ->
+                assertThat(readByOne.stream()
+                        .map(x -> x.value()).collect(Collectors.toList()))
+                        .containsOnly("0", "1", "3", "5"));
+
+
         //
         kcu.props.put(ConsumerConfig.CLIENT_ID_CONFIG, "THREE-my-client");
         KafkaConsumer<String, String> newConsumerThree = kcu.createNewConsumer();
         KafkaProducer<String, String> producerThree = kcu.createNewProducer(true);
-        try (var asyncThree = new ParallelEoSStreamProcessor<>(newConsumerThree, producerThree, options)) {
+        var optionsThree = options.toBuilder().consumer(newConsumerThree).producer(producerThree).build();
+        try (var asyncThree = new ParallelEoSStreamProcessor<String, String>(optionsThree)) {
             asyncThree.subscribe(UniLists.of(rebalanceTopic));
 
             // read what we're given
-            var readByThree = new ArrayList<ConsumerRecord<String, String>>();
+            var readByThree = new ConcurrentLinkedQueue<ConsumerRecord<String, String>>();
             asyncThree.poll(x -> {
                 log.info("Read by consumer THREE: {}", x.value());
                 readByThree.add(x);
             });
 
             // only 2 and 4 should be delivered again, as everything else was processed successfully
-            await().atMost(timeoutToUse).untilAsserted(() -> assertThat(readByThree).extracting(ConsumerRecord::value).containsExactlyInAnyOrder("2", "4"));
+            await().atMost(timeoutToUse).untilAsserted(() ->
+                    assertThat(readByThree).extracting(ConsumerRecord::value)
+                            .containsExactlyInAnyOrder("2", "4"));
         }
     }
 
@@ -160,28 +205,42 @@ void correctOffsetVerySimple() {
 
         KafkaConsumer<String, String> consumer = kcu.createNewConsumer();
         KafkaProducer<String, String> producerOne = kcu.createNewProducer(true);
-        ParallelConsumerOptions options = ParallelConsumerOptions.builder().ordering(ParallelConsumerOptions.ProcessingOrder.UNORDERED).build();
+        var options = ParallelConsumerOptions.<String, String>builder()
+                .ordering(UNORDERED)
+                .consumer(consumer)
+                .producer(producerOne)
+                .commitMode(TRANSACTIONAL_PRODUCER)
+                .build();
 
-        try (var asyncOne = new ParallelEoSStreamProcessor<>(consumer, producerOne, options)) {
+        try (var asyncOne = new ParallelEoSStreamProcessor<String, String>(options)) {
 
             asyncOne.subscribe(UniLists.of(topic));
 
             var readByOne = new ArrayList<ConsumerRecord<String, String>>();
-            asyncOne.poll(readByOne::add);
+            asyncOne.poll(msg -> {
+                log.debug("Reading {}", msg);
+                readByOne.add(msg);
+            });
 
             // the single message is processed
             await().untilAsserted(() -> assertThat(readByOne)
                     .extracting(ConsumerRecord::value)
                     .containsExactly("0"));
 
+        } finally {
+            log.debug("asyncOne closed");
         }
 
         //
+        log.debug("Starting up new client");
         kcu.props.put(ConsumerConfig.CLIENT_ID_CONFIG, "THREE-my-client");
         KafkaConsumer<String, String> newConsumerThree = kcu.createNewConsumer();
         KafkaProducer<String, String> producerThree = kcu.createNewProducer(true);
-
-        try (var asyncThree = new ParallelEoSStreamProcessor<>(newConsumerThree, producerThree, options)) {
+        ParallelConsumerOptions<String, String> optionsThree = options.toBuilder()
+                .consumer(newConsumerThree)
+                .producer(producerThree)
+                .build();
+        try (var asyncThree = new ParallelEoSStreamProcessor<String, String>(optionsThree)) {
             asyncThree.subscribe(UniLists.of(topic));
 
             // read what we're given
@@ -220,8 +279,13 @@ void largeNumberOfMessagesSmallOffsetBitmap() {
 
         KafkaConsumer<String, String> consumer = kcu.createNewConsumer();
         KafkaProducer<String, String> producerOne = kcu.createNewProducer(true);
-        ParallelConsumerOptions options = ParallelConsumerOptions.builder().ordering(ParallelConsumerOptions.ProcessingOrder.UNORDERED).build();
-        var asyncOne = new ParallelEoSStreamProcessor<>(consumer, producerOne, options);
+        var options = ParallelConsumerOptions.<String, String>builder()
+                .ordering(UNORDERED)
+                .consumer(consumer)
+                .producer(producerOne)
+                .commitMode(TRANSACTIONAL_PRODUCER)
+                .build();
+        var asyncOne = new ParallelEoSStreamProcessor<String, String>(options);
 
         asyncOne.subscribe(UniLists.of(topic));
 
@@ -249,7 +313,11 @@ void largeNumberOfMessagesSmallOffsetBitmap() {
         kcu.props.put(ConsumerConfig.CLIENT_ID_CONFIG, "THREE-my-client");
         KafkaConsumer<String, String> newConsumerThree = kcu.createNewConsumer();
         KafkaProducer<String, String> producerThree = kcu.createNewProducer(true);
-        try (var asyncThree = new ParallelEoSStreamProcessor<>(newConsumerThree, producerThree, options)) {
+        var optionsThree = options.toBuilder()
+                .consumer(newConsumerThree)
+                .producer(producerThree)
+                .build();
+        try (var asyncThree = new ParallelEoSStreamProcessor<String, String>(optionsThree)) {
             asyncThree.subscribe(UniLists.of(topic));
 
             // read what we're given
diff --git a/parallel-consumer-core/src/test-integration/java/io/confluent/parallelconsumer/integrationTests/KafkaTest.java b/parallel-consumer-core/src/test-integration/java/io/confluent/parallelconsumer/integrationTests/KafkaTest.java
index 43e7afb2e..14501362b 100644
--- a/parallel-consumer-core/src/test-integration/java/io/confluent/parallelconsumer/integrationTests/KafkaTest.java
+++ b/parallel-consumer-core/src/test-integration/java/io/confluent/parallelconsumer/integrationTests/KafkaTest.java
@@ -6,7 +6,6 @@
 
 import io.confluent.parallelconsumer.integrationTests.utils.KafkaClientUtils;
 import io.confluent.csid.testcontainers.FilteredTestContainerSlf4jLogConsumer;
-import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.kafka.clients.admin.CreateTopicsResult;
 import org.apache.kafka.clients.admin.NewTopic;
@@ -18,11 +17,14 @@
 import org.testcontainers.utility.DockerImageName;
 import pl.tlinkowski.unij.api.UniLists;
 
+import java.util.concurrent.ExecutionException;
+
 import static org.apache.commons.lang3.RandomUtils.nextInt;
 import static org.assertj.core.api.Assertions.assertThat;
 
 @Testcontainers
 @Slf4j
+// TODO rename to broker integration test
 public abstract class KafkaTest<K, V> {
 
     int numPartitions = 2; // as default consumer settings are max request 50 max per partition 1 - 50/1=50
@@ -37,6 +39,8 @@ public abstract class KafkaTest<K, V> {
             .withEnv("KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR", "1") //transaction.state.log.replication.factor
             .withEnv("KAFKA_TRANSACTION_STATE_LOG_MIN_ISR", "1") //transaction.state.log.min.isr
             .withEnv("KAFKA_TRANSACTION_STATE_LOG_NUM_PARTITIONS", "1") //transaction.state.log.num.partitions
+            // try to speed up initial consumer group formation
+            .withEnv("KAFKA_GROUP_INITIAL_REBALANCE_DELAY_MS", "500") // group.initial.rebalance.delay.ms default: 3000
             .withReuse(true);
 
     static {
@@ -45,13 +49,13 @@ public abstract class KafkaTest<K, V> {
 
     protected KafkaClientUtils kcu = new KafkaClientUtils(kafkaContainer);
 
-  @BeforeAll
-  static void followKafkaLogs(){
-    if(log.isDebugEnabled()) {
-      FilteredTestContainerSlf4jLogConsumer logConsumer = new FilteredTestContainerSlf4jLogConsumer(log);
-      kafkaContainer.followOutput(logConsumer);
+    @BeforeAll
+    static void followKafkaLogs() {
+        if (log.isDebugEnabled()) {
+            FilteredTestContainerSlf4jLogConsumer logConsumer = new FilteredTestContainerSlf4jLogConsumer(log);
+            kafkaContainer.followOutput(logConsumer);
+        }
     }
-  }
 
     @BeforeEach
     void open() {
@@ -64,18 +68,30 @@ void close() {
     }
 
     void setupTopic() {
+        String name = LoadTest.class.getSimpleName();
+        setupTopic(name);
+    }
+
+    protected String setupTopic(String name) {
         assertThat(kafkaContainer.isRunning()).isTrue(); // sanity
 
-        topic = LoadTest.class.getSimpleName() + "-" + nextInt();
+        topic = name + "-" + nextInt();
 
         ensureTopic(topic, numPartitions);
+
+        return name;
     }
 
-    @SneakyThrows
     protected void ensureTopic(String topic, int numPartitions) {
         NewTopic e1 = new NewTopic(topic, numPartitions, (short) 1);
         CreateTopicsResult topics = kcu.admin.createTopics(UniLists.of(e1));
-        Void all = topics.all().get();
+        try {
+            Void all = topics.all().get();
+        } catch (ExecutionException e) {
+            // fine
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
     }
 
 }
diff --git a/parallel-consumer-core/src/test-integration/java/io/confluent/parallelconsumer/integrationTests/LoadTest.java b/parallel-consumer-core/src/test-integration/java/io/confluent/parallelconsumer/integrationTests/LoadTest.java
index 0e724c1f9..73f58c02c 100644
--- a/parallel-consumer-core/src/test-integration/java/io/confluent/parallelconsumer/integrationTests/LoadTest.java
+++ b/parallel-consumer-core/src/test-integration/java/io/confluent/parallelconsumer/integrationTests/LoadTest.java
@@ -30,6 +30,7 @@
 
 import static io.confluent.csid.utils.GeneralTestUtils.time;
 import static io.confluent.csid.utils.Range.range;
+import static io.confluent.parallelconsumer.ParallelConsumerOptions.CommitMode.TRANSACTIONAL_PRODUCER;
 import static java.time.Duration.*;
 import static me.tongfei.progressbar.ProgressBar.wrap;
 import static org.apache.commons.lang3.RandomUtils.nextInt;
@@ -71,11 +72,17 @@ void asyncConsumeAndProcess() {
         // subscribe in advance, it can be a few seconds
         kcu.consumer.subscribe(UniLists.of(topic));
 
-        //
-        ParallelConsumerOptions options = ParallelConsumerOptions.builder().ordering(ParallelConsumerOptions.ProcessingOrder.KEY).build();
         KafkaConsumer<String, String> newConsumer = kcu.createNewConsumer();
+        //
+        boolean tx = true;
+        ParallelConsumerOptions<String, String> options = ParallelConsumerOptions.<String, String>builder()
+                .ordering(ParallelConsumerOptions.ProcessingOrder.KEY)
+                .commitMode(TRANSACTIONAL_PRODUCER)
+                .producer(kcu.createNewProducer(tx))
+                .consumer(newConsumer)
+                .build();
         newConsumer.subscribe(Pattern.compile(topic));
-        var async = new ParallelEoSStreamProcessor<>(newConsumer, kcu.createNewProducer(true), options);
+        ParallelEoSStreamProcessor<String, String> async = new ParallelEoSStreamProcessor<>(options);
         AtomicInteger msgCount = new AtomicInteger(0);
 
         ProgressBar pb = new ProgressBarBuilder()
diff --git a/parallel-consumer-core/src/test-integration/java/io/confluent/parallelconsumer/integrationTests/TransactionAndCommitModeTest.java b/parallel-consumer-core/src/test-integration/java/io/confluent/parallelconsumer/integrationTests/TransactionAndCommitModeTest.java
new file mode 100644
index 000000000..6d8cc66f1
--- /dev/null
+++ b/parallel-consumer-core/src/test-integration/java/io/confluent/parallelconsumer/integrationTests/TransactionAndCommitModeTest.java
@@ -0,0 +1,165 @@
+package io.confluent.parallelconsumer.integrationTests;
+
+/*-
+ * Copyright (C) 2020 Confluent, Inc.
+ */
+
+import io.confluent.csid.utils.EnumCartesianProductTestSets;
+import io.confluent.parallelconsumer.ParallelConsumerOptions;
+import io.confluent.parallelconsumer.ParallelConsumerOptions.CommitMode;
+import io.confluent.parallelconsumer.ParallelConsumerOptions.ProcessingOrder;
+import io.confluent.parallelconsumer.ParallelEoSStreamProcessor;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.RandomUtils;
+import org.apache.kafka.clients.consumer.ConsumerConfig;
+import org.apache.kafka.clients.consumer.KafkaConsumer;
+import org.apache.kafka.clients.producer.KafkaProducer;
+import org.apache.kafka.clients.producer.Producer;
+import org.apache.kafka.clients.producer.ProducerRecord;
+import org.awaitility.core.ConditionTimeoutException;
+import org.junit.jupiter.api.RepeatedTest;
+import org.junitpioneer.jupiter.CartesianProductTest;
+import pl.tlinkowski.unij.api.UniLists;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Properties;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static io.confluent.parallelconsumer.ParallelConsumerOptions.CommitMode.TRANSACTIONAL_PRODUCER;
+import static io.confluent.parallelconsumer.ParallelConsumerOptions.ProcessingOrder.KEY;
+import static io.confluent.parallelconsumer.ParallelConsumerOptions.ProcessingOrder.PARTITION;
+import static java.time.Duration.ofSeconds;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+import static org.awaitility.Awaitility.waitAtMost;
+
+/**
+ * Originally created to reproduce bug #25 https://github.com/confluentinc/parallel-consumer/issues/25 which was a known
+ * issue with multi threaded use of the {@link org.apache.kafka.clients.producer.KafkaProducer}.
+ * <p>
+ * After fixing multi threading issue, using Producer transactions was made optional, and this test grew to uncover
+ * several issues with the new implementation of committing offsets through the {@link
+ * org.apache.kafka.clients.consumer.KafkaConsumer}.
+ *
+ * @see io.confluent.parallelconsumer.OffsetCommitter
+ * @see io.confluent.parallelconsumer.ConsumerOffsetCommitter
+ * @see io.confluent.parallelconsumer.ProducerManager
+ */
+@Slf4j
+public class TransactionAndCommitModeTest extends KafkaTest<String, String> {
+
+    int LOW_MAX_POLL_RECORDS_CONFIG = 1;
+    int DEFAULT_MAX_POLL_RECORDS_CONFIG = 500;
+    int HIGH_MAX_POLL_RECORDS_CONFIG = 10_000;
+
+    public List<String> processedAndProducedKeys = Collections.synchronizedList(new ArrayList<>());
+    public AtomicInteger processedCount = new AtomicInteger(0);
+    public AtomicInteger producedCount = new AtomicInteger(0);
+
+    // default
+    @CartesianProductTest(factory = "enumSets")
+    void testDefaultMaxPoll(CommitMode commitMode, ProcessingOrder order) {
+        runTest(DEFAULT_MAX_POLL_RECORDS_CONFIG, commitMode, order);
+    }
+
+    static CartesianProductTest.Sets enumSets() {
+        return new EnumCartesianProductTestSets()
+                .add(CommitMode.class)
+                .add(ProcessingOrder.class);
+    }
+
+    @RepeatedTest(5)
+    public void testTransactionalDefaultMaxPoll() {
+        runTest(DEFAULT_MAX_POLL_RECORDS_CONFIG, TRANSACTIONAL_PRODUCER, KEY);
+    }
+
+    // low
+    @CartesianProductTest(factory = "enumSets")
+    public void testLowMaxPoll(CommitMode commitMode, ProcessingOrder order) {
+        runTest(LOW_MAX_POLL_RECORDS_CONFIG, commitMode, order);
+    }
+
+    // high counts
+    @CartesianProductTest(factory = "enumSets")
+    public void testHighMaxPollEnum(CommitMode commitMode, ProcessingOrder order) {
+        runTest(HIGH_MAX_POLL_RECORDS_CONFIG, commitMode, order);
+    }
+
+    private void runTest(int maxPoll, CommitMode commitMode) {
+        runTest(maxPoll, commitMode, PARTITION);
+    }
+
+    @SneakyThrows
+    private void runTest(int maxPoll, CommitMode commitMode, ProcessingOrder order) {
+        String inputName = setupTopic(this.getClass().getSimpleName() + "-input-" + RandomUtils.nextInt());
+        String outputName = setupTopic(this.getClass().getSimpleName() + "-output-" + RandomUtils.nextInt());
+
+        // pre-produce messages to input-topic
+        List<String> expectedKeys = new ArrayList<>();
+        int expectedMessageCount = 1000;
+        log.info("Producing {} messages before starting application", expectedMessageCount);
+        try (Producer<String, String> kafkaProducer = kcu.createNewProducer(false)) {
+            for (int i = 0; i < expectedMessageCount; i++) {
+                String key = "key-" + i;
+                kafkaProducer.send(new ProducerRecord<>(inputName, key, "value-" + i));
+                expectedKeys.add(key);
+            }
+        }
+
+        // run parallel-consumer
+        log.info("Starting application...");
+        KafkaProducer<String, String> newProducer = kcu.createNewProducer(commitMode.equals(TRANSACTIONAL_PRODUCER));
+
+        Properties consumerProps = new Properties();
+        consumerProps.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, maxPoll);
+        KafkaConsumer<String, String> newConsumer = kcu.createNewConsumer(true, consumerProps);
+
+        var pc = new ParallelEoSStreamProcessor<String, String>(ParallelConsumerOptions.<String, String>builder()
+                .ordering(order)
+                .consumer(newConsumer)
+                .producer(newProducer)
+                .commitMode(commitMode)
+                .build());
+        pc.subscribe(UniLists.of(inputName)); // <5>
+
+        pc.pollAndProduce(record -> {
+                    log.trace("Still going {}", record);
+                    processedCount.incrementAndGet();
+                    return new ProducerRecord<String, String>(outputName, record.key(), "data");
+                }, consumeProduceResult -> {
+                    producedCount.incrementAndGet();
+                    processedAndProducedKeys.add(consumeProduceResult.getIn().key());
+                }
+        );
+
+        // wait for all pre-produced messages to be processed and produced
+        String failureMessage = "All keys sent to input-topic should be processed and produced, within time";
+        try {
+            waitAtMost(ofSeconds(10)).alias(failureMessage).untilAsserted(() -> {
+                log.info("Processed-count: {}, Produced-count: {}", processedCount.get(), producedCount.get());
+                List<String> processedAndProducedKeysCopy = new ArrayList<>(processedAndProducedKeys); // avoid concurrent-modification in assert
+                assertThat(processedAndProducedKeysCopy).contains(expectedKeys.toArray(new String[0]));
+            });
+        } catch (ConditionTimeoutException e) {
+            log.debug("Expected keys=" + expectedKeys + "");
+            log.debug("Processed and produced keys=" + processedAndProducedKeys + "");
+            expectedKeys.removeAll(processedAndProducedKeys);
+            log.debug("Missing keys=" + expectedKeys);
+            fail(failureMessage);
+        }
+
+        pc.closeDrainFirst();
+
+        assertThat(processedCount.get())
+                .as("messages processed and produced by parallel-consumer should be equal")
+                .isEqualTo(producedCount.get());
+
+        // sanity
+        assertThat(expectedMessageCount).isEqualTo(processedCount.get());
+        assertThat(processedAndProducedKeys).hasSameSizeAs(expectedKeys);
+    }
+
+}
diff --git a/parallel-consumer-core/src/test-integration/java/io/confluent/parallelconsumer/integrationTests/VolumeTests.java b/parallel-consumer-core/src/test-integration/java/io/confluent/parallelconsumer/integrationTests/VolumeTests.java
index 7c6a07612..687d45d7c 100644
--- a/parallel-consumer-core/src/test-integration/java/io/confluent/parallelconsumer/integrationTests/VolumeTests.java
+++ b/parallel-consumer-core/src/test-integration/java/io/confluent/parallelconsumer/integrationTests/VolumeTests.java
@@ -4,6 +4,8 @@
  */
 package io.confluent.parallelconsumer.integrationTests;
 
+import io.confluent.parallelconsumer.ParallelConsumerOptions;
+import io.confluent.parallelconsumer.ParallelConsumerOptions.CommitMode;
 import io.confluent.parallelconsumer.ParallelEoSStreamProcessorTestBase;
 import io.confluent.csid.utils.KafkaTestUtils;
 import lombok.SneakyThrows;
@@ -16,8 +18,8 @@
 import org.apache.kafka.clients.producer.ProducerRecord;
 import org.apache.kafka.common.TopicPartition;
 import org.assertj.core.util.Lists;
-import org.awaitility.Awaitility;
-import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.EnumSource;
 import org.testcontainers.shaded.com.google.common.collect.Maps;
 import pl.tlinkowski.unij.api.UniLists;
 
@@ -25,13 +27,17 @@
 import java.util.*;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.CountDownLatch;
+import java.util.stream.Collectors;
 
+import static io.confluent.parallelconsumer.ParallelConsumerOptions.CommitMode.CONSUMER_SYNC;
+import static io.confluent.parallelconsumer.ParallelConsumerOptions.CommitMode.TRANSACTIONAL_PRODUCER;
 import static io.confluent.parallelconsumer.ParallelConsumerOptions.ProcessingOrder.*;
 import static io.confluent.csid.utils.GeneralTestUtils.time;
 import static io.confluent.csid.utils.Range.range;
 import static java.util.Comparator.comparing;
 import static java.util.concurrent.TimeUnit.SECONDS;
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.awaitility.Awaitility.waitAtMost;
 import static org.mockito.Mockito.mock;
 
 /**
@@ -43,10 +49,14 @@ public class VolumeTests extends ParallelEoSStreamProcessorTestBase {
     KafkaTestUtils ku = new KafkaTestUtils(consumerSpy);
 
     @SneakyThrows
-    @Test
-    public void load() {
+    @ParameterizedTest()
+    @EnumSource(CommitMode.class)
+    public void load(CommitMode commitMode) {
         setupClients();
-        setupAsyncConsumerInstance(UNORDERED);
+        setupParallelConsumerInstance(ParallelConsumerOptions.builder()
+                .ordering(UNORDERED)
+                .commitMode(commitMode)
+                .build());
 
 //        int quantityOfMessagesToProduce = 1_000_000;
         int quantityOfMessagesToProduce = 500;
@@ -54,42 +64,43 @@ public void load() {
         List<ConsumerRecord<String, String>> records = ku.generateRecords(quantityOfMessagesToProduce);
         ku.send(consumerSpy, records);
 
-        CountDownLatch latch = new CountDownLatch(quantityOfMessagesToProduce);
+        CountDownLatch allMessagesConsumedLatch = new CountDownLatch(quantityOfMessagesToProduce);
 
-        parallelConsumer.pollAndProduce((rec) -> {
+        parallelConsumer.pollAndProduceMany((rec) -> {
             ProducerRecord<String, String> mock = mock(ProducerRecord.class);
             return UniLists.of(mock);
         }, (x) -> {
 //            log.debug(x.toString());
-            latch.countDown();
+            allMessagesConsumedLatch.countDown();
         });
 
-
         //
+        allMessagesConsumedLatch.await(defaultTimeoutSeconds, SECONDS);
 //        waitAtMost(defaultTimeout).until(() -> producerSpy.consumerGroupOffsetsHistory().size() > 0);
-        latch.await(defaultTimeoutSeconds, SECONDS);
-        parallelConsumer.waitForNoInFlight(defaultTimeout.multipliedBy(10));
+        parallelConsumer.waitForProcessedNotCommitted(defaultTimeout.multipliedBy(10));
         parallelConsumer.close();
 
-
         // assert quantity of produced messages
         List<ProducerRecord<String, String>> history = producerSpy.history();
         assertThat(history).hasSize(quantityOfMessagesToProduce);
 
-        // assert order of produced messages
-
-
-        // assert order of commits
-//        int keySize = ku.getKeys().size();
-        List<Map<String, Map<TopicPartition, OffsetAndMetadata>>> commitHistory = producerSpy.consumerGroupOffsetsHistory();
-        Map<String, Map<TopicPartition, OffsetAndMetadata>> mostRecent = commitHistory.get(commitHistory.size() - 1);
-        Map<TopicPartition, OffsetAndMetadata> topicPartitionOffsetAndMetadataMap = mostRecent.get(CONSUMER_GROUP_ID);
-        OffsetAndMetadata mostRecentTPCommit = topicPartitionOffsetAndMetadataMap.get(new TopicPartition(INPUT_TOPIC, 0));
-
-        assertCommitsAlwaysIncrease();
-
-        long mostRecentCommitOffset = findMostRecentCommitOffset(producerSpy);
-        assertThat(mostRecentCommitOffset).isEqualTo(quantityOfMessagesToProduce);
+        if (commitMode.equals(TRANSACTIONAL_PRODUCER)) {
+            // assert order of commits
+            assertCommitsAlwaysIncrease();
+
+            // producer (tx) commits
+            List<Map<String, Map<TopicPartition, OffsetAndMetadata>>> producerCommits = producerSpy.consumerGroupOffsetsHistory();
+            assertThat(producerCommits).isNotEmpty();
+            long mostRecentProducerCommitOffset = findMostRecentCommitOffset(producerSpy); // tx
+            assertThat(mostRecentProducerCommitOffset).isEqualTo(quantityOfMessagesToProduce);
+        } else {
+            // assert commit messages
+            List<Map<TopicPartition, OffsetAndMetadata>> consumerCommitHistory = consumerSpy.getCommitHistoryInt();
+
+            assertThat(consumerCommitHistory).isNotEmpty();
+            long mostRecentConsumerCommitOffset = consumerCommitHistory.get(consumerCommitHistory.size() - 1).values().stream().collect(Collectors.toList()).get(0).offset(); // non-tx
+            assertThat(mostRecentConsumerCommitOffset).isEqualTo(quantityOfMessagesToProduce);
+        }
 
         // TODO: Assert process ordering
     }
@@ -114,6 +125,7 @@ private void assertCommitsAlwaysIncrease() {
 
     private long findMostRecentCommitOffset(MockProducer<?, ?> producerSpy) {
         List<Map<String, Map<TopicPartition, OffsetAndMetadata>>> commitHistory = producerSpy.consumerGroupOffsetsHistory();
+        assertThat(commitHistory).as("No offsets committed").hasSizeGreaterThan(0);
         Map<String, Map<TopicPartition, OffsetAndMetadata>> mostRecent = commitHistory.get(commitHistory.size() - 1);
         Map<TopicPartition, OffsetAndMetadata> topicPartitionOffsetAndMetadataMap = mostRecent.get(CONSUMER_GROUP_ID);
         OffsetAndMetadata mostRecentTPCommit = topicPartitionOffsetAndMetadataMap.get(new TopicPartition(INPUT_TOPIC, 0));
@@ -126,41 +138,60 @@ private long findMostRecentCommitOffset(MockProducer<?, ?> producerSpy) {
      * <p>
      * Doesn't currently compare different key sizes, only partition order vs key order vs unordered
      */
-    @Test
-    public void timingOfDifferentOrderingTypes() {
+    @ParameterizedTest()
+    @EnumSource(CommitMode.class)
+    public void timingOfDifferentOrderingTypes(CommitMode commitMode) {
         var quantityOfMessagesToProduce = 10_00;
         var defaultNumKeys = 20;
 
+        ParallelConsumerOptions baseOptions = ParallelConsumerOptions.builder()
+                .ordering(UNORDERED)
+                .commitMode(commitMode)
+                .build();
+
+        setupParallelConsumerInstance(baseOptions);
+
         Duration unorderedDuration = null;
         for (var round : range(2)) { // warm up round first
-            setupAsyncConsumerInstance(UNORDERED);
+            setupParallelConsumerInstance(baseOptions.toBuilder().ordering(UNORDERED).build());
             log.debug("No order");
             unorderedDuration = time(() -> testTiming(defaultNumKeys, quantityOfMessagesToProduce));
             log.info("Duration for Unordered processing in round {} with {} keys was {}", round, defaultNumKeys, unorderedDuration);
         }
 
         var keyResults = Maps.<Integer, Duration>newTreeMap();
-        setupAsyncConsumerInstance(KEY);
         for (var keySize : UniLists.of(1, 2, 5, 10, 20, 50, 100, 1_000)) {
-            setupAsyncConsumerInstance(KEY);
+            setupParallelConsumerInstance(baseOptions.toBuilder().ordering(KEY).build());
             log.debug("By key, {} keys", keySize);
             Duration keyOrderDuration = time(() -> testTiming(keySize, quantityOfMessagesToProduce));
             log.info("Duration for Key order processing {} keys was {}", keySize, keyOrderDuration);
             keyResults.put(keySize, keyOrderDuration);
         }
 
-        setupAsyncConsumerInstance(PARTITION);
+        setupParallelConsumerInstance(baseOptions.toBuilder().ordering(PARTITION).build());
         log.debug("By partition");
         Duration partitionOrderDuration = time(() -> testTiming(defaultNumKeys, quantityOfMessagesToProduce));
         log.info("Duration for Partition order processing {} keys was {}", defaultNumKeys, partitionOrderDuration);
 
         log.info("Key duration results:\n{}", keyResults);
 
+        log.info("Unordered duration: {}", unorderedDuration);
+
         int numOfKeysToCompare = 5; // needs to be small enough that there's a significant difference between unordered and key of x
         Duration keyOrderHalfDefaultKeySize = keyResults.get(numOfKeysToCompare);
-        assertThat(unorderedDuration).as("UNORDERED is faster than PARTITION order").isLessThan(partitionOrderDuration);
-        assertThat(unorderedDuration).as("UNORDERED is faster than KEY order, keySize of: " + numOfKeysToCompare).isLessThan(keyOrderHalfDefaultKeySize);
-        assertThat(keyOrderHalfDefaultKeySize).as("KEY order is faster than PARTITION order").isLessThan(partitionOrderDuration);
+        assertThat(unorderedDuration).as("UNORDERED should be faster than PARTITION order")
+                .isLessThan(partitionOrderDuration);
+
+        if (commitMode.equals(CONSUMER_SYNC)) {
+            assertThat(unorderedDuration).as("Committing synchronously from the controller causes a large overhead, making UNORDERED very close in speed to KEY order, keySize of: " + numOfKeysToCompare)
+                    .isCloseTo(keyOrderHalfDefaultKeySize, keyOrderHalfDefaultKeySize.plus(keyOrderHalfDefaultKeySize.dividedBy(5))); // within 20%
+        } else {
+            assertThat(unorderedDuration).as("UNORDERED should be faster than KEY order, keySize of: " + numOfKeysToCompare)
+                    .isLessThan(keyOrderHalfDefaultKeySize);
+        }
+
+        assertThat(keyOrderHalfDefaultKeySize).as("KEY order is faster than PARTITION order")
+                .isLessThan(partitionOrderDuration);
     }
 
     /**
@@ -182,13 +213,12 @@ private void testTiming(int numberOfKeys, int quantityOfMessagesToProduce) {
 
         Queue<ConsumerRecord<String, String>> processingCheck = new ConcurrentLinkedQueue<ConsumerRecord<String, String>>();
 
-        parallelConsumer.pollAndProduce((rec) -> {
+        parallelConsumer.pollAndProduceMany((rec) -> {
             processingCheck.add(rec);
             int rangeOfTimeSimulatedProcessingTakesMs = 5;
             long sleepTime = (long) (Math.random() * rangeOfTimeSimulatedProcessingTakesMs);
             sleep(sleepTime);
             ProducerRecord<String, String> stub = new ProducerRecord<>(OUTPUT_TOPIC, "sk:" + rec.key(), "Processing took: " + sleepTime + ". SourceV:" + rec.value());
-//            ProducerRecord<String, String> stub = new ProducerRecord<>(OUTPUT_TOPIC, "sk:" + rec.key(), rec.value());
             bar.stepTo(producerSpy.history().size());
             return UniLists.of(stub);
         }, (x) -> {
@@ -196,7 +226,7 @@ private void testTiming(int numberOfKeys, int quantityOfMessagesToProduce) {
 //            log.debug(x.toString());
         });
 
-        Awaitility.waitAtMost(defaultTimeout.multipliedBy(10)).untilAsserted(() -> {
+        waitAtMost(defaultTimeout.multipliedBy(10)).untilAsserted(() -> {
             assertThat(super.successfulWork.size()).as("All messages expected messages were processed and successful").isEqualTo(quantityOfMessagesToProduce);
             assertThat(producerSpy.history().size()).as("All messages expected messages were processed and results produced").isEqualTo(quantityOfMessagesToProduce);
         });
@@ -205,8 +235,6 @@ private void testTiming(int numberOfKeys, int quantityOfMessagesToProduce) {
         log.info("Closing async client");
         parallelConsumer.close();
 
-        List<Map<String, Map<TopicPartition, OffsetAndMetadata>>> groupOffsetsHistory = producerSpy.consumerGroupOffsetsHistory();
-
         assertCommitsAlwaysIncrease();
 
         //
@@ -250,7 +278,13 @@ private void testTiming(int numberOfKeys, int quantityOfMessagesToProduce) {
         }
 
         assertThat(producerSpy.history().size()).as("Finally, all messages expected messages were produced").isEqualTo(quantityOfMessagesToProduce);
-        assertThat(groupOffsetsHistory).as("No offsets committed").hasSizeGreaterThan(0);
+        if (isUsingTransactionalProducer()) {
+            List<Map<String, Map<TopicPartition, OffsetAndMetadata>>> groupOffsetsHistory = producerSpy.consumerGroupOffsetsHistory(); // tx
+            assertThat(groupOffsetsHistory).as("No offsets committed").hasSizeGreaterThan(0); // tx
+        } else {
+            List<Map<TopicPartition, OffsetAndMetadata>> commitHistory = consumerSpy.getCommitHistoryInt();
+            assertThat(commitHistory).as("No offsets committed").hasSizeGreaterThan(0); // non-tx
+        }
 
         // clear messages
         super.successfulWork.clear();
diff --git a/parallel-consumer-core/src/test-integration/java/io/confluent/parallelconsumer/integrationTests/utils/KafkaClientUtils.java b/parallel-consumer-core/src/test-integration/java/io/confluent/parallelconsumer/integrationTests/utils/KafkaClientUtils.java
index ff9808c39..333bbcfd3 100644
--- a/parallel-consumer-core/src/test-integration/java/io/confluent/parallelconsumer/integrationTests/utils/KafkaClientUtils.java
+++ b/parallel-consumer-core/src/test-integration/java/io/confluent/parallelconsumer/integrationTests/utils/KafkaClientUtils.java
@@ -14,6 +14,7 @@
 import org.apache.kafka.clients.producer.ProducerConfig;
 import org.apache.kafka.common.serialization.StringDeserializer;
 import org.apache.kafka.common.serialization.StringSerializer;
+import org.jetbrains.annotations.NotNull;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.testcontainers.containers.KafkaContainer;
@@ -93,9 +94,15 @@ public <K, V> KafkaConsumer<K, V> createNewConsumer() {
     }
 
     public <K, V> KafkaConsumer<K, V> createNewConsumer(boolean newConsumerGroup) {
+        return createNewConsumer(newConsumerGroup, new Properties());
+    }
+
+    @NotNull
+    public <K, V> KafkaConsumer<K, V> createNewConsumer(boolean newConsumerGroup, Properties options) {
         if (newConsumerGroup) {
             props.put(ConsumerConfig.GROUP_ID_CONFIG, "group-1-" + RandomUtils.nextInt()); // new group
         }
+        props.putAll(options);
         KafkaConsumer<K, V> kvKafkaConsumer = new KafkaConsumer<>(props);
         log.debug("New consume {}", kvKafkaConsumer);
         return kvKafkaConsumer;
@@ -105,7 +112,12 @@ public <K, V> KafkaProducer<K, V> createNewProducer(boolean tx) {
         var txProps = new Properties();
         txProps.putAll(props);
         if (tx) {
-            txProps.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG, this.getClass().getSimpleName()); // required for tx
+            // random number so we get a unique producer tx session each time. Normally wouldn't do this in production,
+            // but sometimes running in the test suite our producers step on each other between test runs and this causes
+            // Producer Fenced exceptions:
+            // Error looks like: Producer attempted an operation with an old epoch. Either there is a newer producer with
+            // the same transactionalId, or the producer's transaction has been expired by the broker.
+            txProps.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG, this.getClass().getSimpleName() + ":" + RandomUtils.nextInt()); // required for tx
         }
         KafkaProducer<K, V> kvKafkaProducer = new KafkaProducer<>(txProps);
         log.debug("New producer {}", kvKafkaProducer);
diff --git a/parallel-consumer-core/src/test/java/io/confluent/csid/utils/EnumCartesianProductTestSets.java b/parallel-consumer-core/src/test/java/io/confluent/csid/utils/EnumCartesianProductTestSets.java
new file mode 100644
index 000000000..816d05f98
--- /dev/null
+++ b/parallel-consumer-core/src/test/java/io/confluent/csid/utils/EnumCartesianProductTestSets.java
@@ -0,0 +1,30 @@
+package io.confluent.csid.utils;
+
+import org.junitpioneer.jupiter.CartesianProductTest;
+
+/**
+ * Automatically extract enum constants
+ */
+public class EnumCartesianProductTestSets extends CartesianProductTest.Sets {
+
+    /**
+     * Simply pass in the enum class, otherwise use as normal.
+     *
+     * @see CartesianProductTest.Sets#add
+     */
+    @Override
+    public CartesianProductTest.Sets add(final Object... entries) {
+        Object[] finalEntries = entries;
+        if (entries.length == 1) {
+            Object entry = entries[0];
+            if (entry instanceof Class) {
+                Class<?> classEntry = (Class<?>) entry;
+                if (classEntry.isEnum()) {
+                    finalEntries = classEntry.getEnumConstants();
+                }
+            }
+        }
+        return super.add(finalEntries);
+    }
+
+}
diff --git a/parallel-consumer-core/src/test/java/io/confluent/csid/utils/KafkaTestUtils.java b/parallel-consumer-core/src/test/java/io/confluent/csid/utils/KafkaTestUtils.java
index b95a2ea6f..8777e1053 100644
--- a/parallel-consumer-core/src/test/java/io/confluent/csid/utils/KafkaTestUtils.java
+++ b/parallel-consumer-core/src/test/java/io/confluent/csid/utils/KafkaTestUtils.java
@@ -9,12 +9,12 @@
 import lombok.RequiredArgsConstructor;
 import lombok.Setter;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.kafka.clients.consumer.ConsumerGroupMetadata;
 import org.apache.kafka.clients.consumer.ConsumerRecord;
 import org.apache.kafka.clients.consumer.MockConsumer;
 import org.apache.kafka.clients.consumer.OffsetAndMetadata;
 import org.apache.kafka.clients.producer.MockProducer;
 import org.apache.kafka.common.TopicPartition;
+import org.assertj.core.api.Assertions;
 import org.assertj.core.util.Lists;
 import pl.tlinkowski.unij.api.UniLists;
 
@@ -22,12 +22,11 @@
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.stream.Collectors;
 
+import static io.confluent.csid.utils.Range.range;
 import static io.confluent.parallelconsumer.ParallelEoSStreamProcessorTestBase.CONSUMER_GROUP_ID;
 import static io.confluent.parallelconsumer.ParallelEoSStreamProcessorTestBase.INPUT_TOPIC;
-import static io.confluent.csid.utils.Range.range;
 import static java.lang.Math.random;
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.when;
 
 @Slf4j
 @RequiredArgsConstructor
@@ -37,11 +36,7 @@ public class KafkaTestUtils {
 
     int offset = 0;
 
-    public static final ConsumerGroupMetadata DEFAULT_GROUP_METADATA = new ConsumerGroupMetadata(CONSUMER_GROUP_ID);
-
-    public static void setupConsumer(MockConsumer mc) {
-        when(mc.groupMetadata()).thenReturn(DEFAULT_GROUP_METADATA);
-
+    public static void assignConsumerToTopic(final MockConsumer mc) {
         TopicPartition tp1 = new TopicPartition(INPUT_TOPIC, 1);
         TopicPartition tp0 = new TopicPartition(INPUT_TOPIC, 0);
         mc.assign(Lists.list(tp0, tp1));
@@ -52,6 +47,19 @@ public static void setupConsumer(MockConsumer mc) {
         mc.updateBeginningOffsets(beginningOffsets);
     }
 
+    /**
+     * It's a race to see if the genesis offset gets committed or not. So lets remove it if it exists, and all tests can
+     * assume it doesnt.
+     */
+    public static List<Integer> trimAllGeneisOffset(final List<Integer> collect) {
+        while (!collect.isEmpty() && collect.get(0) == 0) {
+            int genesisOffset = collect.get(0);
+            if (genesisOffset == 0)
+                collect.remove(0);
+        }
+        return collect;
+    }
+
     public ConsumerRecord<String, String> makeRecord(String key, String value) {
         return makeRecord(0, key, value);
     }
@@ -75,7 +83,7 @@ public static void assertCommits(MockProducer mp, List<Integer> expectedOffsets,
         log.debug("Asserting commits of {}", expectedOffsets);
         List<Map<String, Map<TopicPartition, OffsetAndMetadata>>> history = mp.consumerGroupOffsetsHistory();
 
-        Set<Integer> set = history.stream().flatMap(histories -> {
+        List<Integer> set = history.stream().flatMap(histories -> {
             // get all partition offsets and flatten
             var results = new ArrayList<Integer>();
             var group = histories.get(CONSUMER_GROUP_ID);
@@ -84,36 +92,46 @@ public static void assertCommits(MockProducer mp, List<Integer> expectedOffsets,
                 int offset = (int) commit.offset();
                 results.add(offset);
             }
-            return results.stream();
-        }).collect(Collectors.toSet()); // set - ignore repeated commits ({@link OffsetMap})
+            List<Integer> integers = KafkaTestUtils.trimAllGeneisOffset(results);
+            return integers.stream();
+        }).collect(Collectors.toList()); // set - ignore repeated commits ({@link OffsetMap})
 
         assertThat(set).describedAs(description.orElse("Which offsets are committed and in the expected order"))
                 .containsExactlyElementsOf(expectedOffsets);
     }
 
+    public static void assertCommitLists(MockProducer mp, List<List<Integer>> expectedPartitionOffsets, Optional<String> description) {
+        assertCommitLists(mp.consumerGroupOffsetsHistory(), expectedPartitionOffsets, description);
+    }
+
     /**
-     * Collects into a set - ignore repeated commits ({@link OffsetMapCodecManager})
+     * Collects into a set - ignore repeated commits ({@link OffsetMapCodecManager}).
+     * <p>
+     * Ignores duplicates.
      *
      * @see OffsetMapCodecManager
      */
-    public static void assertCommitLists(MockProducer mp, List<List<Integer>> expectedPartitionOffsets, Optional<String> description) {
+    public static void assertCommitLists(List<Map<String, Map<TopicPartition, OffsetAndMetadata>>> history, List<List<Integer>> expectedPartitionOffsets, Optional<String> description) {
         log.info("Asserting commits of {}", expectedPartitionOffsets);
-        List<Map<String, Map<TopicPartition, OffsetAndMetadata>>> history = mp.consumerGroupOffsetsHistory();
 
         AtomicReference<String> topicName = new AtomicReference<>("");
-        var results = new HashMap<TopicPartition, Set<Integer>>(); // set - ignore repeated commits ({@link OffsetMap})
-        history.stream().forEachOrdered(histories -> {
+        var partitionToCommittedOffsets = new HashMap<TopicPartition, Set<Integer>>(); // set - ignore repeated commits ({@link OffsetMap})
+        new ArrayList<>(history).stream().forEachOrdered(histories -> {
             // get all partition offsets and flatten
-            var group = histories.get(CONSUMER_GROUP_ID);
-            for (var actualPartitionOffsets : group.entrySet()) {
-                TopicPartition key = actualPartitionOffsets.getKey();
+            var partitionCommits = histories.get(CONSUMER_GROUP_ID);
+            for (var singlePartitionCommit : partitionCommits.entrySet()) {
+                TopicPartition key = singlePartitionCommit.getKey();
                 topicName.set(key.topic());
-                OffsetAndMetadata commit = actualPartitionOffsets.getValue();
+                OffsetAndMetadata commit = singlePartitionCommit.getValue();
                 int offset = (int) commit.offset();
-                results.computeIfAbsent(key, x -> new HashSet<>()).add(offset);
+                partitionToCommittedOffsets.computeIfAbsent(key, x -> new HashSet<>());
+                // ignore genesis commits
+                if (offset != 0)
+                    partitionToCommittedOffsets.get(key).add(offset);
             }
         });
 
+        // compute the matching expected map
         var expectedMap = new HashMap<TopicPartition, Set<Integer>>();
         for (int i = 0; i < expectedPartitionOffsets.size(); i++) {
             List<Integer> offsets = expectedPartitionOffsets.get(i);
@@ -121,10 +139,17 @@ public static void assertCommitLists(MockProducer mp, List<List<Integer>> expect
             expectedMap.put(tp, new HashSet<>(offsets));
         }
 
-        assertThat(results).describedAs(description.orElse("Which offsets are committed and in the expected order"))
+        assertThat(partitionToCommittedOffsets).describedAs(description.orElse("Which offsets are committed and in the expected order"))
                 .containsExactlyEntriesOf(expectedMap);
     }
 
+    public static void assertLastCommitIs(final LongPollingMockConsumer<String, String> mockConsumer, final int expected) {
+        List<Map<TopicPartition, OffsetAndMetadata>> commits = mockConsumer.getCommitHistoryInt();
+        Assertions.assertThat(commits).isNotEmpty();
+        long offset = (int) commits.get(commits.size() - 1).values().iterator().next().offset();
+        Assertions.assertThat(offset).isEqualTo(expected);
+    }
+
     public List<ConsumerRecord<String, String>> generateRecords(int quantity) {
         HashMap<Integer, List<ConsumerRecord<String, String>>> integerListHashMap = generateRecords(defaultKeys, quantity);
         return flatten(integerListHashMap.values());
diff --git a/parallel-consumer-core/src/test/java/io/confluent/csid/utils/LongPollingMockConsumer.java b/parallel-consumer-core/src/test/java/io/confluent/csid/utils/LongPollingMockConsumer.java
index daebfe0b9..798ff44c6 100644
--- a/parallel-consumer-core/src/test/java/io/confluent/csid/utils/LongPollingMockConsumer.java
+++ b/parallel-consumer-core/src/test/java/io/confluent/csid/utils/LongPollingMockConsumer.java
@@ -4,12 +4,19 @@
  * Copyright (C) 2020 Confluent, Inc.
  */
 
+import lombok.Getter;
+import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.kafka.clients.consumer.ConsumerRecords;
-import org.apache.kafka.clients.consumer.MockConsumer;
-import org.apache.kafka.clients.consumer.OffsetResetStrategy;
+import org.apache.kafka.clients.consumer.*;
+import org.apache.kafka.clients.consumer.internals.SubscriptionState;
+import org.apache.kafka.clients.producer.MockProducer;
+import org.apache.kafka.common.TopicPartition;
 
+import java.lang.reflect.Field;
 import java.time.Duration;
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
 
 /**
  * Used in tests to stub out the behaviour of the real Broker and Client's long polling system (the mock Kafka Consumer
@@ -21,6 +28,9 @@
 @Slf4j
 public class LongPollingMockConsumer<K, V> extends MockConsumer<K, V> {
 
+    @Getter
+    private final List<Map<TopicPartition, OffsetAndMetadata>> commitHistoryInt = new ArrayList<>();
+
     public LongPollingMockConsumer(OffsetResetStrategy offsetResetStrategy) {
         super(offsetResetStrategy);
     }
@@ -53,5 +63,79 @@ public synchronized void wakeup() {
         }
     }
 
+    @Override
+    public synchronized void commitAsync(final Map<TopicPartition, OffsetAndMetadata> offsets, final OffsetCommitCallback callback) {
+        commitHistoryInt.add(offsets);
+        super.commitAsync(offsets, callback);
+    }
+
+    /**
+     * Makes the commit history look like the {@link MockProducer}s one so we can use the same assert method.
+     *
+     * @see KafkaTestUtils#assertCommitLists(List, List, Optional)
+     */
+    private List<Map<String, Map<TopicPartition, OffsetAndMetadata>>> injectConsumerGroupId(final List<Map<TopicPartition, OffsetAndMetadata>> commitHistory) {
+        String groupId = this.groupMetadata().groupId();
+        return commitHistory.stream()
+                .map(x -> {
+                    HashMap<String, Map<TopicPartition, OffsetAndMetadata>> stringMapHashMap = new HashMap<>();
+                    stringMapHashMap.put(groupId, x);
+                    return stringMapHashMap;
+                })
+                .collect(Collectors.toList());
+    }
+
+    /**
+     * Makes the commit history look like the {@link MockProducer}s one so we can use the same assert method.
+     *
+     * @see KafkaTestUtils#assertCommitLists(List, List, Optional)
+     */
+    public List<Map<String, Map<TopicPartition, OffsetAndMetadata>>> getCommitHistoryWithGropuId() {
+        return injectConsumerGroupId(getCommitHistoryInt());
+    }
+
+    @Override
+    @SneakyThrows
+    public synchronized void close(final long timeout, final TimeUnit unit) {
+        revokeAssignment();
+        super.close(timeout, unit);
+    }
+
+    /**
+     * {@link MockConsumer} fails to implement any {@link ConsumerRebalanceListener} system, so we manually revoke
+     * assignments, use reflection to access the registered rebalance listener, call the listener, and only then close
+     * the consumer.
+     *
+     * @see io.confluent.parallelconsumer.ParallelEoSStreamProcessor#onPartitionsRevoked
+     */
+    private void revokeAssignment() throws NoSuchFieldException, IllegalAccessException {
+        // access listener
+        Field subscriptionsField = MockConsumer.class.getDeclaredField("subscriptions"); //NoSuchFieldException
+        subscriptionsField.setAccessible(true);
+        SubscriptionState subscriptionState = (SubscriptionState) subscriptionsField.get(this); //IllegalAccessException
+        ConsumerRebalanceListener consumerRebalanceListener = subscriptionState.rebalanceListener();
+
+        // execute
+        if (consumerRebalanceListener == null) {
+            log.warn("No rebalance listener assigned - on revoke can't fire");
+        } else {
+            Set<TopicPartition> assignment = super.assignment();
+            consumerRebalanceListener.onPartitionsRevoked(assignment);
+        }
+    }
+
+    public void subscribeWithRebalanceAndAssignment(final List<String> topics, int partitions) {
+        List<TopicPartition> topicPartitions = topics.stream()
+                .flatMap(y -> Range.rangeStream(partitions).boxed()
+                        .map(x -> new TopicPartition(y, x)))
+                .collect(Collectors.toList());
+        super.rebalance(topicPartitions);
+        //
+        HashMap<TopicPartition, Long> beginningOffsets = new HashMap<>();
+        for (var tp : topicPartitions) {
+            beginningOffsets.put(tp, 0L);
+        }
+        super.updateBeginningOffsets(beginningOffsets);
+    }
 
-}
+}
\ No newline at end of file
diff --git a/parallel-consumer-core/src/test/java/io/confluent/csid/utils/MyRunListener.java b/parallel-consumer-core/src/test/java/io/confluent/csid/utils/MyRunListener.java
new file mode 100644
index 000000000..52a9ba670
--- /dev/null
+++ b/parallel-consumer-core/src/test/java/io/confluent/csid/utils/MyRunListener.java
@@ -0,0 +1,54 @@
+package io.confluent.csid.utils;
+
+import com.google.auto.service.AutoService;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.platform.engine.TestExecutionResult;
+import org.junit.platform.engine.reporting.ReportEntry;
+import org.junit.platform.launcher.TestExecutionListener;
+import org.junit.platform.launcher.TestIdentifier;
+import org.junit.platform.launcher.TestPlan;
+
+import static io.confluent.csid.utils.StringUtils.msg;
+
+/**
+ * Print out test names in Maven output, not just class names. Useful for added context for failures in CI runs.
+ * <p>
+ * {@link AutoService} should work and load this automaticly, but something isn't working. So this is loaded manually
+ * through the META-INF/serices/org.junit.platform.launcher.TestExecutionListener
+ * <pre>
+ *  https://stackoverflow.com/questions/49937451/junit-5-is-it-possible-to-set-a-testexecutionlistener-in-maven-surefire-plugin
+ *  https://junit.org/junit5/docs/current/user-guide/#launcher-api-listeners-custom
+ *  https://github.com/google/auto/tree/master/service
+ *  https://stackoverflow.com/a/50058828/105741
+ * </pre>
+ */
+@AutoService(TestExecutionListener.class)
+public class MyRunListener implements TestExecutionListener {
+
+    private final String template = """
+
+            =========
+               JUNIT {}:    {} ({})
+            =========
+            """;
+
+    @Override
+    public void testPlanExecutionStarted(final TestPlan testPlan) {
+        log(msg(template, "Test plan execution started", testPlan, ""));
+    }
+
+    private void log(final String msg) {
+        System.out.println(msg);
+    }
+
+    @Override
+    public void executionSkipped(final TestIdentifier testIdentifier, final String reason) {
+        log(msg(template, "skipped", testIdentifier.getDisplayName(), reason));
+    }
+
+    @Override
+    public void executionStarted(final TestIdentifier testIdentifier) {
+        log(msg(template, "started", testIdentifier.getDisplayName(), testIdentifier.getLegacyReportingName()));
+    }
+
+}
diff --git a/parallel-consumer-core/src/test/java/io/confluent/csid/utils/TestLogger.java b/parallel-consumer-core/src/test/java/io/confluent/csid/utils/TestLogger.java
deleted file mode 100644
index 972e07f20..000000000
--- a/parallel-consumer-core/src/test/java/io/confluent/csid/utils/TestLogger.java
+++ /dev/null
@@ -1,38 +0,0 @@
-package io.confluent.csid.utils;
-
-/*-
- * Copyright (C) 2020 Confluent, Inc.
- */
-
-import com.google.auto.service.AutoService;
-import lombok.extern.slf4j.Slf4j;
-import org.junit.jupiter.api.extension.BeforeEachCallback;
-import org.junit.jupiter.api.extension.ExtensionContext;
-import org.junit.platform.launcher.TestExecutionListener;
-import org.junit.platform.launcher.TestIdentifier;
-
-/**
- * Print out test names in Maven output, not just class names. Useful for added context for failures in CI runs.
- * <p>
- * Happy times... =D
- * <p>
- * https://stackoverflow.com/questions/49937451/junit-5-is-it-possible-to-set-a-testexecutionlistener-in-maven-surefire-plugin
- * https://junit.org/junit5/docs/current/user-guide/#launcher-api-listeners-custom
- * https://github.com/google/auto/tree/master/service
- * https://stackoverflow.com/a/50058828/105741
- */
-@AutoService(TestExecutionListener.class)
-@Slf4j
-public class TestLogger implements TestExecutionListener {
-
-    @Override
-    public void executionStarted(TestIdentifier testIdentifier) {
-//        log.info("-------------------------------------------------------");
-//        log.info(testIdentifier.getDisplayName());
-//        log.info("-------------------------------------------------------");
-        System.out.println("-------------------------------------------------------");
-        System.out.println(testIdentifier.getDisplayName());
-        System.out.println("-------------------------------------------------------");
-    }
-
-}
diff --git a/parallel-consumer-core/src/test/java/io/confluent/parallelconsumer/JStreamParallelEoSStreamProcessorTest.java b/parallel-consumer-core/src/test/java/io/confluent/parallelconsumer/JStreamParallelEoSStreamProcessorTest.java
index aab0365a9..f84df4b96 100644
--- a/parallel-consumer-core/src/test/java/io/confluent/parallelconsumer/JStreamParallelEoSStreamProcessorTest.java
+++ b/parallel-consumer-core/src/test/java/io/confluent/parallelconsumer/JStreamParallelEoSStreamProcessorTest.java
@@ -36,9 +36,8 @@ public void setupData() {
     }
 
     @Override
-    protected ParallelEoSStreamProcessor initAsyncConsumer(ParallelConsumerOptions parallelConsumerOptions) {
-        ParallelConsumerOptions options = ParallelConsumerOptions.builder().build();
-        streaming = new JStreamParallelEoSStreamProcessor<>(consumerSpy, producerSpy, options);
+    protected ParallelEoSStreamProcessor initAsyncConsumer(ParallelConsumerOptions options) {
+        streaming = new JStreamParallelEoSStreamProcessor<>(options);
 
         return streaming;
     }
diff --git a/parallel-consumer-core/src/test/java/io/confluent/parallelconsumer/ParallelEoSStreamProcessorTest.java b/parallel-consumer-core/src/test/java/io/confluent/parallelconsumer/ParallelEoSStreamProcessorTest.java
index 923ba0a4c..26d9a7541 100644
--- a/parallel-consumer-core/src/test/java/io/confluent/parallelconsumer/ParallelEoSStreamProcessorTest.java
+++ b/parallel-consumer-core/src/test/java/io/confluent/parallelconsumer/ParallelEoSStreamProcessorTest.java
@@ -4,7 +4,7 @@
  * Copyright (C) 2020 Confluent, Inc.
  */
 
-import io.confluent.csid.utils.WallClock;
+import io.confluent.parallelconsumer.ParallelConsumerOptions.CommitMode;
 import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.kafka.clients.consumer.ConsumerGroupMetadata;
@@ -12,29 +12,34 @@
 import org.apache.kafka.clients.consumer.ConsumerRecords;
 import org.apache.kafka.clients.consumer.OffsetAndMetadata;
 import org.apache.kafka.clients.producer.ProducerRecord;
-import org.apache.kafka.clients.producer.RecordMetadata;
 import org.apache.kafka.common.TopicPartition;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.Timeout;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.EnumSource;
 import org.mockito.ArgumentMatchers;
 import org.mockito.Mockito;
+import pl.tlinkowski.unij.api.UniLists;
 
 import java.time.Duration;
 import java.util.*;
 import java.util.concurrent.CountDownLatch;
 import java.util.function.Function;
 
-import static io.confluent.parallelconsumer.ParallelConsumerOptions.ProcessingOrder.KEY;
 import static io.confluent.csid.utils.GeneralTestUtils.time;
 import static io.confluent.csid.utils.KafkaUtils.toTP;
 import static io.confluent.csid.utils.Range.range;
+import static io.confluent.parallelconsumer.ParallelConsumerOptions.CommitMode.CONSUMER_ASYNCHRONOUS;
+import static io.confluent.parallelconsumer.ParallelConsumerOptions.CommitMode.TRANSACTIONAL_PRODUCER;
+import static io.confluent.parallelconsumer.ParallelConsumerOptions.ProcessingOrder.KEY;
 import static java.time.Duration.ofMillis;
-
+import static java.time.Duration.ofSeconds;
 import static java.util.concurrent.TimeUnit.SECONDS;
 import static org.assertj.core.api.Assertions.*;
 import static org.awaitility.Awaitility.await;
+import static org.awaitility.Awaitility.setDefaultConditionEvaluationListener;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 import static org.mockito.internal.verification.VerificationModeFactory.times;
@@ -58,9 +63,12 @@ public void setupData() {
         primeFirstRecord();
     }
 
-    @Test
+    @ParameterizedTest()
+    @EnumSource(CommitMode.class)
     @SneakyThrows
-    public void failingActionNothingCommitted() {
+    public void failingActionNothingCommitted(CommitMode commitMode) {
+        setupParallelConsumerInstance(commitMode);
+
         parallelConsumer.poll((ignore) -> {
             throw new RuntimeException("My user's function error");
         });
@@ -70,8 +78,9 @@ public void failingActionNothingCommitted() {
         waitForSomeLoopCycles(loops);
 
         //
-        assertCommits(of(0), "All erroring, nothing committed except initial");
-        List<Map<String, Map<TopicPartition, OffsetAndMetadata>>> maps = producerSpy.consumerGroupOffsetsHistory();
+        assertCommits(of(), "All erroring, nothing committed except initial");
+        List<Map<String, Map<TopicPartition, OffsetAndMetadata>>> maps = getCommitHistory();
+        assertThat(maps).isNotEmpty();
         List<OffsetAndMetadata> metas = new ArrayList<>();
         for (final Map<String, Map<TopicPartition, OffsetAndMetadata>> map : maps) {
             for (final Map<TopicPartition, OffsetAndMetadata> value : map.values()) {
@@ -88,9 +97,12 @@ public void failingActionNothingCommitted() {
         }
     }
 
-    @Test
+    @ParameterizedTest()
+    @EnumSource(CommitMode.class)
     @SneakyThrows
-    public void offsetsAreNeverCommittedForMessagesStillInFlightSimplest() {
+    public void offsetsAreNeverCommittedForMessagesStillInFlightSimplest(CommitMode commitMode) {
+        setupParallelConsumerInstance(commitMode);
+
         sendSecondRecord(consumerSpy);
 
         var locks = constructLatches(2);
@@ -114,10 +126,12 @@ public void offsetsAreNeverCommittedForMessagesStillInFlightSimplest() {
         // finish processing 1
         releaseAndWait(locks, 1);
 
+        parallelConsumer.requestCommitAsap();
+
         // make sure no offsets are committed
-        assertCommits(of(0), "Partition is blocked");
+        assertCommits(of(), "Partition is blocked");
 
-        // So it's data setup can be used in other tests, finish 0
+        // So it's data is setup can be used in other tests, finish 0
         releaseAndWait(locks, 0);
 
         log.debug("Closing...");
@@ -126,26 +140,37 @@ public void offsetsAreNeverCommittedForMessagesStillInFlightSimplest() {
         assertThat(processedStates.values()).as("sanity - all expected messages are processed").containsExactly(true, true);
     }
 
-    @Test
-    public void offsetsAreNeverCommittedForMessagesStillInFlightShort() {
-        offsetsAreNeverCommittedForMessagesStillInFlightSimplest();
+    private void setupParallelConsumerInstance(final CommitMode commitMode) {
+        setupParallelConsumerInstance(getBaseOptions(commitMode));
+        // created a new client above, so have to send the prime record again
+        primeFirstRecord();
+    }
 
+    private ParallelConsumerOptions getBaseOptions(final CommitMode commitMode) {
+        return ParallelConsumerOptions.<String, String>builder()
+                .commitMode(commitMode)
+                .consumer(consumerSpy)
+                .producer(producerSpy)
+                .build();
+    }
+
+    @ParameterizedTest()
+    @EnumSource(CommitMode.class)
+    @SneakyThrows
+    public void offsetsAreNeverCommittedForMessagesStillInFlightShort(CommitMode commitMode) {
+        offsetsAreNeverCommittedForMessagesStillInFlightSimplest(commitMode);
         log.info("Test start");
 
-        // make sure offset 1, not 0 is committed
-        // check only 1 is now committed, not committing 0 as well is a performance thing
-        verify(producerSpy,
-                after(verificationWaitDelay)
-                        .atLeast(1)
-                        .description("wait for at least one commit call"))
-                .commitTransaction();
-
-        assertCommits(of(0, 2), "Only one of the two offsets committed, as they were coalesced for efficiency");
+        // next expected offset is now 2
+        assertCommits(of(2), "Only one of the two offsets committed, as they were coalesced for efficiency");
     }
 
     @Disabled
-    @Test
-    public void offsetsAreNeverCommittedForMessagesStillInFlightLong() {
+    @ParameterizedTest()
+    @EnumSource(CommitMode.class)
+    public void offsetsAreNeverCommittedForMessagesStillInFlightLong(CommitMode commitMode) {
+        setupParallelConsumerInstance(commitMode);
+
         sendSecondRecord(consumerSpy);
 
         // send three messages - 0, 1, 2
@@ -224,8 +249,12 @@ public void offsetsAreNeverCommittedForMessagesStillInFlightLong() {
         parallelConsumer.close();
     }
 
-    @Test
-    public void offsetCommitsAreIsolatedPerPartition() {
+    @ParameterizedTest()
+    @EnumSource(CommitMode.class)
+    @SneakyThrows
+    public void offsetCommitsAreIsolatedPerPartition(CommitMode commitMode) {
+        setupParallelConsumerInstance(commitMode);
+
         sendSecondRecord(consumerSpy);
 
         // send three messages - 0,1, to one partition and 3,4 to another partition petitions
@@ -252,29 +281,42 @@ public void offsetCommitsAreIsolatedPerPartition() {
         // finish processing 1
         releaseAndWait(locks, 1);
 
+        parallelConsumer.requestCommitAsap();
+
+        waitForSomeLoopCycles(2);
+
         // make sure only base offsets are committed
-        assertCommits(of(0, 2));
-        assertCommitLists(of(of(0), of(2)));
+//        assertCommits(of(2));
+        assertCommitLists(of(of(), of(2)));
 
         // finish 2
         releaseAndWait(locks, 2);
+        parallelConsumer.requestCommitAsap();
         waitForOneLoopCycle();
 
         // make sure only 2 on it's partition of committed
-        assertCommits(of(0, 2, 3));
-        assertCommitLists(of(of(0), of(2, 3)));
+//        assertCommits(of(2, 3));
+        assertCommitLists(of(of(), of(2, 3)));
 
         // finish 0
         releaseAndWait(locks, 0);
 
+        parallelConsumer.requestCommitAsap();
+
+        waitForOneLoopCycle();
+
         // make sure offset 0 and 1 is committed
-        assertCommitLists(of(of(0, 2), of(2, 3)));
+        assertCommitLists(of(of(2), of(2, 3)));
 
         // finish 3
         releaseAndWait(locks, 3);
 
+        // async consumer is slower to execute the commit. We could just wait, or we could add an event to the async consumer commit cycle
+        if (isUsingAsyncCommits())
+            waitForOneLoopCycle();
+
         //
-        assertCommitLists(of(of(0, 2), of(2, 3, 4)));
+        assertCommitLists(of(of(2), of(2, 3, 4)));
     }
 
     @Test
@@ -288,32 +330,40 @@ public void avro() {
         assertThat(false).isTrue();
     }
 
-    @Test
-    @SneakyThrows
-    public void controlFlowException() {
-        //
-        WallClock mock = mock(WallClock.class);
-        when(mock.getNow()).thenThrow(new RuntimeException("My fake control loop error"));
-        parallelConsumer.setClock(mock);
+    @ParameterizedTest()
+    @EnumSource(CommitMode.class)
+    public void controlFlowException(CommitMode commitMode) {
+        // setup again manually to use subscribe instead of assign (for revoke testing)
+        instantiateConsumerProducer();
+        parallelConsumer = initAsyncConsumer(getBaseOptions(commitMode));
+        subscribeParallelConsumerAndMockConsumerTo(INPUT_TOPIC);
+        setupData();
+
+        // cause a control loop error
+        parallelConsumer.addLoopEndCallBack(() -> {
+            throw new RuntimeException("My fake control loop error");
+        });
 
         //
         parallelConsumer.poll((ignore) -> {
-            // ignore
+            log.info("Ignoring {}", ignore);
         });
 
         // close and retrieve exception in control loop
         assertThatThrownBy(() -> {
-            parallelConsumer.closeDontDrainFirst();
+            parallelConsumer.closeDrainFirst(ofSeconds(10));
         }).hasMessageContainingAll("Error", "poll", "thread", "fake control");
     }
 
-    @Test
+    @ParameterizedTest()
+    @EnumSource(CommitMode.class)
     @SneakyThrows
-    public void testVoid() {
+    public void testVoid(CommitMode commitMode) {
+        setupParallelConsumerInstance(commitMode);
+
         int expected = 1;
         var msgCompleteBarrier = new CountDownLatch(expected);
         parallelConsumer.poll((record) -> {
-            waitForInitialBootstrapCommit();
             myRecordProcessingAction.apply(record);
             msgCompleteBarrier.countDown();
         });
@@ -322,31 +372,18 @@ public void testVoid() {
 
         waitForSomeLoopCycles(1);
 
-        assertCommits(of(0, 1));
+        parallelConsumer.close();
 
-        verify(myRecordProcessingAction, times(expected)).apply(any());
-        verify(producerSpy, atLeastOnce()).commitTransaction();
-        verify(producerSpy, atLeastOnce()).sendOffsetsToTransaction(anyMap(), ArgumentMatchers.<ConsumerGroupMetadata>any());
-    }
+        assertCommits(of(1));
 
-    /**
-     * Allow time for offset zero to be committed
-     */
-    private void waitForInitialBootstrapCommit() {
-        await("for initial commit")
-                .pollDelay(ofMillis(0))
-                .pollInterval(ofMillis(DEFAULT_COMMIT_INTERVAL_MAX_MS / 2))
-                .untilAsserted(() -> assertCommits(of(0)));
-    }
-
-    @Test
-    public void testProducerStep() {
-        ProducerRecord<String, String> outMsg = new ProducerRecord(OUTPUT_TOPIC, "");
-        RecordMetadata prodResult = parallelConsumer.produceMessage(outMsg);
-        assertThat(prodResult).isNotNull();
+        verify(myRecordProcessingAction, times(expected)).apply(any());
 
-        List<ProducerRecord<String, String>> history = producerSpy.history();
-        assertThat(history).hasSize(1);
+        // assert internal methods - shouldn't really need this as we already check the commit history above through the
+        // spy, so can leave in for the old producer style
+        if (commitMode.equals(TRANSACTIONAL_PRODUCER)) {
+            verify(producerSpy, atLeastOnce()).commitTransaction();
+            verify(producerSpy, atLeastOnce()).sendOffsetsToTransaction(anyMap(), ArgumentMatchers.<ConsumerGroupMetadata>any());
+        }
     }
 
     @Test
@@ -381,18 +418,21 @@ public void failingMessagesThatAreRetriedDontBreakProcessingOrders() {
     public void ifTooManyMessagesAreInFlightDontPollBrokerForMore() {
     }
 
+    @ParameterizedTest()
+    @EnumSource(CommitMode.class)
     @SneakyThrows
-    @Test
     @Disabled
-    public void processInKeyOrder() {
-        ParallelConsumerOptions options = ParallelConsumerOptions.builder().ordering(KEY).build();
-        setupAsyncConsumerInstance(options);
+    public void processInKeyOrder(CommitMode commitMode) {
+        setupParallelConsumerInstance(ParallelConsumerOptions.builder()
+                .commitMode(commitMode)
+                .ordering(KEY)
+                .build());
+        // created a new client above, so have to send the prime record again
+        primeFirstRecord();
 
         // sanity check
         assertThat(parallelConsumer.wm.getOptions().getOrdering()).isEqualTo(KEY);
 
-        primeFirstRecord();
-
         sendSecondRecord(consumerSpy);
 
         // 0,1 previously sent to partition 0
@@ -534,7 +574,7 @@ public void processInKeyOrder() {
     @Test
     public void processInKeyOrderWorkNotReturnedDoesntBreakCommits() {
         ParallelConsumerOptions options = ParallelConsumerOptions.builder().ordering(KEY).build();
-        setupAsyncConsumerInstance(options);
+        setupParallelConsumerInstance(options);
         primeFirstRecord();
 
         sendSecondRecord(consumerSpy);
@@ -612,12 +652,14 @@ public void processInKeyOrderWorkNotReturnedDoesntBreakCommits() {
         }
     }
 
-    @Test
-    public void closeAfterSingleMessageShouldBeEventBasedFast() {
+    @ParameterizedTest()
+    @EnumSource(CommitMode.class)
+    public void closeAfterSingleMessageShouldBeEventBasedFast(CommitMode commitMode) {
+        setupParallelConsumerInstance(commitMode);
+
         var msgCompleteBarrier = new CountDownLatch(1);
 
         parallelConsumer.poll((ignore) -> {
-            waitForInitialBootstrapCommit();
             log.info("Message processed: {} - noop", ignore.offset());
             msgCompleteBarrier.countDown();
         });
@@ -627,7 +669,11 @@ public void closeAfterSingleMessageShouldBeEventBasedFast() {
         // allow for offset to be committed
         waitForOneLoopCycle();
 
-        assertCommits(of(0, 1));
+        parallelConsumer.requestCommitAsap();
+
+        waitForOneLoopCycle();
+
+        assertCommits(of(1));
 
         // close
         Duration time = time(() -> {
@@ -639,8 +685,11 @@ public void closeAfterSingleMessageShouldBeEventBasedFast() {
                 .isLessThan(ofMillis(500));
     }
 
-    @Test
-    public void closeWithoutRunningShouldBeEventBasedFast() {
+    @ParameterizedTest()
+    @EnumSource(CommitMode.class)
+    public void closeWithoutRunningShouldBeEventBasedFast(CommitMode commitMode) {
+        setupParallelConsumerInstance(getBaseOptions(commitMode));
+
         parallelConsumer.closeDontDrainFirst();
     }
 
@@ -654,4 +703,102 @@ public void ensureLibraryCantBeUsedTwice() {
         });
     }
 
+    @ParameterizedTest()
+    @EnumSource(CommitMode.class)
+    void consumeFlowDoesntRequireProducer(CommitMode commitMode) {
+        setupClients();
+
+        var optionsWithClients = ParallelConsumerOptions.<String, String>builder()
+                .consumer(consumerSpy)
+                .commitMode(commitMode)
+                .build();
+
+        if (commitMode.equals(TRANSACTIONAL_PRODUCER)) {
+            assertThatThrownBy(() -> parallelConsumer = initAsyncConsumer(optionsWithClients))
+                    .isInstanceOf(IllegalArgumentException.class)
+                    .hasMessageContaining("Producer", "Transaction");
+        } else {
+            parallelConsumer = initAsyncConsumer(optionsWithClients);
+            attachLoopCounter(parallelConsumer);
+
+            subscribeParallelConsumerAndMockConsumerTo(INPUT_TOPIC);
+            setupData();
+
+            parallelConsumer.poll((ignore) -> {
+                //ignore
+            });
+
+            waitForSomeLoopCycles(2);
+
+            parallelConsumer.closeDrainFirst();
+
+            //
+            assertCommits(of(1));
+        }
+    }
+
+    @Test
+    void produceMessageFlowRequiresProducer() {
+        setupClients();
+
+        var optionsWithClients = ParallelConsumerOptions.<String, String>builder()
+                .consumer(consumerSpy)
+                .commitMode(TRANSACTIONAL_PRODUCER)
+                .build();
+
+        assertThatThrownBy(() -> parallelConsumer = initAsyncConsumer(optionsWithClients))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessageContaining("Producer", "Transaction");
+    }
+
+    @Test
+    void cantUseProduceFlowWithWrongOptions() throws InterruptedException {
+        setupClients();
+
+        // forget to supply producer
+        var optionsWithClients = ParallelConsumerOptions.<String, String>builder()
+                .consumer(consumerSpy)
+                .commitMode(CONSUMER_ASYNCHRONOUS)
+                .build();
+
+        setupParallelConsumerInstance(optionsWithClients);
+
+        subscribeParallelConsumerAndMockConsumerTo(INPUT_TOPIC);
+
+        setupData();
+
+        var parallel = initAsyncConsumer(optionsWithClients);
+
+        assertThatThrownBy(() -> parallel.pollAndProduce((record) ->
+                new ProducerRecord<>(INPUT_TOPIC, "hi there")))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessageContaining("Producer", "Transaction");
+    }
+
+    @ParameterizedTest()
+    @EnumSource(CommitMode.class)
+    public void produceMessageFlow(CommitMode commitMode) {
+        setupParallelConsumerInstance(commitMode);
+
+        parallelConsumer.pollAndProduce((ignore) -> new ProducerRecord<>("Hello", "there"));
+
+        // let it process
+        waitForSomeLoopCycles(2);
+
+        parallelConsumer.requestCommitAsap();
+//        requestCommitAndPause();
+
+        parallelConsumer.closeDrainFirst();
+
+        //
+        assertCommits(of(1));
+
+        assertThat(producerSpy.history()).hasSize(1);
+    }
+
+    private void requestCommitAndPause() {
+        parallelConsumer.requestCommitAsap();
+        waitForSomeLoopCycles(2);
+    }
 }
+
diff --git a/parallel-consumer-core/src/test/java/io/confluent/parallelconsumer/ParallelEoSStreamProcessorTestBase.java b/parallel-consumer-core/src/test/java/io/confluent/parallelconsumer/ParallelEoSStreamProcessorTestBase.java
index c20cbdbbe..e01c3d3db 100644
--- a/parallel-consumer-core/src/test/java/io/confluent/parallelconsumer/ParallelEoSStreamProcessorTestBase.java
+++ b/parallel-consumer-core/src/test/java/io/confluent/parallelconsumer/ParallelEoSStreamProcessorTestBase.java
@@ -6,28 +6,33 @@
 
 import io.confluent.csid.utils.KafkaTestUtils;
 import io.confluent.csid.utils.LongPollingMockConsumer;
+import io.confluent.parallelconsumer.ParallelConsumerOptions.ProcessingOrder;
 import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.kafka.clients.consumer.*;
 import org.apache.kafka.clients.producer.MockProducer;
 import org.apache.kafka.common.TopicPartition;
 import org.junit.jupiter.api.BeforeEach;
+import pl.tlinkowski.unij.api.UniLists;
 import pl.tlinkowski.unij.api.UniMaps;
 
 import java.time.Duration;
 import java.util.*;
-import java.util.concurrent.Callable;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.TimeUnit;
+import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.stream.Collectors;
 
+import static io.confluent.csid.utils.KafkaTestUtils.trimAllGeneisOffset;
 import static io.confluent.csid.utils.Range.range;
+import static io.confluent.csid.utils.StringUtils.msg;
+import static io.confluent.parallelconsumer.ParallelConsumerOptions.CommitMode.*;
 import static java.time.Duration.ofMillis;
 import static java.time.Duration.ofSeconds;
 import static java.util.concurrent.TimeUnit.SECONDS;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.awaitility.Awaitility.waitAtMost;
 import static org.mockito.Mockito.*;
+import static pl.tlinkowski.unij.api.UniLists.of;
 
 @Slf4j
 public class ParallelEoSStreamProcessorTestBase {
@@ -36,24 +41,27 @@ public class ParallelEoSStreamProcessorTestBase {
     public static final String OUTPUT_TOPIC = "output";
     public static final String CONSUMER_GROUP_ID = "my-group";
 
+    public static final ConsumerGroupMetadata DEFAULT_GROUP_METADATA = new ConsumerGroupMetadata(CONSUMER_GROUP_ID);
+
     /**
      * The frequency with which we pretend to poll the broker for records - actually the pretend long poll timeout. A
      * lower value shouldn't affect test speed much unless many different batches of messages are "published".
+     *
      * @see LongPollingMockConsumer#poll(Duration)
      */
     public static final int DEFAULT_BROKER_POLL_FREQUENCY_MS = 100;
 
     /**
-     * The commit interval for the main {@link ParallelEoSStreamProcessor} control thread. Actually the timeout that we poll the
-     * {@link LinkedBlockingQueue} for. A lower value will increase the frequency of control loop cycles, making our
-     * test waiting go faster.
+     * The commit interval for the main {@link ParallelEoSStreamProcessor} control thread. Actually the timeout that we
+     * poll the {@link LinkedBlockingQueue} for. A lower value will increase the frequency of control loop cycles,
+     * making our test waiting go faster.
      *
      * @see ParallelEoSStreamProcessor#workMailBox
      * @see ParallelEoSStreamProcessor#processWorkCompleteMailBox
      */
     public static final int DEFAULT_COMMIT_INTERVAL_MAX_MS = 100;
 
-    protected MockConsumer<String, String> consumerSpy;
+    protected LongPollingMockConsumer<String, String> consumerSpy;
     protected MockProducer<String, String> producerSpy;
 
     protected ParallelEoSStreamProcessor<String, String> parallelConsumer;
@@ -62,7 +70,7 @@ public class ParallelEoSStreamProcessorTestBase {
 
     protected static Duration defaultTimeout = ofSeconds(defaultTimeoutSeconds);
     protected static long defaultTimeoutMs = defaultTimeout.toMillis();
-    protected static Duration infiniteTimeout = Duration.ofMinutes(20);
+    protected static Duration effectivelyInfiniteTimeout = Duration.ofMinutes(20);
 
     ParallelEoSStreamProcessorTest.MyAction myRecordProcessingAction;
 
@@ -84,13 +92,13 @@ public class ParallelEoSStreamProcessorTestBase {
 
     @BeforeEach
     public void setupAsyncConsumerTestBase() {
-        setupAsyncConsumerInstance(ParallelConsumerOptions.builder().build());
+        setupParallelConsumerInstance(ParallelConsumerOptions.builder().commitMode(CONSUMER_SYNC).build());
     }
 
     protected List<WorkContainer<String, String>> successfulWork = Collections.synchronizedList(new ArrayList<>());
 
     private void setupWorkManager(WorkManager<String, String> wm) {
-        wm.getSuccessfulWorkListeners().add((work)->{
+        wm.getSuccessfulWorkListeners().add((work) -> {
             log.debug("Test work listener heard some successful work: {}", work);
             successfulWork.add(work);
         });
@@ -102,28 +110,49 @@ protected void primeFirstRecord() {
     }
 
     protected MockConsumer<String, String> setupClients() {
-        MockConsumer<String, String> consumer = new LongPollingMockConsumer<>(OffsetResetStrategy.EARLIEST);
+        instantiateConsumerProducer();
+
+        ktu = new KafkaTestUtils(consumerSpy);
+
+        return consumerSpy;
+    }
+
+    protected void instantiateConsumerProducer() {
+        LongPollingMockConsumer<String, String> consumer = new LongPollingMockConsumer<>(OffsetResetStrategy.EARLIEST);
         MockProducer<String, String> producer = new MockProducer<>(true, null, null); // TODO do async testing
 
         this.producerSpy = spy(producer);
         this.consumerSpy = spy(consumer);
         myRecordProcessingAction = mock(ParallelEoSStreamProcessorTest.MyAction.class);
 
-        ktu = new KafkaTestUtils(consumerSpy);
-
-        KafkaTestUtils.setupConsumer(this.consumerSpy);
+        when(consumerSpy.groupMetadata()).thenReturn(DEFAULT_GROUP_METADATA);
+    }
 
-        return consumerSpy;
+    /**
+     * Need to make sure we only use {@link ParallelEoSStreamProcessor#subscribe} methods, and not do manual assignment,
+     * otherwise rebalance listeneres don't fire (because there are never rebalances).
+     */
+    protected void subscribeParallelConsumerAndMockConsumerTo(String topic) {
+        List<String> of = of(topic);
+        parallelConsumer.subscribe(of);
+        consumerSpy.subscribeWithRebalanceAndAssignment(of, 2);
     }
 
-    protected void setupAsyncConsumerInstance(ParallelConsumerOptions.ProcessingOrder order) {
-        setupAsyncConsumerInstance(ParallelConsumerOptions.builder().ordering(order).build());
+    protected void setupParallelConsumerInstance(ProcessingOrder order) {
+        setupParallelConsumerInstance(ParallelConsumerOptions.builder().ordering(order).build());
     }
 
-    protected void setupAsyncConsumerInstance(ParallelConsumerOptions parallelConsumerOptions) {
+    protected void setupParallelConsumerInstance(ParallelConsumerOptions parallelConsumerOptions) {
         setupClients();
 
-        parallelConsumer = initAsyncConsumer(parallelConsumerOptions);
+        var optionsWithClients = parallelConsumerOptions.toBuilder()
+                .consumer(consumerSpy)
+                .producer(producerSpy)
+                .build();
+
+        parallelConsumer = initAsyncConsumer(optionsWithClients);
+
+        subscribeParallelConsumerAndMockConsumerTo(INPUT_TOPIC);
 
         parallelConsumer.setLongPollTimeout(ofMillis(DEFAULT_BROKER_POLL_FREQUENCY_MS));
         parallelConsumer.setTimeBetweenCommits(ofMillis(DEFAULT_COMMIT_INTERVAL_MAX_MS));
@@ -136,7 +165,7 @@ protected void setupAsyncConsumerInstance(ParallelConsumerOptions parallelConsum
     }
 
     protected ParallelEoSStreamProcessor<String, String> initAsyncConsumer(ParallelConsumerOptions parallelConsumerOptions) {
-        parallelConsumer = new ParallelEoSStreamProcessor<>(consumerSpy, producerSpy, parallelConsumerOptions);
+        parallelConsumer = new ParallelEoSStreamProcessor<>(parallelConsumerOptions);
 
         return parallelConsumer;
     }
@@ -199,11 +228,16 @@ protected void waitUntilTrue(Callable<Boolean> booleanCallable) {
         waitAtMost(defaultTimeout).until(booleanCallable);
     }
 
+    /**
+     * Make sure the latch is attached, if this times out unexpectedly
+     */
     @SneakyThrows
     private void blockingLoopLatchTrigger(int waitForCount) {
         log.debug("Waiting on {} cycles on loop latch...", waitForCount);
         loopLatchV = new CountDownLatch(waitForCount);
-        loopLatchV.await(defaultTimeoutSeconds, TimeUnit.SECONDS);
+        boolean timeout = !loopLatchV.await(defaultTimeoutSeconds, SECONDS);
+        if (timeout)
+            throw new TimeoutException(msg("Timeout {} waiting for latch", defaultTimeoutSeconds));
     }
 
     @SneakyThrows
@@ -222,16 +256,83 @@ protected void waitForCommitExact(int partition, int offset) {
                 any(ConsumerGroupMetadata.class));
     }
 
-    public void assertCommits(List<Integer> integers, String description) {
-        KafkaTestUtils.assertCommits(producerSpy, integers, Optional.of(description));
+    public void assertCommits(List<Integer> offsets, String description) {
+        assertCommits(offsets, Optional.of(description));
+    }
+
+    /**
+     * Flattens the offsets of all partitions into a single sequential list
+     */
+    public void assertCommits(List<Integer> offsets, Optional<String> description) {
+        if (isUsingTransactionalProducer()) {
+            KafkaTestUtils.assertCommits(producerSpy, offsets, description);
+            assertThat(extractAllPartitionsOffsetsSequentially()).isEmpty();
+        } else {
+            List<Integer> collect = extractAllPartitionsOffsetsSequentially();
+            collect = trimAllGeneisOffset(collect);
+            // duplicates are ok
+            // is there a nicer optional way?
+            // {@link Optional#ifPresentOrElse} only @since 9
+            if (description.isPresent()) {
+                assertThat(collect).as(description.get()).hasSameElementsAs(offsets);
+            } else {
+                try {
+                    assertThat(collect).hasSameElementsAs(offsets);
+                } catch (AssertionError e) {
+                    log.error("", e);
+                    throw e;
+                }
+            }
+
+            KafkaTestUtils.assertCommits(producerSpy, UniLists.of(), Optional.of("Empty"));
+        }
+    }
+
+    /**
+     * Flattens the offsets of all partitions into a single sequential list
+     */
+    private List<Integer> extractAllPartitionsOffsetsSequentially() {
+        var result = new ArrayList<Integer>();
+        // copy the list for safe concurrent access
+        List<Map<TopicPartition, OffsetAndMetadata>> history = new ArrayList<>(consumerSpy.getCommitHistoryInt());
+        return history.stream()
+                .flatMap(commits ->
+                        commits.values().stream().map(meta -> (int) meta.offset())
+                ).collect(Collectors.toList());
+    }
+
+    public void assertCommits(List<Integer> offsets) {
+        assertCommits(offsets, Optional.empty());
+    }
+
+    /**
+     * Checks a list of commits of a list of partitions
+     */
+    public void assertCommitLists(List<List<Integer>> offsets) {
+        if (isUsingTransactionalProducer()) {
+            KafkaTestUtils.assertCommitLists(producerSpy, offsets, Optional.empty());
+        } else {
+            List<Map<String, Map<TopicPartition, OffsetAndMetadata>>> commitHistoryWithGropuId = consumerSpy.getCommitHistoryWithGropuId();
+            KafkaTestUtils.assertCommitLists(commitHistoryWithGropuId, offsets, Optional.empty());
+        }
+    }
+
+    protected List<Map<String, Map<TopicPartition, OffsetAndMetadata>>> getCommitHistory() {
+        if (isUsingTransactionalProducer()) {
+            return producerSpy.consumerGroupOffsetsHistory();
+        } else {
+            return consumerSpy.getCommitHistoryWithGropuId();
+        }
     }
 
-    public void assertCommits(List<Integer> integers) {
-        KafkaTestUtils.assertCommits(producerSpy, integers, Optional.empty());
+    protected boolean isUsingTransactionalProducer() {
+        ParallelConsumerOptions.CommitMode commitMode = parallelConsumer.getWm().getOptions().getCommitMode();
+        return commitMode.equals(TRANSACTIONAL_PRODUCER);
     }
 
-    public void assertCommitLists(List<List<Integer>> integers) {
-        KafkaTestUtils.assertCommitLists(producerSpy, integers, Optional.empty());
+    protected boolean isUsingAsyncCommits() {
+        ParallelConsumerOptions.CommitMode commitMode = parallelConsumer.getWm().getOptions().getCommitMode();
+        return commitMode.equals(CONSUMER_ASYNCHRONOUS);
     }
 
     protected void awaitLatch(List<CountDownLatch> latches, int latchIndex) {
diff --git a/parallel-consumer-core/src/test/java/io/confluent/parallelconsumer/WorkManagerTest.java b/parallel-consumer-core/src/test/java/io/confluent/parallelconsumer/WorkManagerTest.java
index 1322608a8..7736f7068 100644
--- a/parallel-consumer-core/src/test/java/io/confluent/parallelconsumer/WorkManagerTest.java
+++ b/parallel-consumer-core/src/test/java/io/confluent/parallelconsumer/WorkManagerTest.java
@@ -318,7 +318,7 @@ public void maxPerTopic() {
     public void maxInFlight() {
         //
         var opts = ParallelConsumerOptions.builder();
-        opts.maxUncommittedMessagesToHandlePerPartition(1);
+        opts.maxNumberMessagesBeyondBaseCommitOffset(1);
         setupWorkManager(opts.build());
 
         //
@@ -333,7 +333,7 @@ public void maxInFlight() {
     public void maxConcurrency() {
         //
         var opts = ParallelConsumerOptions.builder();
-        opts.maxConcurrency(1);
+        opts.maxMessagesToQueue(1);
         setupWorkManager(opts.build());
 
         //
@@ -372,8 +372,8 @@ public void maxConcurrencyVsInFlightAndNoLeaks() {
         var opts = ParallelConsumerOptions.builder();
         opts.ordering(UNORDERED);
 
-        opts.maxUncommittedMessagesToHandlePerPartition(3);
-        opts.maxConcurrency(2);
+        opts.maxNumberMessagesBeyondBaseCommitOffset(3);
+        opts.maxMessagesToQueue(2);
 
         setupWorkManager(opts.build());
 
@@ -609,8 +609,8 @@ public void treeMapOrderingCorrect() {
     public void workQueuesEmptyWhenAllWorkComplete() {
         ParallelConsumerOptions build = ParallelConsumerOptions.builder()
                 .ordering(UNORDERED)
-                .maxConcurrency(10)
-                .maxUncommittedMessagesToHandlePerPartition(10)
+                .maxMessagesToQueue(10)
+                .maxNumberMessagesBeyondBaseCommitOffset(10)
                 .build();
         setupWorkManager(build);
         registerSomeWork();
diff --git a/parallel-consumer-core/src/test/resources/META-INF/services/org.junit.platform.launcher.TestExecutionListener b/parallel-consumer-core/src/test/resources/META-INF/services/org.junit.platform.launcher.TestExecutionListener
new file mode 100644
index 000000000..3b6460b54
--- /dev/null
+++ b/parallel-consumer-core/src/test/resources/META-INF/services/org.junit.platform.launcher.TestExecutionListener
@@ -0,0 +1 @@
+io.confluent.csid.utils.MyRunListener
\ No newline at end of file
diff --git a/parallel-consumer-core/src/test/resources/junit-platform.properties b/parallel-consumer-core/src/test/resources/junit-platform.properties
index 7f40a1ce1..e3c240beb 100644
--- a/parallel-consumer-core/src/test/resources/junit-platform.properties
+++ b/parallel-consumer-core/src/test/resources/junit-platform.properties
@@ -2,4 +2,4 @@
 # Copyright (C) 2020 Confluent, Inc.
 #
 
-junit.jupiter.displayname.generator.default = io.confluent.csid.utils.ReplaceCamelCase
\ No newline at end of file
+#junit.jupiter.displayname.generator.default = io.confluent.csid.utils.ReplaceCamelCase
\ No newline at end of file
diff --git a/parallel-consumer-core/src/test/resources/logback-test.xml b/parallel-consumer-core/src/test/resources/logback-test.xml
index 0c8e39099..3b376a4a6 100644
--- a/parallel-consumer-core/src/test/resources/logback-test.xml
+++ b/parallel-consumer-core/src/test/resources/logback-test.xml
@@ -25,25 +25,32 @@
         <appender-ref ref="STDOUT"/>
     </root>
 
+    <!-- primary -->
+    <logger name="io.confluent.parallelconsumer" level="info"/>
+<!--    <logger name="io.confluent.parallelconsumer" level="debug"/>-->
+<!--    <logger name="io.confluent.parallelconsumer" level="trace"/>-->
+<!--        <logger name="io.confluent.parallelconsumer.ParallelEoSStreamProcessor" level="trace"/>-->
+<!--    <logger name="io.confluent.parallelconsumer.integrationTests.KafkaTest" level="info"/> &lt;!&ndash; docker logs &ndash;&gt;-->
     <logger name="io.confluent.csid" level="info"/>
 <!--    <logger name="io.confluent.csid" level="debug"/>-->
-<!--            <logger name="io.confluent.csid" level="trace" />-->
+
+<!--            <logger name="io.confluent.parallelconsumer" level="trace" />-->
 
     <!-- notable specifics -->
-    <!--    <logger name="io.confluent.csid.asyncconsumer.integrationTests.VolumeTests" level="debug"/>-->
-    <!--    <logger name="io.confluent.csid.asyncconsumer.ParallelConsumerTestBase" level="trace"/>-->
-    <!--    <logger name="io.confluent.csid.asyncconsumer.WorkManager" level="trace" />-->
-    <!--    <logger name="io.confluent.csid.asyncconsumer.ParallelConsumer" level="info" />-->
-    <!--    <logger name="io.confluent.csid.asyncconsumer.OffsetMapCodecManager" level="debug"/>-->
-    <!--    <logger name="io.confluent.csid.asyncconsumer.WorkManagerOffsetMapCodecManagerTest" level="debug"/>-->
+    <!--    <logger name="io.confluent.parallelconsumer.integrationTests.VolumeTests" level="debug"/>-->
+    <!--    <logger name="io.confluent.parallelconsumer.ParallelConsumerTestBase" level="trace"/>-->
+    <!--    <logger name="io.confluent.parallelconsumer.WorkManager" level="trace" />-->
+    <!--    <logger name="io.confluent.parallelconsumer.ParallelConsumer" level="info" />-->
+    <!--    <logger name="io.confluent.parallelconsumer.OffsetMapCodecManager" level="debug"/>-->
+    <!--    <logger name="io.confluent.parallelconsumer.WorkManagerOffsetMapCodecManagerTest" level="debug"/>-->
 
     <!-- containers -->
-    <!--    <logger name="io.confluent.csid.asyncconsumer.integrationTests.DbTest" level="debug"/>-->
-    <!--    <logger name="io.confluent.csid.asyncconsumer.integrationTests.KafkaTest" level="debug"/>-->
+    <!--    <logger name="io.confluent.parallelconsumer.integrationTests.DbTest" level="debug"/>-->
+    <!--    <logger name="io.confluent.parallelconsumer.integrationTests.KafkaTest" level="debug"/>-->
 
     <!-- related -->
-    <logger name="org.apache.kafka.clients" level="warn"/>
 <!--    <logger name="org.apache.kafka.clients" level="info"/>-->
+<!--    <logger name="org.apache.kafka.clients" level="warn"/>-->
 <!--    <logger name="org.apache.kafka.clients" level="debug"/>-->
 
     <logger name="org.postgresql" level="info"/>
diff --git a/parallel-consumer-examples/parallel-consumer-example-core/src/main/java/io/confluent/parallelconsumer/examples/core/CoreApp.java b/parallel-consumer-examples/parallel-consumer-example-core/src/main/java/io/confluent/parallelconsumer/examples/core/CoreApp.java
index ee01ee717..a109eabef 100644
--- a/parallel-consumer-examples/parallel-consumer-example-core/src/main/java/io/confluent/parallelconsumer/examples/core/CoreApp.java
+++ b/parallel-consumer-examples/parallel-consumer-example-core/src/main/java/io/confluent/parallelconsumer/examples/core/CoreApp.java
@@ -18,9 +18,14 @@
 import org.apache.kafka.clients.producer.ProducerRecord;
 import pl.tlinkowski.unij.api.UniLists;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
 import java.util.Properties;
+import java.util.concurrent.atomic.AtomicInteger;
 
 import static io.confluent.parallelconsumer.ParallelConsumerOptions.ProcessingOrder.KEY;
+import static pl.tlinkowski.unij.api.UniLists.of;
 
 /**
  * Basic core examples
@@ -28,8 +33,9 @@
 @Slf4j
 public class CoreApp {
 
-    static String inputTopic = "input-topic-" + RandomUtils.nextInt();
-    static String outputTopic = "output-topic-" + RandomUtils.nextInt();
+
+    String inputTopic = "input-topic-" + RandomUtils.nextInt();
+    String outputTopic = "output-topic-" + RandomUtils.nextInt();
 
     Consumer<String, String> getKafkaConsumer() {
         return new KafkaConsumer<>(new Properties());
@@ -43,7 +49,9 @@ Producer<String, String> getKafkaProducer() {
 
     @SuppressWarnings("UnqualifiedFieldAccess")
     void run() {
-        this.parallelConsumer = setupConsumer();
+        this.parallelConsumer = setupParallelConsumer();
+
+        postSetup();
 
         // tag::example[]
         parallelConsumer.poll(record ->
@@ -52,21 +60,30 @@ void run() {
         // end::example[]
     }
 
+    protected void postSetup() {
+        // ignore
+    }
+
     @SuppressWarnings({"FeatureEnvy", "MagicNumber"})
-    ParallelStreamProcessor<String, String> setupConsumer() {
+    ParallelStreamProcessor<String, String> setupParallelConsumer() {
         // tag::exampleSetup[]
-        var options = ParallelConsumerOptions.builder()
-                .ordering(KEY) // <1>
-                .maxConcurrency(1000) // <2>
-                .maxUncommittedMessagesToHandlePerPartition(10000) // <3>
+        Consumer<String, String> kafkaConsumer = getKafkaConsumer(); // <1>
+        Producer<String, String> kafkaProducer = getKafkaProducer();
+
+        var options = ParallelConsumerOptions.<String, String>builder()
+                .ordering(KEY) // <2>
+                .maxMessagesToQueue(1000) // <3>
+                .maxNumberMessagesBeyondBaseCommitOffset(1000) // <4>
+                .consumer(kafkaConsumer)
+                .producer(kafkaProducer)
                 .build();
 
-        Consumer<String, String> kafkaConsumer = getKafkaConsumer(); // <4>
-        if (!(kafkaConsumer instanceof MockConsumer)) {
-            kafkaConsumer.subscribe(UniLists.of(inputTopic)); // <5>
-        }
+        ParallelStreamProcessor<String, String> eosStreamProcessor =
+                ParallelStreamProcessor.createEosStreamProcessor(options);
+
+        eosStreamProcessor.subscribe(of(inputTopic)); // <5>
 
-        return ParallelStreamProcessor.createEosStreamProcessor(kafkaConsumer, getKafkaProducer(), options);
+        return eosStreamProcessor;
         // end::exampleSetup[]
     }
 
@@ -75,18 +92,19 @@ void close() {
     }
 
     void runPollAndProduce() {
-        this.parallelConsumer = setupConsumer();
+        this.parallelConsumer = setupParallelConsumer();
+
+        postSetup();
 
         // tag::exampleProduce[]
-        this.parallelConsumer.pollAndProduce(record -> {
+        parallelConsumer.pollAndProduce(record -> {
                     var result = processBrokerRecord(record);
-                    ProducerRecord<String, String> produceRecord =
-                            new ProducerRecord<>(outputTopic, "a-key", result.payload);
-                    return UniLists.of(produceRecord);
-                }, consumeProduceResult ->
-                        log.info("Message {} saved to broker at offset {}",
-                                consumeProduceResult.getOut(),
-                                consumeProduceResult.getMeta().offset())
+                    return new ProducerRecord<>(outputTopic, record.key(), result.payload);
+                }, consumeProduceResult -> {
+                    log.debug("Message {} saved to broker at offset {}",
+                            consumeProduceResult.getOut(),
+                            consumeProduceResult.getMeta().offset());
+                }
         );
         // end::exampleProduce[]
     }
diff --git a/parallel-consumer-examples/parallel-consumer-example-core/src/test/java/io/confluent/parallelconsumer/examples/core/CoreAppTest.java b/parallel-consumer-examples/parallel-consumer-example-core/src/test/java/io/confluent/parallelconsumer/examples/core/CoreAppTest.java
index fb3b0a65c..f44ba7159 100644
--- a/parallel-consumer-examples/parallel-consumer-example-core/src/test/java/io/confluent/parallelconsumer/examples/core/CoreAppTest.java
+++ b/parallel-consumer-examples/parallel-consumer-example-core/src/test/java/io/confluent/parallelconsumer/examples/core/CoreAppTest.java
@@ -4,6 +4,7 @@
  * Copyright (C) 2020 Confluent, Inc.
  */
 
+import io.confluent.csid.utils.KafkaTestUtils;
 import io.confluent.csid.utils.LongPollingMockConsumer;
 import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
@@ -13,7 +14,6 @@
 import org.apache.kafka.clients.producer.MockProducer;
 import org.apache.kafka.clients.producer.Producer;
 import org.apache.kafka.common.TopicPartition;
-import org.assertj.core.api.Assertions;
 import org.awaitility.Awaitility;
 import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
@@ -22,34 +22,33 @@
 import java.time.Duration;
 import java.util.HashMap;
 
-import static io.confluent.csid.utils.KafkaTestUtils.DEFAULT_GROUP_METADATA;
+import static io.confluent.parallelconsumer.ParallelEoSStreamProcessorTestBase.DEFAULT_GROUP_METADATA;
 import static org.mockito.Mockito.when;
+import static pl.tlinkowski.unij.api.UniLists.of;
 
 @Slf4j
 public class CoreAppTest {
 
-    TopicPartition tp = new TopicPartition(CoreApp.inputTopic, 0);
-
     @SneakyThrows
     @Test
     public void test() {
         log.info("Test start");
         CoreAppUnderTest coreApp = new CoreAppUnderTest();
+        TopicPartition tp = new TopicPartition(coreApp.inputTopic, 0);
 
         coreApp.run();
 
-        coreApp.mockConsumer.addRecord(new ConsumerRecord(CoreApp.inputTopic, 0, 0, "a key 1", "a value"));
-        coreApp.mockConsumer.addRecord(new ConsumerRecord(CoreApp.inputTopic, 0, 1, "a key 2", "a value"));
-        coreApp.mockConsumer.addRecord(new ConsumerRecord(CoreApp.inputTopic, 0, 2, "a key 3", "a value"));
+        coreApp.mockConsumer.addRecord(new ConsumerRecord(coreApp.inputTopic, 0, 0, "a key 1", "a value"));
+        coreApp.mockConsumer.addRecord(new ConsumerRecord(coreApp.inputTopic, 0, 1, "a key 2", "a value"));
+        coreApp.mockConsumer.addRecord(new ConsumerRecord(coreApp.inputTopic, 0, 2, "a key 3", "a value"));
 
-        Awaitility.await().pollInterval(Duration.ofSeconds(1)).untilAsserted(()->{
-            Assertions.assertThat(coreApp.mockConsumer.position(tp)).isEqualTo(3);
+        Awaitility.await().pollInterval(Duration.ofSeconds(1)).untilAsserted(() -> {
+            KafkaTestUtils.assertLastCommitIs(coreApp.mockConsumer, 3);
         });
 
         coreApp.close();
     }
 
-
     @SneakyThrows
     @Test
     public void testPollAndProduce() {
@@ -58,12 +57,12 @@ public void testPollAndProduce() {
 
         coreApp.runPollAndProduce();
 
-        coreApp.mockConsumer.addRecord(new ConsumerRecord(CoreApp.inputTopic, 0, 0, "a key 1", "a value"));
-        coreApp.mockConsumer.addRecord(new ConsumerRecord(CoreApp.inputTopic, 0, 1, "a key 2", "a value"));
-        coreApp.mockConsumer.addRecord(new ConsumerRecord(CoreApp.inputTopic, 0, 2, "a key 3", "a value"));
+        coreApp.mockConsumer.addRecord(new ConsumerRecord(coreApp.inputTopic, 0, 0, "a key 1", "a value"));
+        coreApp.mockConsumer.addRecord(new ConsumerRecord(coreApp.inputTopic, 0, 1, "a key 2", "a value"));
+        coreApp.mockConsumer.addRecord(new ConsumerRecord(coreApp.inputTopic, 0, 2, "a key 3", "a value"));
 
-        Awaitility.await().pollInterval(Duration.ofSeconds(1)).untilAsserted(()->{
-            Assertions.assertThat(coreApp.mockConsumer.position(tp)).isEqualTo(3);
+        Awaitility.await().pollInterval(Duration.ofSeconds(1)).untilAsserted(() -> {
+            KafkaTestUtils.assertLastCommitIs(coreApp.mockConsumer, 3);
         });
 
         coreApp.close();
@@ -72,21 +71,22 @@ public void testPollAndProduce() {
     class CoreAppUnderTest extends CoreApp {
 
         LongPollingMockConsumer<String, String> mockConsumer = Mockito.spy(new LongPollingMockConsumer<>(OffsetResetStrategy.EARLIEST));
+        TopicPartition tp = new TopicPartition(inputTopic, 0);
 
         @Override
         Consumer<String, String> getKafkaConsumer() {
-            HashMap<TopicPartition, Long> beginningOffsets = new HashMap<>();
-            beginningOffsets.put(tp, 0L);
-            mockConsumer.updateBeginningOffsets(beginningOffsets);
             when(mockConsumer.groupMetadata()).thenReturn(DEFAULT_GROUP_METADATA); // todo fix AK mock consumer
-            mockConsumer.assign(UniLists.of(tp));
             return mockConsumer;
         }
 
         @Override
         Producer<String, String> getKafkaProducer() {
-            return new MockProducer<>();
+            return new MockProducer<>(true, null, null);
         }
 
+        @Override
+        protected void postSetup() {
+            mockConsumer.subscribeWithRebalanceAndAssignment(of(inputTopic), 1);
+        }
     }
 }
diff --git a/parallel-consumer-examples/parallel-consumer-example-core/src/test/resources/logback-test.xml b/parallel-consumer-examples/parallel-consumer-example-core/src/test/resources/logback-temp-test.xml
similarity index 94%
rename from parallel-consumer-examples/parallel-consumer-example-core/src/test/resources/logback-test.xml
rename to parallel-consumer-examples/parallel-consumer-example-core/src/test/resources/logback-temp-test.xml
index 1d977eeab..aab528624 100644
--- a/parallel-consumer-examples/parallel-consumer-example-core/src/test/resources/logback-test.xml
+++ b/parallel-consumer-examples/parallel-consumer-example-core/src/test/resources/logback-temp-test.xml
@@ -16,7 +16,7 @@
     </root>
 
     <logger name="io.confluent.csid" level="info" />
-<!--    <logger name="io.confluent.csid" level="debug" />-->
+    <logger name="io.confluent.parallelconsumer" level="debug" />
 <!--    <logger name="io.confluent.csid" level="trace" />-->
 
     <!--    <logger name="io.confluent.csid.asyncconsumer.WorkManager" level="info" />-->
diff --git a/parallel-consumer-examples/parallel-consumer-example-streams/src/main/java/io/confluent/parallelconsumer/examples/streams/StreamsApp.java b/parallel-consumer-examples/parallel-consumer-example-streams/src/main/java/io/confluent/parallelconsumer/examples/streams/StreamsApp.java
index d85148239..7bf6e00b5 100644
--- a/parallel-consumer-examples/parallel-consumer-example-streams/src/main/java/io/confluent/parallelconsumer/examples/streams/StreamsApp.java
+++ b/parallel-consumer-examples/parallel-consumer-example-streams/src/main/java/io/confluent/parallelconsumer/examples/streams/StreamsApp.java
@@ -5,7 +5,6 @@
  */
 
 
-import io.confluent.parallelconsumer.ParallelEoSStreamProcessor;
 import io.confluent.parallelconsumer.ParallelConsumerOptions;
 import io.confluent.parallelconsumer.ParallelStreamProcessor;
 import lombok.extern.slf4j.Slf4j;
@@ -69,7 +68,7 @@ void startStreams(Topology topology) {
     }
 
     void concurrentProcess() {
-        setupConsumer();
+        setupParallelConsumer();
 
         parallelConsumer.poll(record -> {
             log.info("Concurrently processing a record: {}", record);
@@ -78,16 +77,19 @@ void concurrentProcess() {
     }
     // end::example[]
 
-    private void setupConsumer() {
-        var options = ParallelConsumerOptions.builder()
+    private void setupParallelConsumer() {
+        Consumer<String, String> kafkaConsumer = getKafkaConsumer();
+        Producer<String, String> kafkaProducer = getKafkaProducer();
+        var options = ParallelConsumerOptions.<String, String>builder()
                 .ordering(ParallelConsumerOptions.ProcessingOrder.KEY)
-                .maxConcurrency(1000)
-                .maxUncommittedMessagesToHandlePerPartition(10000)
+                .maxMessagesToQueue(1000)
+                .maxNumberMessagesBeyondBaseCommitOffset(10000)
+                .consumer(kafkaConsumer)
+                .producer(kafkaProducer)
                 .build();
 
-        Consumer<String, String> kafkaConsumer = getKafkaConsumer();
 
-        parallelConsumer = ParallelStreamProcessor.createEosStreamProcessor(kafkaConsumer, getKafkaProducer(), options);
+        parallelConsumer = ParallelStreamProcessor.createEosStreamProcessor(options);
         parallelConsumer.subscribe(UniLists.of(outputTopicName));
     }
 
diff --git a/parallel-consumer-examples/parallel-consumer-example-streams/src/test/java/io/confluent/parallelconsumer/examples/streams/StreamsAppTest.java b/parallel-consumer-examples/parallel-consumer-example-streams/src/test/java/io/confluent/parallelconsumer/examples/streams/StreamsAppTest.java
index d8cc84425..a0e5a5acb 100644
--- a/parallel-consumer-examples/parallel-consumer-example-streams/src/test/java/io/confluent/parallelconsumer/examples/streams/StreamsAppTest.java
+++ b/parallel-consumer-examples/parallel-consumer-example-streams/src/test/java/io/confluent/parallelconsumer/examples/streams/StreamsAppTest.java
@@ -52,7 +52,7 @@ Consumer<String, String> getKafkaConsumer() {
 
         @Override
         Producer<String, String> getKafkaProducer() {
-            return kcu.createNewProducer(true);
+            return kcu.createNewProducer(false);
         }
 
         @Override
diff --git a/parallel-consumer-examples/parallel-consumer-example-vertx/pom.xml b/parallel-consumer-examples/parallel-consumer-example-vertx/pom.xml
index 054f25d4a..23bd541c3 100644
--- a/parallel-consumer-examples/parallel-consumer-example-vertx/pom.xml
+++ b/parallel-consumer-examples/parallel-consumer-example-vertx/pom.xml
@@ -31,6 +31,13 @@
             <classifier>tests</classifier>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>io.confluent.parallelconsumer</groupId>
+            <artifactId>parallel-consumer-vertx</artifactId>
+            <version>${project.version}</version>
+            <classifier>tests</classifier>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-lang3</artifactId>
@@ -40,6 +47,12 @@
             <artifactId>awaitility</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>com.github.tomakehurst</groupId>
+            <artifactId>wiremock</artifactId>
+            <version>2.27.2</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
 </project>
\ No newline at end of file
diff --git a/parallel-consumer-examples/parallel-consumer-example-vertx/src/main/java/io/confluent/parallelconsumer/examples/vertx/VertxApp.java b/parallel-consumer-examples/parallel-consumer-example-vertx/src/main/java/io/confluent/parallelconsumer/examples/vertx/VertxApp.java
index 0b4c1d023..e0e0e58d3 100644
--- a/parallel-consumer-examples/parallel-consumer-example-vertx/src/main/java/io/confluent/parallelconsumer/examples/vertx/VertxApp.java
+++ b/parallel-consumer-examples/parallel-consumer-example-vertx/src/main/java/io/confluent/parallelconsumer/examples/vertx/VertxApp.java
@@ -37,32 +37,40 @@ Producer<String, String> getKafkaProducer() {
 
 
     void run() {
-        var options = ParallelConsumerOptions.builder()
+        Consumer<String, String> kafkaConsumer = getKafkaConsumer();
+        Producer<String, String> kafkaProducer = getKafkaProducer();
+        var options = ParallelConsumerOptions.<String, String>builder()
                 .ordering(ParallelConsumerOptions.ProcessingOrder.KEY)
-                .maxConcurrency(1000)
-                .maxUncommittedMessagesToHandlePerPartition(10000)
+                .maxMessagesToQueue(1000)
+                .maxNumberMessagesBeyondBaseCommitOffset(10000)
+                .consumer(kafkaConsumer)
+                .producer(kafkaProducer)
                 .build();
 
-        Consumer<String, String> kafkaConsumer = getKafkaConsumer();
         setupSubscription(kafkaConsumer);
 
-        this.parallelConsumer = JStreamVertxParallelStreamProcessor.createEosStreamProcessor(kafkaConsumer,
-                getKafkaProducer(), options);
+        this.parallelConsumer = JStreamVertxParallelStreamProcessor.createEosStreamProcessor(options);
+
+        int port = getPort();
 
         // tag::example[]
         var resultStream = parallelConsumer.vertxHttpReqInfoStream(record -> {
             log.info("Concurrently constructing and returning RequestInfo from record: {}", record);
             Map<String, String> params = UniMaps.of("recordKey", record.key(), "payload", record.value());
-            return new RequestInfo("localhost", "/api", params); // <1>
+            return new RequestInfo("localhost", port, "/api", params); // <1>
         });
         // end::example[]
 
-        resultStream.forEach(x->{
+        resultStream.forEach(x -> {
             log.info("From result stream: {}", x);
         });
 
     }
 
+    protected int getPort() {
+        return 8080;
+    }
+
     void setupSubscription(Consumer<String, String> kafkaConsumer) {
         kafkaConsumer.subscribe(UniLists.of(inputTopic));
     }
diff --git a/parallel-consumer-examples/parallel-consumer-example-vertx/src/test/java/io/confluent/parallelconsumer/examples/vertx/VertxAppTest.java b/parallel-consumer-examples/parallel-consumer-example-vertx/src/test/java/io/confluent/parallelconsumer/examples/vertx/VertxAppTest.java
index 7652ad1d3..88cc778ee 100644
--- a/parallel-consumer-examples/parallel-consumer-example-vertx/src/test/java/io/confluent/parallelconsumer/examples/vertx/VertxAppTest.java
+++ b/parallel-consumer-examples/parallel-consumer-example-vertx/src/test/java/io/confluent/parallelconsumer/examples/vertx/VertxAppTest.java
@@ -4,7 +4,10 @@
  * Copyright (C) 2020 Confluent, Inc.
  */
 
+import io.confluent.csid.utils.KafkaTestUtils;
 import io.confluent.csid.utils.LongPollingMockConsumer;
+import io.confluent.parallelconsumer.vertx.VertxTest;
+import lombok.RequiredArgsConstructor;
 import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.kafka.clients.consumer.Consumer;
@@ -13,7 +16,6 @@
 import org.apache.kafka.clients.producer.MockProducer;
 import org.apache.kafka.clients.producer.Producer;
 import org.apache.kafka.common.TopicPartition;
-import org.assertj.core.api.Assertions;
 import org.awaitility.Awaitility;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.Timeout;
@@ -22,9 +24,8 @@
 
 import java.time.Duration;
 import java.util.HashMap;
-import java.util.concurrent.TimeoutException;
 
-import static io.confluent.csid.utils.KafkaTestUtils.DEFAULT_GROUP_METADATA;
+import static io.confluent.parallelconsumer.ParallelEoSStreamProcessorTestBase.DEFAULT_GROUP_METADATA;
 
 @Slf4j
 public class VertxAppTest {
@@ -36,7 +37,10 @@ public class VertxAppTest {
     @Test
     public void test() {
         log.info("Test start");
-        VertxAppAppUnderTest coreApp = new VertxAppAppUnderTest();
+        VertxTest.setupWireMock();
+        int port = VertxTest.stubServer.port();
+
+        VertxAppAppUnderTest coreApp = new VertxAppAppUnderTest(port);
 
         coreApp.run();
 
@@ -45,17 +49,17 @@ public void test() {
         coreApp.mockConsumer.addRecord(new ConsumerRecord(VertxApp.inputTopic, 0, 2, "a key 3", "a value"));
 
         Awaitility.await().pollInterval(Duration.ofSeconds(1)).untilAsserted(()->{
-            Assertions.assertThat(coreApp.mockConsumer.position(tp)).isEqualTo(3);
+            KafkaTestUtils.assertLastCommitIs(coreApp.mockConsumer, 3);
         });
 
-        Assertions.assertThatExceptionOfType(TimeoutException.class)
-                .as("no server to receive request, should timeout trying to close. Could also setup wire mock...")
-                .isThrownBy(coreApp::close)
-                .withMessageContainingAll("Waiting", "records", "flight");
+        coreApp.close();
     }
 
+    @RequiredArgsConstructor
     class VertxAppAppUnderTest extends VertxApp {
 
+        private final int port;
+
         LongPollingMockConsumer<String, String> mockConsumer = Mockito.spy(new LongPollingMockConsumer<>(OffsetResetStrategy.EARLIEST));
 
         @Override
@@ -69,12 +73,17 @@ Consumer<String, String> getKafkaConsumer() {
 
         @Override
         Producer<String, String> getKafkaProducer() {
-            return new MockProducer<>();
+            return new MockProducer<>(true, null, null);
         }
 
         @Override
         void setupSubscription(Consumer<String, String> kafkaConsumer) {
             mockConsumer.assign(UniLists.of(tp));
         }
+
+        @Override
+        protected int getPort() {
+            return port;
+        }
     }
 }
diff --git a/parallel-consumer-vertx/src/main/java/io/confluent/parallelconsumer/vertx/JStreamVertxParallelEoSStreamProcessor.java b/parallel-consumer-vertx/src/main/java/io/confluent/parallelconsumer/vertx/JStreamVertxParallelEoSStreamProcessor.java
index ae2eae61b..1ddf16616 100644
--- a/parallel-consumer-vertx/src/main/java/io/confluent/parallelconsumer/vertx/JStreamVertxParallelEoSStreamProcessor.java
+++ b/parallel-consumer-vertx/src/main/java/io/confluent/parallelconsumer/vertx/JStreamVertxParallelEoSStreamProcessor.java
@@ -25,6 +25,8 @@
 import java.util.function.Function;
 import java.util.stream.Stream;
 
+import static io.confluent.parallelconsumer.UserFunctions.carefullyRun;
+
 @Slf4j
 public class JStreamVertxParallelEoSStreamProcessor<K, V> extends VertxParallelEoSStreamProcessor<K, V>
         implements JStreamVertxParallelStreamProcessor<K, V> {
@@ -44,12 +46,10 @@ public class JStreamVertxParallelEoSStreamProcessor<K, V> extends VertxParallelE
      * <p>
      * Use this to share a Vertx runtime with different systems for efficiency.
      */
-    public JStreamVertxParallelEoSStreamProcessor(org.apache.kafka.clients.consumer.Consumer<K, V> consumer,
-                                                  Producer<K, V> producer,
-                                                  Vertx vertx,
+    public JStreamVertxParallelEoSStreamProcessor(Vertx vertx,
                                                   WebClient webClient,
-                                                  ParallelConsumerOptions options) {
-        super(consumer, producer, vertx, webClient, options);
+                                                  ParallelConsumerOptions<K, V> options) {
+        super(vertx, webClient, options);
 
         this.userProcessResultsStream = new ConcurrentLinkedDeque<>();
 
@@ -59,10 +59,8 @@ public JStreamVertxParallelEoSStreamProcessor(org.apache.kafka.clients.consumer.
     /**
      * Simple constructor. Internal Vertx objects will be created.
      */
-    public JStreamVertxParallelEoSStreamProcessor(org.apache.kafka.clients.consumer.Consumer<K, V> consumer,
-                                                  Producer<K, V> producer,
-                                                  ParallelConsumerOptions options) {
-        this(consumer, producer, null, null, options);
+    public JStreamVertxParallelEoSStreamProcessor(ParallelConsumerOptions<K, V> options) {
+        this(null, null, options);
     }
 
     @Override
@@ -72,7 +70,7 @@ public Stream<VertxCPResult<K, V>> vertxHttpReqInfoStream(Function<ConsumerRecor
 
         Function<ConsumerRecord<K, V>, RequestInfo> requestInfoFunctionWrapped = x -> {
             result.in(x);
-            RequestInfo apply = requestInfoFunction.apply(x);
+            RequestInfo apply = carefullyRun(requestInfoFunction, x);
             result.requestInfo(Optional.of(apply));
             return apply;
         };
@@ -97,7 +95,8 @@ public Stream<VertxCPResult<K, V>> vertxHttpRequestStream(BiFunction<WebClient,
 
         BiFunction<WebClient, ConsumerRecord<K, V>, HttpRequest<Buffer>> requestInfoFunctionWrapped = (wc, x) -> {
             result.in(x);
-            HttpRequest<Buffer> apply = webClientRequestFunction.apply(wc, x);
+            HttpRequest<Buffer> apply = carefullyRun(webClientRequestFunction, wc, x);
+
             result.httpReq(Optional.of(apply));
             return apply;
         };
@@ -123,7 +122,8 @@ public Stream<VertxCPResult<K, V>> vertxHttpWebClientStream(
         BiFunction<WebClient, ConsumerRecord<K, V>, Future<HttpResponse<Buffer>>> wrappedFunc = (x, y) -> {
             // capture
             result.in(y);
-            Future<HttpResponse<Buffer>> apply = webClientRequestFunction.apply(x, y);
+            Future<HttpResponse<Buffer>> apply = carefullyRun(webClientRequestFunction, x, y);
+
             result.asr(apply);
             return apply;
         };
diff --git a/parallel-consumer-vertx/src/main/java/io/confluent/parallelconsumer/vertx/JStreamVertxParallelStreamProcessor.java b/parallel-consumer-vertx/src/main/java/io/confluent/parallelconsumer/vertx/JStreamVertxParallelStreamProcessor.java
index bbc677b19..9c9b722b5 100644
--- a/parallel-consumer-vertx/src/main/java/io/confluent/parallelconsumer/vertx/JStreamVertxParallelStreamProcessor.java
+++ b/parallel-consumer-vertx/src/main/java/io/confluent/parallelconsumer/vertx/JStreamVertxParallelStreamProcessor.java
@@ -24,11 +24,8 @@
  */
 public interface JStreamVertxParallelStreamProcessor<K, V> extends DrainingCloseable {
 
-    static <KK, VV> JStreamVertxParallelStreamProcessor<KK, VV> createEosStreamProcessor(
-            org.apache.kafka.clients.consumer.Consumer<KK, VV> consumer,
-            org.apache.kafka.clients.producer.Producer<KK, VV> producer,
-            ParallelConsumerOptions options) {
-        return new JStreamVertxParallelEoSStreamProcessor<>(consumer, producer, options);
+    static <KK, VV> JStreamVertxParallelStreamProcessor<KK, VV> createEosStreamProcessor(ParallelConsumerOptions<KK, VV> options) {
+        return new JStreamVertxParallelEoSStreamProcessor<>(options);
     }
 
     /**
diff --git a/parallel-consumer-vertx/src/main/java/io/confluent/parallelconsumer/vertx/VertxParallelEoSStreamProcessor.java b/parallel-consumer-vertx/src/main/java/io/confluent/parallelconsumer/vertx/VertxParallelEoSStreamProcessor.java
index 68eefbb06..bf9df7dcb 100644
--- a/parallel-consumer-vertx/src/main/java/io/confluent/parallelconsumer/vertx/VertxParallelEoSStreamProcessor.java
+++ b/parallel-consumer-vertx/src/main/java/io/confluent/parallelconsumer/vertx/VertxParallelEoSStreamProcessor.java
@@ -4,9 +4,7 @@
  * Copyright (C) 2020 Confluent, Inc.
  */
 
-import io.confluent.parallelconsumer.ParallelEoSStreamProcessor;
-import io.confluent.parallelconsumer.ParallelConsumerOptions;
-import io.confluent.parallelconsumer.WorkContainer;
+import io.confluent.parallelconsumer.*;
 import io.vertx.core.AsyncResult;
 import io.vertx.core.Future;
 import io.vertx.core.Vertx;
@@ -34,6 +32,8 @@
 import java.util.function.Consumer;
 import java.util.function.Function;
 
+import static io.confluent.parallelconsumer.UserFunctions.carefullyRun;
+
 @Slf4j
 public class VertxParallelEoSStreamProcessor<K, V> extends ParallelEoSStreamProcessor<K, V>
         implements VertxParallelStreamProcessor<K, V> {
@@ -64,7 +64,7 @@ public class VertxParallelEoSStreamProcessor<K, V> extends ParallelEoSStreamProc
     public VertxParallelEoSStreamProcessor(org.apache.kafka.clients.consumer.Consumer<K, V> consumer,
                                            Producer<K, V> producer,
                                            ParallelConsumerOptions options) {
-        this(consumer, producer, Vertx.vertx(), null, options);
+        this(Vertx.vertx(), null, options);
     }
 
     /**
@@ -72,11 +72,10 @@ public VertxParallelEoSStreamProcessor(org.apache.kafka.clients.consumer.Consume
      * <p>
      * Use this to share a Vertx runtime with different systems for efficiency.
      */
-    public VertxParallelEoSStreamProcessor(org.apache.kafka.clients.consumer.Consumer<K, V> consumer, Producer<K, V> producer,
-                                           Vertx vertx,
+    public VertxParallelEoSStreamProcessor(Vertx vertx,
                                            WebClient webClient,
                                            ParallelConsumerOptions options) {
-        super(consumer, producer, options);
+        super(options);
         if (vertx == null)
             vertx = Vertx.vertx();
         this.vertx = vertx;
@@ -90,7 +89,8 @@ public void vertxHttpReqInfo(Function<ConsumerRecord<K, V>, RequestInfo> request
                                  Consumer<Future<HttpResponse<Buffer>>> onSend,
                                  Consumer<AsyncResult<HttpResponse<Buffer>>> onWebRequestComplete) {
         vertxHttpRequest((WebClient wc, ConsumerRecord<K, V> rec) -> {
-            RequestInfo reqInf = requestInfoFunction.apply(rec);
+            RequestInfo reqInf = carefullyRun(requestInfoFunction, rec);
+
             HttpRequest<Buffer> req = wc.get(reqInf.getPort(), reqInf.getHost(), reqInf.getContextPath());
             Map<String, String> params = reqInf.getParams();
             for (var entry : params.entrySet()) {
@@ -106,7 +106,7 @@ public void vertxHttpRequest(BiFunction<WebClient, ConsumerRecord<K, V>, HttpReq
                                  Consumer<AsyncResult<HttpResponse<Buffer>>> onWebRequestComplete) { // TODO remove, redundant over onSend?
 
         vertxHttpWebClient((webClient, record) -> {
-            HttpRequest<Buffer> call = webClientRequestFunction.apply(webClient, record);
+            HttpRequest<Buffer> call = carefullyRun(webClientRequestFunction, webClient, record);
 
             Future<HttpResponse<Buffer>> send = call.send(); // dispatches the work to vertx
 
@@ -124,7 +124,8 @@ public void vertxHttpWebClient(BiFunction<WebClient, ConsumerRecord<K, V>, Futur
                                    Consumer<Future<HttpResponse<Buffer>>> onSend) {
 
         Function<ConsumerRecord<K, V>, List<Future<HttpResponse<Buffer>>>> userFuncWrapper = (record) -> {
-            Future<HttpResponse<Buffer>> send = webClientRequestFunction.apply(webClient, record);
+
+            Future<HttpResponse<Buffer>> send = carefullyRun(webClientRequestFunction, webClient, record);
 
             // send callback
             onSend.accept(send);
@@ -232,7 +233,7 @@ private boolean isVertxWork(List<?> resultsFromUserFunction) {
     @Override
     public void close(Duration timeout, DrainingMode drainMode) {
         log.info("Vert.x async consumer closing...");
-        waitForNoInFlight(timeout);
+        waitForProcessedNotCommitted(timeout);
         super.close(timeout, drainMode);
         webClient.close();
         Future<Void> close = vertx.close();
diff --git a/parallel-consumer-vertx/src/test/java/io/confluent/parallelconsumer/vertx/VertxNonVertxOperations.java b/parallel-consumer-vertx/src/test/java/io/confluent/parallelconsumer/vertx/VertxNonVertxOperations.java
index df4d6516f..cf72d299f 100644
--- a/parallel-consumer-vertx/src/test/java/io/confluent/parallelconsumer/vertx/VertxNonVertxOperations.java
+++ b/parallel-consumer-vertx/src/test/java/io/confluent/parallelconsumer/vertx/VertxNonVertxOperations.java
@@ -20,7 +20,7 @@ public class VertxNonVertxOperations extends ParallelEoSStreamProcessorTest {
     protected ParallelEoSStreamProcessor initAsyncConsumer(ParallelConsumerOptions parallelConsumerOptions) {
         VertxOptions vertxOptions = new VertxOptions();
         Vertx vertx = Vertx.vertx(vertxOptions);
-        parallelConsumer = new VertxParallelEoSStreamProcessor<>(consumerSpy, producerSpy, vertx, WebClient.create(vertx), parallelConsumerOptions);
+        parallelConsumer = new VertxParallelEoSStreamProcessor<>(vertx, WebClient.create(vertx), parallelConsumerOptions);
 
         return parallelConsumer;
     }
diff --git a/parallel-consumer-vertx/src/test/java/io/confluent/parallelconsumer/vertx/VertxTest.java b/parallel-consumer-vertx/src/test/java/io/confluent/parallelconsumer/vertx/VertxTest.java
index 22b634f02..6f150099c 100644
--- a/parallel-consumer-vertx/src/test/java/io/confluent/parallelconsumer/vertx/VertxTest.java
+++ b/parallel-consumer-vertx/src/test/java/io/confluent/parallelconsumer/vertx/VertxTest.java
@@ -41,6 +41,7 @@
 
 import static com.github.tomakehurst.wiremock.client.WireMock.*;
 import static com.github.tomakehurst.wiremock.core.WireMockConfiguration.wireMockConfig;
+import static io.confluent.parallelconsumer.ParallelConsumerOptions.CommitMode.TRANSACTIONAL_PRODUCER;
 import static java.util.concurrent.TimeUnit.SECONDS;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.awaitility.Awaitility.await;
@@ -52,7 +53,7 @@ public class VertxTest extends ParallelEoSStreamProcessorTestBase {
 
     JStreamVertxParallelEoSStreamProcessor<String, String> vertxAsync;
 
-    protected static WireMockServer stubServer;
+    public static WireMockServer stubServer;
 
     protected static final String stubResponse = "Good times.";
 
@@ -68,12 +69,13 @@ VertxParallelEoSStreamProcessor.RequestInfo getBadHost() {
     public static void setupWireMock() {
         WireMockConfiguration options = wireMockConfig().dynamicPort();
         stubServer = new WireMockServer(options);
-        stubServer.start();
         MappingBuilder mappingBuilder = get(urlPathEqualTo("/"))
                 .willReturn(aResponse()
                         .withBody(stubResponse));
-        stubServer.stubFor(
-                mappingBuilder);
+        stubServer.stubFor(mappingBuilder);
+        stubServer.stubFor(get(urlPathEqualTo("/api")).
+                willReturn(aResponse().withBody(stubResponse)));
+        stubServer.start();
     }
 
     @Override
@@ -81,8 +83,10 @@ protected ParallelEoSStreamProcessor initAsyncConsumer(ParallelConsumerOptions p
         VertxOptions vertxOptions = new VertxOptions();
         Vertx vertx = Vertx.vertx(vertxOptions);
         WebClient wc = WebClient.create(vertx);
-        ParallelConsumerOptions build = ParallelConsumerOptions.builder().build();
-        vertxAsync = new JStreamVertxParallelEoSStreamProcessor<>(consumerSpy, producerSpy, vertx, wc, build);
+        var build = parallelConsumerOptions.toBuilder()
+                .commitMode(TRANSACTIONAL_PRODUCER) // force tx
+                .build();
+        vertxAsync = new JStreamVertxParallelEoSStreamProcessor<>(vertx, wc, build);
 
         return vertxAsync;
     }
@@ -119,7 +123,7 @@ public void failingHttpCall() {
         awaitLatch(latch);
 
         //
-        assertCommits(of(0));
+        assertCommits(of());
 
         // check results are failures
         var res = getResults(tupleStream);
@@ -185,7 +189,7 @@ public void testHttpMinimal() {
         // verify
         var res = getResults(futureStream);
 
-        KafkaTestUtils.assertCommits(producerSpy, of(0, 1));
+        KafkaTestUtils.assertCommits(producerSpy, of(1));
 
         // test results are successes
         assertThat(res).extracting(x -> x.result().statusCode()).containsOnly(200);
diff --git a/pom.xml b/pom.xml
index 8d609a8b8..579b2854f 100644
--- a/pom.xml
+++ b/pom.xml
@@ -4,7 +4,8 @@
     Copyright (C) 2020 Confluent, Inc.
 
 -->
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
 
     <groupId>io.confluent.parallelconsumer</groupId>
@@ -75,6 +76,7 @@
         <jvm8.location>-insert jvm8 location via environment variable-</jvm8.location>
         <jvm9.location>-insert jvm9 location via environment variable-</jvm9.location>
         <license.mode>check</license.mode>
+        <delombok.output>${project.basedir}/target/delombok</delombok.output>
 
         <!-- standard props -->
         <maven.version>3.6.3</maven.version>
@@ -266,6 +268,13 @@
             <version>${junit.platform.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <!-- Junit Pioneer pulls in an older version - force the matched version -->
+            <groupId>org.junit.platform</groupId>
+            <artifactId>junit-platform-commons</artifactId>
+            <version>${junit.platform.version}</version>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.assertj</groupId>
             <artifactId>assertj-core</artifactId>
@@ -568,10 +577,37 @@
                 <artifactId>maven-project-info-reports-plugin</artifactId>
                 <version>3.1.0</version>
             </plugin>
+            <plugin>
+                <groupId>org.projectlombok</groupId>
+                <artifactId>lombok-maven-plugin</artifactId>
+                <version>1.18.16.0</version>
+                <configuration>
+                    <sourceDirectory>${project.basedir}/src/main/java</sourceDirectory>
+                    <outputDirectory>${delombok.output}</outputDirectory>
+                    <addOutputDirectory>false</addOutputDirectory>
+                </configuration>
+                <executions>
+                    <execution>
+                        <phase>generate-sources</phase>
+                        <goals>
+                            <goal>delombok</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-javadoc-plugin</artifactId>
                 <version>3.1.1</version>
+                <configuration>
+                    <sourcepath>${delombok.output}</sourcepath>
+                    <sourcepath>${delombok.output}</sourcepath>
+                    <!--
+                    Force javadoc to ignore things like "unknown tag: implNote"
+                    and "no @param for <C>"
+                    -->
+                    <additionalOptions>-Xdoclint:none</additionalOptions>
+                </configuration>
                 <executions>
                     <execution>
                         <id>attach-javadocs</id>
diff --git a/src/docs/README.adoc b/src/docs/README.adoc
index 3501b1511..82f8034d4 100644
--- a/src/docs/README.adoc
+++ b/src/docs/README.adoc
@@ -38,7 +38,10 @@ ifdef::env-github[]
 :warning-caption: :warning:
 endif::[]
 
-image:https://travis-ci.com/astubbs/parallel-consumer.svg?branch=master["Build Status", link="https://travis-ci.com/astubbs/parallel-consumer"] image:https://codecov.io/gh/astubbs/parallel-consumer/branch/master/graph/badge.svg["Coverage",https://codecov.io/gh/astubbs/parallel-consumer]
+image:https://maven-badges.herokuapp.com/maven-central/io.confluent.parallelconsumer/parallel-consumer-parent/badge.svg?style=flat[link=https://mvnrepository.com/artifact/io.confluent.parallelconsumer/parallel-consumer-parent,Latest Parallel Consumer on Maven Central]
+
+// travis badges temporarily disabled as travis isn't running CI currently
+//image:https://travis-ci.com/astubbs/parallel-consumer.svg?branch=master["Build Status", link="https://travis-ci.com/astubbs/parallel-consumer"] image:https://codecov.io/gh/astubbs/parallel-consumer/branch/master/graph/badge.svg["Coverage",https://codecov.io/gh/astubbs/parallel-consumer]
 
 Parallel Apache Kafka client wrapper with client side queueing, a simpler consumer/producer API with *key concurrency* and *extendable non-blocking IO* processing.
 
@@ -111,10 +114,12 @@ This is effective in many situations, but falls short in a lot too.
 
 * Primarily: You cannot use more consumers than you have partitions available to read from.
 For example, if you have a topic with five partitions, you cannot use a group with more than five consumers to read from it.
-* Running more extra consumers has resource implications - each consumer takes up resources on both the client  and broker side
+* Running more extra consumers has resource implications - each consumer takes up resources on both the client  and broker side.
 Each consumer adds a lot of overhead in terms of memory, CPU, and network bandwidth.
 * Large consumer groups (especially many large groups) can cause a lot of strain on the consumer group coordination system, such as rebalance storms.
-* Even with several partitions, you cannot achieve the performance levels obtainable by *per-key* ordered or unordered concurrent processing
+* Even with several partitions, you cannot achieve the performance levels obtainable by *per-key* ordered or unordered concurrent processing.
+* A single slow or failing message will also still block all messages behind the problematic message, ie. the entire partition.
+The process may recover, but the latency of all the messages behind the problematic one will be negatively impacted severely.
 
 Why not run more consumers __within__ your application instance?::
 * This is in some respects a slightly easier way of running more consumer instances, and in others a more complicated way.
@@ -193,11 +198,12 @@ without operational burden or harming the clusters performance
 * Vert.x non-blocking library integration (HTTP currently)
 * Fair partition traversal
 * Zero~ dependencies (`Slf4j` and `Lombok`) for the core module
+* Java 8 compatibility
 * Throttle control and broker liveliness management
 * Clean draining shutdown cycle
 
-image:https://codecov.io/gh/astubbs/parallel-consumer/branch/master/graph/badge.svg["Coverage",https://codecov.io/gh/astubbs/parallel-consumer]
-image:https://travis-ci.com/astubbs/parallel-consumer.svg?branch=master["Build Status", link="https://travis-ci.com/astubbs/parallel-consumer"]
+//image:https://codecov.io/gh/astubbs/parallel-consumer/branch/master/graph/badge.svg["Coverage",https://codecov.io/gh/astubbs/parallel-consumer]
+//image:https://travis-ci.com/astubbs/parallel-consumer.svg?branch=master["Build Status", link="https://travis-ci.com/astubbs/parallel-consumer"]
 
 And more <<roadmap,to come>>!
 
@@ -340,6 +346,11 @@ Latest version can be seen https://search.maven.org/artifact/io.confluent.parall
 
 Where `${project.version}` is the version to be used:
 
+* group ID: `io.confluent.parallelconsumer`
+* artifact ID: `parallel-consumer-core`
+* version: image:https://maven-badges.herokuapp.com/maven-central/io.confluent.parallelconsumer/parallel-consumer-parent/badge.svg?style=flat[link=https://mvnrepository.com/artifact/io.confluent.parallelconsumer/parallel-consumer-parent,Latest Parallel Consumer on Maven Central]
+
+
 .Core Module Dependency
 [source,xml,indent=0]
 include::{project_root}/parallel-consumer-examples/parallel-consumer-example-core/pom.xml[tag=exampleDep]
@@ -356,13 +367,13 @@ include::{project_root}/parallel-consumer-examples/parallel-consumer-example-ver
 ----
 include::{project_root}/parallel-consumer-examples/parallel-consumer-example-core/src/main/java/io/confluent/parallelconsumer/examples/core/CoreApp.java[tag=exampleSetup]
 ----
-<1> Choose your ordering type, `KEY` in this case.
+<1> Setup your clients as per normal. A Producer is only required if using the `produce` flows.
+<2> Choose your ordering type, `KEY` in this case.
 This ensures maximum concurrency, while ensuring messages are processed and committed in `KEY` order, making sure no offset is committed unless all offsets before it in it's partition, are completed also.
-<2> The maximum number of concurrent processing operations to be performing at any given time
-<3> Regardless of the level of concurrency, don't have more than this many messages uncommitted at any given time.
+<3> The maximum number of concurrent processing operations to be performing at any given time
+<4> Regardless of the level of concurrency, don't have more than this many messages uncommitted at any given time.
 Also, because the library coordinates offsets, `enable.auto.commit` must be disabled in your consumer.
-<4> Setup your consumer client as per normal
-<5> Setup your topic subscriptions - (when using the `MockConsumer` you must use the `MockConsumer#assign` method)
+<5> Subscribe to your topics
 
 NOTE: Because the library coordinates offsets, `enable.auto.commit` must be disabled.
 
@@ -528,16 +539,33 @@ When your function is actually run, a result object will be streamed back to you
 After your operation completes, you can also choose to publish a result message back to Kafka.
 The message publishing metadata can be streamed back to your client code.
 
-== Apache Kafka EoS Transaction Model
+== Commit Mode
+
+The system gives you three choices for how to do offset commits.
+The simplest of the three are the two Consummer commits modes.
+They are of course, `sycnhronous` and `asynchronous` mode.
+The `transactional` mode is explained in the next section.
+
+`Asychornous` mode is faster, as it doesn't block the control loop.
+
+`Sycnhronous` will block the processing loop until a successful commit response is received, however, `asycnhronous` will still be capped by the max processing settings in the `Options` class.
 
-The system uses Kafka's Exactly Once Semantics (EoS) system.
+If you're used to using the auto commit mode in the normal Kafka consumer, you can think of the `Asychornous` mode being similar to this.
+We suggest starting with this mode, and it is the default.
+
+=== Apache Kafka EoS Transaction Model
+
+There is also the option to use Kafka's Exactly Once Semantics (EoS) system.
 This causes all messages produced as a result of processing a message to be committed within a transaction, along with their source offset.
 This means that even under failure, the results will exist exactly once in the Kafka output topic.
-If as a part of
-your processing, you create side effects in other systems, this pertains to the usual idempotency requirements when breaking of EoS Kafka boundaries.
+If as a part of your processing, you create side effects in other systems, this pertains to the usual idempotency requirements when breaking of EoS Kafka boundaries.
+
+NOTE:: As with the `synchronous` processing mode, this will also block the processing loop until a successful transaction completes
 
 CAUTION: This cannot be true for any externally integrated third party system, unless that system is __idempotent__.
 
+For implementations details, see the <<Transactional System Architecture>> section.
+
 [[streams-usage]]
 == Using with Kafka Streams
 
@@ -556,21 +584,20 @@ image::https://lucid.app/publicSegments/view/43f2740c-2a7f-4b7f-909e-434a5bbe3fb
 
 === Short Term - What we're working on nowish ⏰
 
-* Producer is optional
-* Transactions optional
 * Depth~ first or breadth first partition traversal
 * JavaRX and other streaming modules
 
 === Medium Term - What's up next ⏲
 
-* Automatic fanout (automatic selection of concurrency level based on downstream back pressure)
+* https://github.com/confluentinc/parallel-consumer/issues/21[Automatic fanout] (automatic selection of concurrency level based on downstream back pressure) (https://github.com/confluentinc/parallel-consumer/pull/22[draft PR])
 * Support for general Vert.x Verticles (non-blocking libraries)
 * Dead Letter Queue (DLQ) handling
 * Non-blocking I/O work management
 ** More customisable handling of HTTP interactions
 ** Chance to batch multiple consumer records into a single or multiple http request objects
-* Distributed tracing integration
-* Metrics
+* https://github.com/confluentinc/parallel-consumer/issues/28[Distributed tracing integration]
+* https://github.com/confluentinc/parallel-consumer/issues/24[Distributed rate limiting]
+* https://github.com/confluentinc/parallel-consumer/issues/27[Metrics]
 
 === Long Term - The future ☁️
 
@@ -724,6 +751,10 @@ Instead of the work thread pool count being the degree of concurrency, it is con
 .Vert.x Architecture
 image::https://lucid.app/publicSegments/view/509df410-5997-46be-98e7-ac7f241780b4/image.png[Vert.x Architecture, align="center"]
 
+=== Transactional System Architecture
+
+image::https://lucid.app/publicSegments/view/7480d948-ed7d-4370-a308-8ec12e6b453b/image.png[]
+
 === Offset Map
 
 ==== Storage