diff --git a/src/main/java/org/folio/models/pieces/PieceBatchStatusUpdateHolder.java b/src/main/java/org/folio/models/pieces/PieceBatchStatusUpdateHolder.java
index af6a5ddc9..b65c1663f 100644
--- a/src/main/java/org/folio/models/pieces/PieceBatchStatusUpdateHolder.java
+++ b/src/main/java/org/folio/models/pieces/PieceBatchStatusUpdateHolder.java
@@ -1,18 +1,17 @@
 package org.folio.models.pieces;
 
 import lombok.AllArgsConstructor;
-import lombok.Builder;
 import lombok.Getter;
 import org.folio.rest.jaxrs.model.Piece;
 
 import java.util.List;
 
 @AllArgsConstructor
-@Getter
-@Builder
 public class PieceBatchStatusUpdateHolder extends BasePieceFlowHolder {
 
+  @Getter
   private Piece.ReceivingStatus receivingStatus;
+  @Getter
   private List<Piece> pieces;
   private String poLineId;
 
diff --git a/src/main/java/org/folio/orders/events/handlers/ReceiptStatusConsistency.java b/src/main/java/org/folio/orders/events/handlers/ReceiptStatusConsistency.java
index c992e4902..e234e935e 100644
--- a/src/main/java/org/folio/orders/events/handlers/ReceiptStatusConsistency.java
+++ b/src/main/java/org/folio/orders/events/handlers/ReceiptStatusConsistency.java
@@ -59,6 +59,7 @@ public void handle(Message<JsonObject> message) {
 
   private Future<Void> updatePoLineAndOrderStatuses(List<Piece> pieces, PoLine poLine, RequestContext requestContext) {
     if (PoLineCommonUtil.isCancelledOrOngoingStatus(poLine)) {
+      logger.info("updatePoLineAndOrderStatuses:: PoLine with id: '{}' has status: '{}', skipping...", poLine.getId(), poLine.getReceiptStatus());
       return Future.succeededFuture();
     }
     var newStatus = pieces.isEmpty()
@@ -66,11 +67,13 @@ private Future<Void> updatePoLineAndOrderStatuses(List<Piece> pieces, PoLine poL
       : calculatePoLineReceiptStatus(poLine.getId(), pieces);
     boolean statusUpdated = purchaseOrderLineService.updatePoLineReceiptStatusWithoutSave(poLine, newStatus);
     if (!statusUpdated) {
+      logger.info("updatePoLineAndOrderStatuses:: PoLine receipt status is not updated, skipping...");
       return Future.succeededFuture();
     }
     return purchaseOrderLineService.saveOrderLine(poLine, requestContext)
       .compose(v -> updateOrderStatus(poLine, okapiHeaders, requestContext))
-      .onFailure(e -> logger.error("Exception occurred while updating PoLine by id: '{}'", poLine.getId(), e));
+      .onSuccess(v -> logger.info("updatePoLineAndOrderStatuses:: Order '{}' and PoLine '{}' updated successfully", poLine.getId(), poLine.getPurchaseOrderId()))
+      .onFailure(e -> logger.error("Exception occurred while updating Order '{}' and PoLine '{}'", poLine.getId(), poLine.getPurchaseOrderId(), e));
   }
 
   private Future<Void> updateOrderStatus(PoLine poLine, Map<String, String> okapiHeaders, RequestContext requestContext) {
diff --git a/src/main/java/org/folio/orders/utils/FutureUtils.java b/src/main/java/org/folio/orders/utils/FutureUtils.java
new file mode 100644
index 000000000..2abbf9e62
--- /dev/null
+++ b/src/main/java/org/folio/orders/utils/FutureUtils.java
@@ -0,0 +1,26 @@
+package org.folio.orders.utils;
+
+import io.vertx.core.Future;
+
+import java.util.concurrent.Callable;
+
+public class FutureUtils {
+
+  public static Future<Void> asFuture(Runnable runnable) {
+    return asFuture(() -> {
+      runnable.run();
+      return null;
+    });
+  }
+
+  public static <T> Future<T> asFuture(Callable<T> callable) {
+    try {
+      return Future.succeededFuture(callable.call());
+    } catch (Exception e) {
+      return Future.failedFuture(e);
+    }
+  }
+
+  private FutureUtils() {}
+
+}
diff --git a/src/main/java/org/folio/service/pieces/flows/update/PieceUpdateFlowManager.java b/src/main/java/org/folio/service/pieces/flows/update/PieceUpdateFlowManager.java
index a2583478c..3c28b8831 100644
--- a/src/main/java/org/folio/service/pieces/flows/update/PieceUpdateFlowManager.java
+++ b/src/main/java/org/folio/service/pieces/flows/update/PieceUpdateFlowManager.java
@@ -1,5 +1,6 @@
 package org.folio.service.pieces.flows.update;
 
+import static org.folio.orders.utils.FutureUtils.asFuture;
 import static org.folio.orders.utils.ProtectedOperationType.UPDATE;
 import static org.folio.service.orders.utils.StatusUtils.calculatePoLineReceiptStatus;
 import static org.folio.service.pieces.PieceUtil.updatePieceStatus;
@@ -75,21 +76,17 @@ public Future<Void> updatePiece(Piece pieceToUpdate, boolean createItem, boolean
       .map(holder::withPieceFromStorage)
       .compose(aHolder -> basePieceFlowHolderBuilder.updateHolderWithOrderInformation(holder, requestContext))
       .compose(aHolder -> basePieceFlowHolderBuilder.updateHolderWithTitleInformation(holder, requestContext))
-      .map(v -> {
-        defaultPieceFlowsValidator.isPieceRequestValid(pieceToUpdate, holder.getOriginPoLine(), createItem);
-        return null;
-      })
+      .compose(v -> asFuture(() -> defaultPieceFlowsValidator.isPieceRequestValid(pieceToUpdate, holder.getOriginPoLine(), createItem)))
       .compose(title -> protectionService.isOperationRestricted(holder.getTitle().getAcqUnitIds(), UPDATE, requestContext))
       .compose(v -> pieceUpdateFlowInventoryManager.processInventory(holder, requestContext))
       .compose(v -> updatePoLine(holder, requestContext))
       .map(v -> updatePieceStatus(holder.getPieceToUpdate(), holder.getPieceFromStorage().getReceivingStatus(), holder.getPieceToUpdate().getReceivingStatus()))
       .compose(verifyReceiptStatus -> pieceStorageService.updatePiece(holder.getPieceToUpdate(), requestContext).map(verifyReceiptStatus))
-      .compose(verifyReceiptStatus -> {
+      .compose(verifyReceiptStatus -> asFuture(() -> {
         if (Boolean.TRUE.equals(verifyReceiptStatus)) {
           pieceService.receiptConsistencyPiecePoLine(holder.getPieceToUpdate().getPoLineId(), requestContext);
         }
-        return Future.succeededFuture();
-      })
+      }))
       .onFailure(t -> log.error("User to update piece with id={}", holder.getPieceToUpdate().getId(), t))
       .mapEmpty();
   }
@@ -146,16 +143,14 @@ private <T extends BasePieceFlowHolder> Future<Void> updatePoLine(T holder, List
       .onFailure(t -> log.error("Failed to update PO line with id: '{}' for pieceIds: {}", originPoLine.getId(), pieceIds, t));
   }
 
-  private Future<Boolean> updatePiecesStatusesByPoLine(PieceBatchStatusUpdateHolder holder, RequestContext requestContext) {
+  private Future<Void> updatePiecesStatusesByPoLine(PieceBatchStatusUpdateHolder holder, RequestContext requestContext) {
     var isAnyPiecesUpdated = holder.getPieces().stream().anyMatch(piece -> updatePieceStatus(piece, piece.getReceivingStatus(), holder.getReceivingStatus()));
+    if (!isAnyPiecesUpdated) {
+      return Future.succeededFuture();
+    }
     var updates = holder.getPieces().stream().map(piece -> pieceStorageService.updatePiece(piece, requestContext)).toList();
     return HelperUtils.collectResultsOnSuccess(updates)
-      .map(v -> {
-        if (isAnyPiecesUpdated) {
-          pieceService.receiptConsistencyPiecePoLine(holder.getPoLineId(), requestContext);
-        }
-        return isAnyPiecesUpdated;
-      });
+      .compose(v -> asFuture(() -> pieceService.receiptConsistencyPiecePoLine(holder.getOrderLineId(), requestContext)));
   }
 
   private List<Location> getPieceLocations(List<Piece> pieces, CompositePoLine poLine) {