diff --git a/subsystem/src/main/java/org/wildfly/extension/vertx/VertxConstants.java b/subsystem/src/main/java/org/wildfly/extension/vertx/VertxConstants.java
index fb6a242..83f69b3 100644
--- a/subsystem/src/main/java/org/wildfly/extension/vertx/VertxConstants.java
+++ b/subsystem/src/main/java/org/wildfly/extension/vertx/VertxConstants.java
@@ -27,6 +27,7 @@ public interface VertxConstants {
 
     String[] TIME_UNITS = Arrays.stream(TimeUnit.values()).map(Enum::toString).collect(Collectors.toList()).toArray(new String[0]);
 
+    String CDI_NAMED_QUALIFIER = "vertx";
     String VERTX_SERVICE = "vertx";
     String ELEMENT_VERTX = "vertx";
 
diff --git a/subsystem/src/main/java/org/wildfly/extension/vertx/logging/VertxLogger.java b/subsystem/src/main/java/org/wildfly/extension/vertx/logging/VertxLogger.java
index 2601113..43bf93a 100644
--- a/subsystem/src/main/java/org/wildfly/extension/vertx/logging/VertxLogger.java
+++ b/subsystem/src/main/java/org/wildfly/extension/vertx/logging/VertxLogger.java
@@ -58,4 +58,8 @@ public interface VertxLogger extends BasicLogger {
     @LogMessage(level = INFO)
     @Message(id = 8, value = "Use Vertx instance from vertx subsystem")
     void useVertxFromSubsystem();
+
+    @Message(id = 9, value = "There is no vertx defined from vertx subsystem")
+    IllegalStateException noVertxDefined();
+
 }
diff --git a/subsystem/src/main/java/org/wildfly/extension/vertx/processors/CDIExtension.java b/subsystem/src/main/java/org/wildfly/extension/vertx/processors/CDIExtension.java
index 3cbb27b..c10d102 100644
--- a/subsystem/src/main/java/org/wildfly/extension/vertx/processors/CDIExtension.java
+++ b/subsystem/src/main/java/org/wildfly/extension/vertx/processors/CDIExtension.java
@@ -18,6 +18,7 @@
 
 import jakarta.enterprise.context.spi.CreationalContext;
 import jakarta.enterprise.event.Observes;
+import jakarta.enterprise.inject.literal.NamedLiteral;
 import jakarta.enterprise.inject.spi.AfterBeanDiscovery;
 import jakarta.enterprise.inject.spi.AnnotatedType;
 import jakarta.enterprise.inject.spi.Bean;
@@ -27,11 +28,17 @@
 import jakarta.enterprise.inject.spi.InjectionPoint;
 import jakarta.enterprise.inject.spi.InjectionTarget;
 import jakarta.enterprise.inject.spi.InjectionTargetFactory;
+import org.wildfly.extension.vertx.VertxProxy;
 import org.wildfly.extension.vertx.VertxProxyHolder;
 import org.wildfly.extension.vertx.logging.VertxLogger;
 
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import java.util.HashSet;
 import java.util.Set;
 
+import static org.wildfly.extension.vertx.VertxConstants.CDI_NAMED_QUALIFIER;
+
 /**
  * CDI Extension which adds the ability to inject the Vertx instances by the member name.
  *
@@ -44,87 +51,123 @@ public CDIExtension() {
 
     public void registerVertxBean(@Observes AfterBeanDiscovery afterBeanDiscovery, BeanManager beanManager) {
         if (VertxProxyHolder.instance().getVertxProxy() != null) {
-            VertxLogger.VERTX_LOGGER.useVertxFromSubsystem();
+            final String vpName = CDI_NAMED_QUALIFIER;
             AnnotatedType<io.vertx.core.Vertx> rawVertxAnnotatedType = beanManager.createAnnotatedType(io.vertx.core.Vertx.class);
-            BeanAttributes<io.vertx.core.Vertx> rawVertxBeanAttributes = beanManager.createBeanAttributes(rawVertxAnnotatedType);
+            BeanAttributes<io.vertx.core.Vertx> rawVertxBeanAttributes =
+                    new BeanAttributesWrapper<>(beanManager.createBeanAttributes(rawVertxAnnotatedType), Set.of(NamedLiteral.of(vpName)));
             afterBeanDiscovery.addBean(beanManager.createBean(rawVertxBeanAttributes, io.vertx.core.Vertx.class, new RawVertxProducer()));
 
             AnnotatedType<io.vertx.mutiny.core.Vertx> annotatedType = beanManager.createAnnotatedType(io.vertx.mutiny.core.Vertx.class);
-            BeanAttributes<io.vertx.mutiny.core.Vertx> beanAttributes = beanManager.createBeanAttributes(annotatedType);
+            BeanAttributes<io.vertx.mutiny.core.Vertx> beanAttributes =
+                    new BeanAttributesWrapper<>(beanManager.createBeanAttributes(annotatedType), Set.of(NamedLiteral.of(vpName)));
             afterBeanDiscovery.addBean(beanManager.createBean(beanAttributes, io.vertx.mutiny.core.Vertx.class, new MunityVertxProducer()));
         }
     }
 
-    private class MunityVertxProducer implements InjectionTargetFactory<io.vertx.mutiny.core.Vertx> {
+    private static class BeanAttributesWrapper<T> implements BeanAttributes<T> {
+        private final BeanAttributes<T> delegate;
+        private final Set<Annotation> qualifiers;
+
+        BeanAttributesWrapper(BeanAttributes<T> delegate, Set<Annotation> additionalQualifiers) {
+            this.delegate = delegate;
+            this.qualifiers = new HashSet<>(delegate.getQualifiers());
+            this.qualifiers.addAll(additionalQualifiers);
+        }
+
         @Override
-        public InjectionTarget<io.vertx.mutiny.core.Vertx> createInjectionTarget(Bean<io.vertx.mutiny.core.Vertx> bean) {
-            return new InjectionTarget<>() {
-                @Override
-                public void inject(io.vertx.mutiny.core.Vertx instance, CreationalContext<io.vertx.mutiny.core.Vertx> ctx) {
-                }
+        public Set<Type> getTypes() {
+            return delegate.getTypes();
+        }
 
-                @Override
-                public void postConstruct(io.vertx.mutiny.core.Vertx instance) {
-                }
+        @Override
+        public Set<Annotation> getQualifiers() {
+            return qualifiers;
+        }
 
-                @Override
-                public void preDestroy(io.vertx.mutiny.core.Vertx instance) {
-                }
+        @Override
+        public Class<? extends Annotation> getScope() {
+            return delegate.getScope();
+        }
 
-                @Override
-                public io.vertx.mutiny.core.Vertx produce(CreationalContext<io.vertx.mutiny.core.Vertx> ctx) {
-                    return mutinyVertx();
-                }
+        @Override
+        public String getName() {
+            return delegate.getName();
+        }
 
-                @Override
-                public void dispose(io.vertx.mutiny.core.Vertx instance) {
-                }
+        @Override
+        public Set<Class<? extends Annotation>> getStereotypes() {
+            return delegate.getStereotypes();
+        }
 
-                @Override
-                public Set<InjectionPoint> getInjectionPoints() {
-                    return Set.of();
-                }
-            };
+        @Override
+        public boolean isAlternative() {
+            return delegate.isAlternative();
         }
+
     }
-    private class RawVertxProducer implements InjectionTargetFactory<io.vertx.core.Vertx> {
+
+    private abstract static class AbstractVertxInjectionTarget<T> implements InjectionTarget<T> {
         @Override
-        public InjectionTarget<io.vertx.core.Vertx> createInjectionTarget(Bean<io.vertx.core.Vertx> bean) {
-            return new InjectionTarget<>() {
-                @Override
-                public void inject(io.vertx.core.Vertx instance, CreationalContext<io.vertx.core.Vertx> ctx) {
-                }
+        public void inject(T instance, CreationalContext<T> ctx) {
+        }
 
-                @Override
-                public void postConstruct(io.vertx.core.Vertx instance) {
-                }
+        @Override
+        public void postConstruct(T instance) {
+        }
 
-                @Override
-                public void preDestroy(io.vertx.core.Vertx instance) {
-                }
+        @Override
+        public void preDestroy(T instance) {
+        }
 
-                @Override
-                public io.vertx.core.Vertx produce(CreationalContext<io.vertx.core.Vertx> ctx) {
-                    return rawVertx();
-                }
+        @Override
+        public void dispose(T instance) {
+        }
+
+        @Override
+        public Set<InjectionPoint> getInjectionPoints() {
+            return Set.of();
+        }
+    }
+
+    private static class MunityVertxProducer implements InjectionTargetFactory<io.vertx.mutiny.core.Vertx> {
+        @Override
+        public InjectionTarget<io.vertx.mutiny.core.Vertx> createInjectionTarget(Bean<io.vertx.mutiny.core.Vertx> bean) {
+            return new AbstractVertxInjectionTarget<>() {
 
                 @Override
-                public void dispose(io.vertx.core.Vertx instance) {
+                public io.vertx.mutiny.core.Vertx produce(CreationalContext<io.vertx.mutiny.core.Vertx> ctx) {
+                    return mutinyVertx();
                 }
-
+            };
+        }
+    }
+    private static class RawVertxProducer implements InjectionTargetFactory<io.vertx.core.Vertx> {
+        @Override
+        public InjectionTarget<io.vertx.core.Vertx> createInjectionTarget(Bean<io.vertx.core.Vertx> bean) {
+            return new AbstractVertxInjectionTarget<>() {
                 @Override
-                public Set<InjectionPoint> getInjectionPoints() {
-                    return Set.of();
+                public io.vertx.core.Vertx produce(CreationalContext<io.vertx.core.Vertx> ctx) {
+                    return rawVertx();
                 }
             };
         }
     }
 
-    private io.vertx.mutiny.core.Vertx mutinyVertx() {
-        return VertxProxyHolder.instance().getVertxProxy().getMutiyVertx();
+    private static io.vertx.mutiny.core.Vertx mutinyVertx() {
+        VertxProxy vertxProxy = VertxProxyHolder.instance().getVertxProxy();
+        if (vertxProxy == null) {
+            throw VertxLogger.VERTX_LOGGER.noVertxDefined();
+        }
+        VertxLogger.VERTX_LOGGER.useVertxFromSubsystem();
+        return vertxProxy.getMutiyVertx();
     }
 
-    private io.vertx.core.Vertx rawVertx() {
-        return VertxProxyHolder.instance().getVertxProxy().getVertx();
+    private static io.vertx.core.Vertx rawVertx() {
+        VertxProxy vertxProxy = VertxProxyHolder.instance().getVertxProxy();
+        if (vertxProxy == null) {
+            throw VertxLogger.VERTX_LOGGER.noVertxDefined();
+        }
+        VertxLogger.VERTX_LOGGER.useVertxFromSubsystem();
+        return vertxProxy.getVertx();
     }
 }