diff --git a/vorgang-manager-server/src/main/java/de/ozgcloud/vorgang/vorgang/redirect/ForwardingEventListener.java b/vorgang-manager-server/src/main/java/de/ozgcloud/vorgang/vorgang/redirect/ForwardingEventListener.java
index b8aab024e7464c3371e9647b506f58611d0d0f95..83e00d9f132b73ac497b360ea7f2f02624b88437 100644
--- a/vorgang-manager-server/src/main/java/de/ozgcloud/vorgang/vorgang/redirect/ForwardingEventListener.java
+++ b/vorgang-manager-server/src/main/java/de/ozgcloud/vorgang/vorgang/redirect/ForwardingEventListener.java
@@ -97,16 +97,25 @@ public class ForwardingEventListener {
 
 	@EventListener(condition = IS_FORWARD_VORGANG_ORDER_CONDITION)
 	public void onForwardVorgangOrder(CommandCreatedEvent event) {
-		lockVorgangOnForwarding(event.getSource());
-		service.forward(forwardingRequestMapper.fromCommand(event.getSource()));
-		publisher.publishEvent(new VorgangLockedEvent(event.getSource()));
+		handleException(() -> handleForwardVorgangCommand(event.getSource()), event.getSource().getId());
+	}
+
+	void handleForwardVorgangCommand(Command command) {
+		lockVorgangOnForwarding(command);
+		service.forward(updateVorgangVersion(forwardingRequestMapper.fromCommand(command)));
+		publisher.publishEvent(new VorgangLockedEvent(command));
 	}
 
 	private void lockVorgangOnForwarding(Command command) {
-		var lock = lockMapper.fromCommand(command).toBuilder().reason("Vorgang is being forwarded").build();
+		var lock = lockMapper.fromCommand(command).toBuilder().reason("Vorgang was forwarded").build();
 		vorgangService.lockVorgang(lock, command.getVorgangId(), command.getRelationVersion());
 	}
 
+	ForwardingRequest updateVorgangVersion(ForwardingRequest request) {
+		var vorgang = vorgangService.getById(request.getVorgangId());
+		return request.toBuilder().version(vorgang.getVersion()).build();
+	}
+
 	private void handleException(Runnable runnable, String commandId) {
 		try {
 			runnable.run();
diff --git a/vorgang-manager-server/src/main/java/de/ozgcloud/vorgang/vorgang/redirect/ForwardingRequest.java b/vorgang-manager-server/src/main/java/de/ozgcloud/vorgang/vorgang/redirect/ForwardingRequest.java
index b8dbf058763bb106e0a9a700af4bde86e1c755a5..25179865679a4100697b767fb850f8be54a3c7dd 100644
--- a/vorgang-manager-server/src/main/java/de/ozgcloud/vorgang/vorgang/redirect/ForwardingRequest.java
+++ b/vorgang-manager-server/src/main/java/de/ozgcloud/vorgang/vorgang/redirect/ForwardingRequest.java
@@ -27,7 +27,7 @@ import lombok.Builder;
 import lombok.Getter;
 
 @Getter
-@Builder
+@Builder(toBuilder = true)
 public class ForwardingRequest {
 
 	private String vorgangId;
diff --git a/vorgang-manager-server/src/test/java/de/ozgcloud/vorgang/vorgang/redirect/ForwardingEventListenerTest.java b/vorgang-manager-server/src/test/java/de/ozgcloud/vorgang/vorgang/redirect/ForwardingEventListenerTest.java
index 4ca29c2ac342679a09903dba8d8855699d7bdd1a..588060cef8cfa5609fe6c566224fd0591639fad9 100644
--- a/vorgang-manager-server/src/test/java/de/ozgcloud/vorgang/vorgang/redirect/ForwardingEventListenerTest.java
+++ b/vorgang-manager-server/src/test/java/de/ozgcloud/vorgang/vorgang/redirect/ForwardingEventListenerTest.java
@@ -37,6 +37,7 @@ import org.mockito.ArgumentCaptor;
 import org.mockito.Captor;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
+import org.mockito.Spy;
 import org.springframework.context.ApplicationEventPublisher;
 
 import com.thedeanda.lorem.LoremIpsum;
@@ -45,6 +46,7 @@ import de.ozgcloud.command.Command;
 import de.ozgcloud.command.CommandCreatedEvent;
 import de.ozgcloud.command.CommandFailedEvent;
 import de.ozgcloud.command.VorgangLockedEvent;
+import de.ozgcloud.common.errorhandling.TechnicalException;
 import de.ozgcloud.nachrichten.email.MailSentEventTestFactory;
 import de.ozgcloud.vorgang.command.CommandCreatedEventTestFactory;
 import de.ozgcloud.vorgang.command.CommandTestFactory;
@@ -57,6 +59,7 @@ import de.ozgcloud.vorgang.vorgang.VorgangTestFactory;
 
 class ForwardingEventListenerTest {
 
+	@Spy
 	@InjectMocks // NOSONAR
 	private ForwardingEventListener listener;
 
@@ -108,8 +111,42 @@ class ForwardingEventListenerTest {
 	@Nested
 	class TestOnForwardVorgangOrder {
 
-		private final CommandCreatedEvent event = event();
+		private final CommandCreatedEvent event = CommandCreatedEventTestFactory.create();
+
+		@Captor
+		private ArgumentCaptor<CommandFailedEvent> failedEventCaptor;
+
+		@Test
+		void shouldHandleForwardVorgangCommand() {
+			doNothing().when(listener).handleForwardVorgangCommand(any());
+
+			onForwardVorgangOrder();
+
+			verify(listener).handleForwardVorgangCommand(event.getSource());
+		}
+
+		@Test
+		void shouldPublishFailedEventOnError() {
+			doThrow(TechnicalException.class).when(listener).handleForwardVorgangCommand(any());
+
+			onForwardVorgangOrder();
+
+			verify(publisher).publishEvent(failedEventCaptor.capture());
+			assertThat(failedEventCaptor.getValue().getSource()).isEqualTo(event.getSource().getId());
+		}
+
+		private void onForwardVorgangOrder() {
+			listener.onForwardVorgangOrder(event);
+		}
+	}
+
+	@Nested
+	class TestHandleForwardVorgangCommand {
+
+		private final Command command = CommandTestFactory.createBuilder().bodyObject(commandBody()).build();
 		private final Lock lock = LockTestFactory.create();
+		private final ForwardingRequest request = ForwardingRequestTestFactory.create();
+		private final ForwardingRequest updatedRequest = ForwardingRequestTestFactory.createBuilder().version(request.getVersion() + 1).build();
 		@Captor
 		private ArgumentCaptor<Lock> lockCaptor;
 		@Captor
@@ -119,55 +156,59 @@ class ForwardingEventListenerTest {
 
 		@BeforeEach
 		void init() {
-			when(forwardingRequestMapper.fromCommand(any())).thenReturn(ForwardingRequestTestFactory.create());
+			when(forwardingRequestMapper.fromCommand(any())).thenReturn(request);
 			when(lockMapper.fromCommand(any())).thenReturn(lock);
+			doReturn(updatedRequest).when(listener).updateVorgangVersion(any());
 		}
 
 		@Test
 		void shouldMapLock() {
-			onForwardVorgangOrder();
+			handleForwardVorgangCommand();
 
-			verify(lockMapper).fromCommand(event.getSource());
+			verify(lockMapper).fromCommand(command);
 		}
 
 		@Test
 		void shouldLockVorgang() {
-			onForwardVorgangOrder();
+			handleForwardVorgangCommand();
 
 			verify(vorgangService).lockVorgang(lockCaptor.capture(), eq(VorgangTestFactory.ID), eq(CommandTestFactory.RELATION_VERSION));
 			assertThat(lockCaptor.getValue()).usingRecursiveComparison()
-					.isEqualTo(LockTestFactory.createBuilder().reason("Vorgang is being forwarded").build());
+					.isEqualTo(LockTestFactory.createBuilder().reason("Vorgang was forwarded").build());
 		}
 
 		@Test
 		void shouldMapCommandForwardingRequest() {
-			onForwardVorgangOrder();
+			handleForwardVorgangCommand();
+
+			verify(forwardingRequestMapper).fromCommand(command);
+		}
+
+		@Test
+		void shouldUpdateVorgangVersionInRequest() {
+			handleForwardVorgangCommand();
 
-			verify(forwardingRequestMapper).fromCommand(event.getSource());
+			verify(listener).updateVorgangVersion(request);
 		}
 
 		@Test
 		void shouldCallForwardingService() {
-			onForwardVorgangOrder();
+			handleForwardVorgangCommand();
 
 			verify(forwardingService).forward(forwardingRequestCaptor.capture());
-			assertThat(forwardingRequestCaptor.getValue()).usingRecursiveComparison().isEqualTo(ForwardingRequestTestFactory.create());
+			assertThat(forwardingRequestCaptor.getValue()).isSameAs(updatedRequest);
 		}
 
 		@Test
 		void shouldPublishVorgangLockedEvent() {
-			onForwardVorgangOrder();
+			handleForwardVorgangCommand();
 
 			verify(publisher).publishEvent(lockedEventCaptor.capture());
-			assertThat(lockedEventCaptor.getValue().getCommand()).isSameAs(event.getSource());
-		}
-
-		private void onForwardVorgangOrder() {
-			listener.onForwardVorgangOrder(event);
+			assertThat(lockedEventCaptor.getValue().getCommand()).isSameAs(command);
 		}
 
-		private static CommandCreatedEvent event() {
-			return CommandCreatedEventTestFactory.create(CommandTestFactory.createBuilder().bodyObject(commandBody()).build());
+		private void handleForwardVorgangCommand() {
+			listener.handleForwardVorgangCommand(command);
 		}
 
 		private static Map<String, Object> commandBody() {