diff --git a/distribution/pom.xml b/distribution/pom.xml
index 4b99e35ab0..0d0a6c24d2 100644
--- a/distribution/pom.xml
+++ b/distribution/pom.xml
@@ -68,6 +68,10 @@
             <groupId>org.jsoup</groupId>
             <artifactId>jsoup</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.jboss</groupId>
+            <artifactId>jandex</artifactId>
+        </dependency>
         <dependency>
             <groupId>com.thoughtworks.paranamer</groupId>
             <artifactId>paranamer</artifactId>
diff --git a/engine/pom.xml b/engine/pom.xml
index a52590697f..6ed67aacc0 100644
--- a/engine/pom.xml
+++ b/engine/pom.xml
@@ -94,6 +94,11 @@
             <artifactId>money-api</artifactId>
             <optional>true</optional>
         </dependency>
+        <dependency>
+            <groupId>org.jboss</groupId>
+            <artifactId>jandex</artifactId>
+            <optional>true</optional>
+        </dependency>
 
         <!--
         Test dependencies
diff --git a/engine/src/main/java/org/hibernate/validator/internal/metadata/jandex/AbstractConstrainedElementJandexBuilder.java b/engine/src/main/java/org/hibernate/validator/internal/metadata/jandex/AbstractConstrainedElementJandexBuilder.java
new file mode 100644
index 0000000000..63679d4771
--- /dev/null
+++ b/engine/src/main/java/org/hibernate/validator/internal/metadata/jandex/AbstractConstrainedElementJandexBuilder.java
@@ -0,0 +1,333 @@
+/*
+ * Hibernate Validator, declare and validate application constraints
+ *
+ * License: Apache License, Version 2.0
+ * See the license.txt file in the root directory or <http://www.apache.org/licenses/LICENSE-2.0>.
+ */
+package org.hibernate.validator.internal.metadata.jandex;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.ElementType;
+import java.lang.reflect.AnnotatedParameterizedType;
+import java.lang.reflect.AnnotatedType;
+import java.lang.reflect.Member;
+import java.lang.reflect.TypeVariable;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import javax.validation.Valid;
+import javax.validation.groups.ConvertGroup;
+
+import org.hibernate.validator.internal.engine.valuehandling.UnwrapMode;
+import org.hibernate.validator.internal.metadata.core.AnnotationProcessingOptions;
+import org.hibernate.validator.internal.metadata.core.ConstraintHelper;
+import org.hibernate.validator.internal.metadata.core.MetaConstraint;
+import org.hibernate.validator.internal.metadata.descriptor.ConstraintDescriptorImpl;
+import org.hibernate.validator.internal.metadata.jandex.util.JandexHelper;
+import org.hibernate.validator.internal.metadata.location.ConstraintLocation;
+import org.hibernate.validator.internal.metadata.raw.ConstrainedElement;
+import org.hibernate.validator.internal.util.CollectionHelper;
+import org.hibernate.validator.internal.util.annotationfactory.AnnotationDescriptor;
+import org.hibernate.validator.internal.util.annotationfactory.AnnotationFactory;
+import org.hibernate.validator.internal.util.logging.Log;
+import org.hibernate.validator.internal.util.logging.LoggerFactory;
+import org.hibernate.validator.valuehandling.UnwrapValidatedValue;
+import org.jboss.jandex.AnnotationInstance;
+import org.jboss.jandex.AnnotationValue;
+import org.jboss.jandex.DotName;
+import org.jboss.jandex.Type;
+
+/**
+ * Abstract builder exploiting the Jandex index to build {@link ConstrainedElement}s.
+ *
+ * @author Marko Bekhta
+ * @author Guillaume Smet
+ */
+public abstract class AbstractConstrainedElementJandexBuilder {
+
+	protected static final Log LOG = LoggerFactory.make();
+
+	private final ConstraintHelper constraintHelper;
+
+	protected final JandexHelper jandexHelper;
+
+	protected final AnnotationProcessingOptions annotationProcessingOptions;
+
+	private final List<DotName> constraintAnnotations;
+
+	protected AbstractConstrainedElementJandexBuilder(ConstraintHelper constraintHelper, JandexHelper jandexHelper,
+			AnnotationProcessingOptions annotationProcessingOptions, List<DotName> constraintAnnotations) {
+		this.jandexHelper = jandexHelper;
+		this.constraintHelper = constraintHelper;
+		this.annotationProcessingOptions = annotationProcessingOptions;
+		this.constraintAnnotations = constraintAnnotations;
+	}
+
+	protected Stream<ConstraintDescriptorImpl<?>> findConstraints(Collection<AnnotationInstance> annotationInstances, Member member) {
+		return findConstrainAnnotations( annotationInstances )
+				.flatMap( annotationInstance -> findConstraintAnnotations( member, annotationInstance ) );
+	}
+
+	protected Stream<MetaConstraint<?>> findTypeAnnotationConstraintsForMember(MemberInformation information, boolean isCascaded) {
+		//TODO: Do we need to include Type.Kind.WILDCARD_TYPE ?
+		if ( !Type.Kind.PARAMETERIZED_TYPE.equals( information.getType().kind() ) ) {
+			return Stream.empty();
+		}
+
+		List<Type> arguments = information.getType().asParameterizedType().arguments();
+		Optional<Type> argument;
+		if ( arguments.size() == 1 ) {
+			argument = Optional.of( arguments.get( 0 ) );
+		}
+		else if ( jandexHelper.isMap( information.getType() ) ) {
+			argument = Optional.of( arguments.get( 1 ) );
+		}
+		else {
+			argument = Optional.empty();
+		}
+		if ( argument.isPresent() ) {
+			// HV-925
+			// We need to determine the validated type used for constraint validator resolution.
+			// Iterables and maps need special treatment at this point, since the validated type is the type of the
+			// specified type parameter. In the other cases the validated type is the parameterized type, eg Optional<String>.
+			// In the latter case a value unwrapping has to occur
+			Type validatedType = information.getType();
+			if ( jandexHelper.isIterable( validatedType ) || jandexHelper.isMap( validatedType ) ) {
+				validatedType = argument.get();
+			}
+			Class<?> memberType = jandexHelper.getClassForName( validatedType.name() );
+			return findConstrainAnnotations( argument.get().annotations() )
+					.flatMap( annotationInstance -> findConstraintAnnotations( information.getMember(), annotationInstance ) )
+					.map( constraintDescriptor -> createTypeArgumentMetaConstraint( information.getConstraintLocation(), constraintDescriptor, memberType ) );
+		}
+
+		return Stream.empty();
+	}
+
+	protected CommonConstraintInformation findCommonConstraintInformation(Type type, Collection<AnnotationInstance> annotationInstances,
+			boolean typeArgumentAnnotated, boolean isCascading) {
+		return new CommonConstraintInformation(
+				getGroupConversions(
+						jandexHelper.findAnnotation( annotationInstances, ConvertGroup.class ),
+						jandexHelper.findAnnotation( annotationInstances, ConvertGroup.List.class )
+				),
+				isCascading,
+				determineUnwrapMode( type, annotationInstances, typeArgumentAnnotated )
+		);
+	}
+
+	private UnwrapMode determineUnwrapMode(Type type, Collection<AnnotationInstance> annotationInstances, boolean typeArgumentAnnotated) {
+		boolean indexable = jandexHelper.isIndexable( type );
+		Optional<AnnotationInstance> unwrapValidatedValue = jandexHelper.findAnnotation( annotationInstances, UnwrapValidatedValue.class );
+
+		if ( !unwrapValidatedValue.isPresent() && typeArgumentAnnotated && !indexable ) {
+			return UnwrapMode.UNWRAP;
+		}
+		else if ( unwrapValidatedValue.isPresent() ) {
+			return unwrapValidatedValue.get().value().asBoolean() ? UnwrapMode.UNWRAP : UnwrapMode.SKIP_UNWRAP;
+		}
+		return UnwrapMode.AUTOMATIC;
+	}
+
+	private Map<Class<?>, Class<?>> getGroupConversions(Optional<AnnotationInstance> convertGroup, Optional<AnnotationInstance> convertGroupList) {
+		Map<Class<?>, Class<?>> groupConversionMap = CollectionHelper.newHashMap();
+
+		convertGroup.ifPresent( annotation -> addToConversionGroup( groupConversionMap, annotation ) );
+
+		convertGroupList.ifPresent( nestedAnnotations -> {
+			for ( AnnotationValue annotationValue : (AnnotationValue[]) nestedAnnotations.value().value() ) {
+				addToConversionGroup( groupConversionMap, annotationValue.asNested() );
+			}
+		} );
+
+		return groupConversionMap;
+	}
+
+	private void addToConversionGroup(Map<Class<?>, Class<?>> groupConversionMap, AnnotationInstance annotation) {
+		Class<?> from = jandexHelper.getClassForName( annotation.value( "from" ).asClass().name() );
+		groupConversionMap.merge(
+				from,
+				jandexHelper.getClassForName( annotation.value( "to" ).asClass().name() ),
+				( val1, val2 ) -> {
+					throw LOG.getMultipleGroupConversionsForSameSourceException(
+							from,
+							CollectionHelper.asSet( val1, val2 )
+					);
+				}
+		);
+	}
+
+	private Stream<ConstraintDescriptorImpl<?>> findConstraintAnnotations(Member member, AnnotationInstance annotationInstance) {
+		return instanceToAnnotations( annotationInstance ).map( constraint -> buildConstraintDescriptor( member, constraint, ElementType.FIELD ) );
+	}
+
+	@SuppressWarnings("unchecked")
+	private <A extends Annotation> Stream<Annotation> instanceToAnnotations(AnnotationInstance annotationInstance) {
+		Class<A> annotationClass = (Class<A>) jandexHelper.getClassForName( annotationInstance.name() );
+		if ( constraintHelper.isMultiValueConstraint( annotationClass ) ) {
+			return Arrays.stream( (AnnotationValue[]) annotationInstance.value().value() )
+					.map( annotationValue -> instanceToAnnotation( annotationValue.asNested() ) );
+		}
+		else if ( constraintHelper.isConstraintAnnotation( annotationClass ) ) {
+			return Stream.of( instanceToAnnotation( annotationClass, annotationInstance ) );
+		}
+		else {
+			return Stream.empty();
+		}
+	}
+
+	@SuppressWarnings("unchecked")
+	private <A extends Annotation> A instanceToAnnotation(AnnotationInstance annotationInstance) {
+		return instanceToAnnotation( (Class<A>) jandexHelper.getClassForName( annotationInstance.name() ), annotationInstance );
+	}
+
+	private <A extends Annotation> A instanceToAnnotation(Class<A> annotationClass, AnnotationInstance annotationInstance) {
+		AnnotationDescriptor<A> annotationDescriptor = new AnnotationDescriptor<>( annotationClass );
+
+		annotationInstance.values().stream()
+				.forEach( annotationValue -> annotationDescriptor.setValue( annotationValue.name(), jandexHelper.convertAnnotationValue( annotationValue ) ) );
+
+		A annotation;
+		try {
+			annotation = AnnotationFactory.create( annotationDescriptor );
+		}
+		catch (RuntimeException e) {
+			throw LOG.getUnableToCreateAnnotationForConfiguredConstraintException( e );
+		}
+		return annotation;
+	}
+
+	private Stream<AnnotationInstance> findConstrainAnnotations(Collection<AnnotationInstance> allAnnotations) {
+		return allAnnotations.stream().filter( this::isConstraintAnnotation );
+	}
+
+	private boolean isConstraintAnnotation(AnnotationInstance annotationInstance) {
+		return constraintAnnotations.contains( annotationInstance.name() );
+	}
+
+	private <A extends Annotation> MetaConstraint<?> createTypeArgumentMetaConstraint(
+			ConstraintLocation location,
+			ConstraintDescriptorImpl<A> descriptor,
+			java.lang.reflect.Type type
+	) {
+		// TODO Jandex: we need a new way to build the type argument constraint location
+		return new MetaConstraint<>( descriptor, ConstraintLocation.forTypeArgument( location, null, type ) );
+	}
+
+	private <A extends Annotation> ConstraintDescriptorImpl<A> buildConstraintDescriptor(
+			Member member,
+			A annotation,
+			ElementType type) {
+		return new ConstraintDescriptorImpl<>(
+				constraintHelper,
+				member,
+				annotation,
+				type
+		);
+	}
+
+	/**
+	 * TODO: this method was directly copied from AnnotationMetaDataProvider, we will need to refactor this but it's
+	 * better to wait for the dust to settle a bit
+	 */
+	protected List<TypeVariable<?>> getCascadingTypeParameters(TypeVariable<?>[] typeParameters, AnnotatedType annotatedType) {
+		List<TypeVariable<?>> cascadingTypeParameters = new ArrayList<>();
+
+		if ( annotatedType instanceof AnnotatedParameterizedType ) {
+			AnnotatedParameterizedType annotatedParameterizedType = (AnnotatedParameterizedType) annotatedType;
+			AnnotatedType[] annotatedTypeArguments = annotatedParameterizedType.getAnnotatedActualTypeArguments();
+
+			int i = 0;
+
+			for ( AnnotatedType annotatedTypeArgument : annotatedTypeArguments ) {
+				if ( annotatedTypeArgument.isAnnotationPresent( Valid.class ) ) {
+					cascadingTypeParameters.add( typeParameters[i] );
+				}
+				i++;
+			}
+		}
+
+		return cascadingTypeParameters;
+	}
+
+	/**
+	 * Simple POJO that contains constraint information common to all elements.
+	 */
+	protected static class CommonConstraintInformation {
+
+		private Map<Class<?>, Class<?>> groupConversions;
+		private boolean isCascading;
+		private UnwrapMode unwrapMode;
+
+		public CommonConstraintInformation() {
+			this.groupConversions = Collections.emptyMap();
+			this.isCascading = false;
+			this.unwrapMode = UnwrapMode.AUTOMATIC;
+		}
+
+		public CommonConstraintInformation(Map<Class<?>, Class<?>> groupConversions, boolean isCascading, UnwrapMode unwrapMode) {
+			this.groupConversions = groupConversions;
+			this.isCascading = isCascading;
+			this.unwrapMode = unwrapMode;
+		}
+
+		public Map<Class<?>, Class<?>> getGroupConversions() {
+			return groupConversions;
+		}
+
+		public boolean isCascading() {
+			return isCascading;
+		}
+
+		public UnwrapMode getUnwrapMode() {
+			return unwrapMode;
+		}
+	}
+
+	/**
+	 * Contains general information about {@link Member}.
+	 */
+	protected static class MemberInformation {
+
+		private Type type;
+		private String name;
+		private Member member;
+		private Class<?> beanClass;
+		private ConstraintLocation constraintLocation;
+
+		public MemberInformation(Type type, String name, Member member,ConstraintLocation constraintLocation, Class<?> beanClass) {
+			this.type = type;
+			this.name = name;
+			this.member = member;
+			this.beanClass = beanClass;
+			this.constraintLocation = constraintLocation;
+		}
+
+		public Type getType() {
+			return type;
+		}
+
+		public String getName() {
+			return name;
+		}
+
+		public Member getMember() {
+			return member;
+		}
+
+		public Class<?> getBeanClass() {
+			return beanClass;
+		}
+
+		public ConstraintLocation getConstraintLocation() {
+			return constraintLocation;
+		}
+	}
+
+}
diff --git a/engine/src/main/java/org/hibernate/validator/internal/metadata/jandex/ClassConstraintsJandexBuilder.java b/engine/src/main/java/org/hibernate/validator/internal/metadata/jandex/ClassConstraintsJandexBuilder.java
new file mode 100644
index 0000000000..4698150fa6
--- /dev/null
+++ b/engine/src/main/java/org/hibernate/validator/internal/metadata/jandex/ClassConstraintsJandexBuilder.java
@@ -0,0 +1,62 @@
+/*
+ * Hibernate Validator, declare and validate application constraints
+ *
+ * License: Apache License, Version 2.0
+ * See the license.txt file in the root directory or <http://www.apache.org/licenses/LICENSE-2.0>.
+ */
+package org.hibernate.validator.internal.metadata.jandex;
+
+import java.lang.annotation.Annotation;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.hibernate.validator.internal.metadata.core.AnnotationProcessingOptions;
+import org.hibernate.validator.internal.metadata.core.ConstraintHelper;
+import org.hibernate.validator.internal.metadata.core.MetaConstraint;
+import org.hibernate.validator.internal.metadata.descriptor.ConstraintDescriptorImpl;
+import org.hibernate.validator.internal.metadata.jandex.util.JandexHelper;
+import org.hibernate.validator.internal.metadata.location.ConstraintLocation;
+import org.hibernate.validator.internal.metadata.raw.ConfigurationSource;
+import org.hibernate.validator.internal.metadata.raw.ConstrainedElement;
+import org.hibernate.validator.internal.metadata.raw.ConstrainedType;
+import org.jboss.jandex.AnnotationInstance;
+import org.jboss.jandex.ClassInfo;
+import org.jboss.jandex.DotName;
+
+/**
+ * Builder used to extract class constraints from the Jandex index.
+ *
+ * @author Marko Bekhta
+ * @author Guillaume Smet
+ */
+public class ClassConstraintsJandexBuilder extends AbstractConstrainedElementJandexBuilder {
+
+	public ClassConstraintsJandexBuilder(ConstraintHelper constraintHelper, JandexHelper jandexHelper, AnnotationProcessingOptions annotationProcessingOptions,
+			List<DotName> constraintAnnotations) {
+		super( constraintHelper, jandexHelper, annotationProcessingOptions, constraintAnnotations );
+	}
+
+	public Stream<ConstrainedElement> getClassConstraints(ClassInfo classInfo, Class<?> beanClass) {
+		if ( annotationProcessingOptions.areClassLevelConstraintsIgnoredFor( beanClass ) ) {
+			return Stream.empty();
+		}
+
+		return Stream.of( new ConstrainedType(
+				ConfigurationSource.JANDEX,
+				beanClass,
+				findMetaConstraints( classInfo.classAnnotations(), beanClass ).collect( Collectors.toSet() )
+		) );
+	}
+
+	private Stream<MetaConstraint<?>> findMetaConstraints(Collection<AnnotationInstance> annotationInstances, Class<?> beanClass) {
+		return findConstraints( annotationInstances, null )
+				.map( descriptor -> createMetaConstraint( beanClass, descriptor ) );
+	}
+
+	private <A extends Annotation> MetaConstraint<?> createMetaConstraint(Class<?> declaringClass, ConstraintDescriptorImpl<A> descriptor) {
+		return new MetaConstraint<>( descriptor, ConstraintLocation.forClass( declaringClass ) );
+	}
+
+}
diff --git a/engine/src/main/java/org/hibernate/validator/internal/metadata/jandex/ConstrainedFieldJandexBuilder.java b/engine/src/main/java/org/hibernate/validator/internal/metadata/jandex/ConstrainedFieldJandexBuilder.java
new file mode 100644
index 0000000000..fac880bf01
--- /dev/null
+++ b/engine/src/main/java/org/hibernate/validator/internal/metadata/jandex/ConstrainedFieldJandexBuilder.java
@@ -0,0 +1,124 @@
+/*
+ * Hibernate Validator, declare and validate application constraints
+ *
+ * License: Apache License, Version 2.0
+ * See the license.txt file in the root directory or <http://www.apache.org/licenses/LICENSE-2.0>.
+ */
+package org.hibernate.validator.internal.metadata.jandex;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.AnnotatedType;
+import java.lang.reflect.Field;
+import java.lang.reflect.TypeVariable;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import javax.validation.Valid;
+
+import org.hibernate.validator.internal.engine.cascading.AnnotatedObject;
+import org.hibernate.validator.internal.engine.cascading.ArrayElement;
+import org.hibernate.validator.internal.metadata.core.AnnotationProcessingOptions;
+import org.hibernate.validator.internal.metadata.core.ConstraintHelper;
+import org.hibernate.validator.internal.metadata.core.MetaConstraint;
+import org.hibernate.validator.internal.metadata.descriptor.ConstraintDescriptorImpl;
+import org.hibernate.validator.internal.metadata.jandex.util.JandexHelper;
+import org.hibernate.validator.internal.metadata.location.ConstraintLocation;
+import org.hibernate.validator.internal.metadata.raw.ConfigurationSource;
+import org.hibernate.validator.internal.metadata.raw.ConstrainedElement;
+import org.hibernate.validator.internal.metadata.raw.ConstrainedField;
+import org.jboss.jandex.AnnotationInstance;
+import org.jboss.jandex.ClassInfo;
+import org.jboss.jandex.DotName;
+import org.jboss.jandex.FieldInfo;
+
+/**
+ * Builder used to extract field constraints from the Jandex index.
+ *
+ * @author Marko Bekhta
+ * @author Guillaume Smet
+ */
+public class ConstrainedFieldJandexBuilder extends AbstractConstrainedElementJandexBuilder {
+
+	public ConstrainedFieldJandexBuilder(ConstraintHelper constraintHelper, JandexHelper jandexHelper,
+			AnnotationProcessingOptions annotationProcessingOptions, List<DotName> constraintAnnotations) {
+		super( constraintHelper, jandexHelper, annotationProcessingOptions, constraintAnnotations );
+	}
+
+	public Stream<ConstrainedElement> getConstrainedFields(ClassInfo classInfo, Class<?> beanClass) {
+		return classInfo.fields().stream()
+				.map( fieldInfo -> toConstrainedField( beanClass, fieldInfo ) );
+	}
+
+	private ConstrainedField toConstrainedField(Class<?> beanClass, FieldInfo fieldInfo) {
+		Field field = findField( beanClass, fieldInfo );
+		Set<MetaConstraint<?>> constraints = findMetaConstraints( fieldInfo.annotations(), field ).collect( Collectors.toSet() );
+
+		boolean isCascading = jandexHelper.isCascading( fieldInfo.annotations() );
+		Set<MetaConstraint<?>> typeArgumentsConstraints = findTypeAnnotationConstraintsForMember(
+				new MemberInformation(
+						fieldInfo.type(),
+						fieldInfo.name(),
+						field,
+						ConstraintLocation.forProperty( field ),
+						beanClass
+				),
+				isCascading
+		).collect( Collectors.toSet() );
+
+		CommonConstraintInformation commonInformation = findCommonConstraintInformation(
+				fieldInfo.type(),
+				fieldInfo.annotations(),
+				!typeArgumentsConstraints.isEmpty(),
+				isCascading
+		);
+
+		return new ConstrainedField(
+				ConfigurationSource.JANDEX,
+				field,
+				constraints,
+				typeArgumentsConstraints,
+				commonInformation.getGroupConversions(),
+				findCascadingTypeParameters( field ),
+				commonInformation.getUnwrapMode()
+		);
+	}
+
+	private Stream<MetaConstraint<?>> findMetaConstraints(Collection<AnnotationInstance> annotationInstances, Field field) {
+		return findConstraints( annotationInstances, field )
+				.map( descriptor -> createMetaConstraint( field, descriptor ) );
+	}
+
+	private Field findField(Class<?> beanClass, FieldInfo fieldInfo) {
+		try {
+			return beanClass.getDeclaredField( fieldInfo.name() );
+		}
+		catch (NoSuchFieldException e) {
+			throw LOG.getUnableToFindFieldReferencedInJandexIndex( beanClass, fieldInfo.name().toString(), e );
+		}
+	}
+
+	private <A extends Annotation> MetaConstraint<?> createMetaConstraint(Field member, ConstraintDescriptorImpl<A> descriptor) {
+		return new MetaConstraint<>( descriptor, ConstraintLocation.forProperty( member ) );
+	}
+
+	/**
+	 * TODO: this method was directly copied from AnnotationMetaDataProvider, we will need to refactor this but it's
+	 * better to wait for the dust to settle a bit
+	 */
+	private List<TypeVariable<?>> findCascadingTypeParameters(Field field) {
+		TypeVariable<?>[] typeParameters = field.getType().getTypeParameters();
+		AnnotatedType annotatedType = field.getAnnotatedType();
+
+		List<TypeVariable<?>> cascadingTypeParameters = getCascadingTypeParameters( typeParameters, annotatedType );
+
+		if ( field.isAnnotationPresent( Valid.class ) ) {
+			cascadingTypeParameters.add( field.getType().isArray() ? ArrayElement.INSTANCE : AnnotatedObject.INSTANCE );
+		}
+
+		return cascadingTypeParameters;
+	}
+
+}
diff --git a/engine/src/main/java/org/hibernate/validator/internal/metadata/jandex/ConstrainedMethodJandexBuilder.java b/engine/src/main/java/org/hibernate/validator/internal/metadata/jandex/ConstrainedMethodJandexBuilder.java
new file mode 100644
index 0000000000..9d04c21f7a
--- /dev/null
+++ b/engine/src/main/java/org/hibernate/validator/internal/metadata/jandex/ConstrainedMethodJandexBuilder.java
@@ -0,0 +1,323 @@
+/*
+ * Hibernate Validator, declare and validate application constraints
+ *
+ * License: Apache License, Version 2.0
+ * See the license.txt file in the root directory or <http://www.apache.org/licenses/LICENSE-2.0>.
+ */
+package org.hibernate.validator.internal.metadata.jandex;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.AnnotatedType;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Executable;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.TypeVariable;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import javax.validation.Valid;
+
+import org.hibernate.validator.internal.engine.cascading.AnnotatedObject;
+import org.hibernate.validator.internal.engine.cascading.ArrayElement;
+import org.hibernate.validator.internal.metadata.core.AnnotationProcessingOptions;
+import org.hibernate.validator.internal.metadata.core.ConstraintHelper;
+import org.hibernate.validator.internal.metadata.core.MetaConstraint;
+import org.hibernate.validator.internal.metadata.descriptor.ConstraintDescriptorImpl;
+import org.hibernate.validator.internal.metadata.jandex.util.JandexHelper;
+import org.hibernate.validator.internal.metadata.location.ConstraintLocation;
+import org.hibernate.validator.internal.metadata.raw.ConfigurationSource;
+import org.hibernate.validator.internal.metadata.raw.ConstrainedElement;
+import org.hibernate.validator.internal.metadata.raw.ConstrainedExecutable;
+import org.hibernate.validator.internal.metadata.raw.ConstrainedParameter;
+import org.hibernate.validator.internal.util.CollectionHelper;
+import org.hibernate.validator.internal.util.ExecutableParameterNameProvider;
+import org.jboss.jandex.AnnotationInstance;
+import org.jboss.jandex.ClassInfo;
+import org.jboss.jandex.DotName;
+import org.jboss.jandex.MethodInfo;
+import org.jboss.jandex.Type;
+
+/**
+ * Builder used to extract builder and method constraints from the Jandex index.
+ *
+ * @author Marko Bekhta
+ * @author Guillaume Smet
+ */
+public class ConstrainedMethodJandexBuilder extends AbstractConstrainedElementJandexBuilder {
+
+	private static final int SYNTHETIC = 0x1000;
+	private static final int BRIDGE = 0x0040;
+
+	protected final ExecutableParameterNameProvider parameterNameProvider;
+
+	public ConstrainedMethodJandexBuilder(ConstraintHelper constraintHelper, JandexHelper jandexHelper,
+			AnnotationProcessingOptions annotationProcessingOptions, ExecutableParameterNameProvider parameterNameProvider,
+			List<DotName> constraintAnnotations) {
+		super( constraintHelper, jandexHelper, annotationProcessingOptions, constraintAnnotations );
+		this.parameterNameProvider = parameterNameProvider;
+	}
+
+	public Stream<ConstrainedElement> getConstrainedExecutables(ClassInfo classInfo, Class<?> beanClass) {
+		// HV-172; ignoring synthetic methods (inserted by the compiler), as they can't have any constraints
+		// anyway and possibly hide the actual method with the same signature in the built meta model
+
+		return classInfo.methods().stream()
+				.filter( methodInfo -> !Modifier.isStatic( methodInfo.flags() ) && !isSynthetic( methodInfo ) )
+				.map( methodInfo -> toConstrainedExecutable( beanClass, methodInfo ) );
+	}
+
+	private ConstrainedExecutable toConstrainedExecutable(Class<?> beanClass, MethodInfo methodInfo) {
+		Executable executable = findExecutable( beanClass, methodInfo );
+
+		Stream<ConstrainedParameter> parameterConstraints = getParameterMetaData( beanClass, executable, methodInfo );
+
+		Set<MetaConstraint<?>> crossParameterConstraints;
+		Map<ConstraintDescriptorImpl.ConstraintType, Set<MetaConstraint<?>>> executableConstraints =
+				findMetaConstraints( methodInfo.annotations(), executable )
+						.collect( Collectors.groupingBy( constraint -> constraint.getDescriptor().getConstraintType(), Collectors.toSet() ) );
+
+		if ( annotationProcessingOptions.areCrossParameterConstraintsIgnoredFor( executable ) ) {
+			crossParameterConstraints = Collections.emptySet();
+		}
+		else {
+			crossParameterConstraints = executableConstraints.containsKey( ConstraintDescriptorImpl.ConstraintType.CROSS_PARAMETER ) ?
+					executableConstraints.get( ConstraintDescriptorImpl.ConstraintType.CROSS_PARAMETER ) :
+					Collections.emptySet();
+		}
+
+		Set<MetaConstraint<?>> returnValueConstraints;
+		Set<MetaConstraint<?>> typeArgumentsConstraints;
+		CommonConstraintInformation commonInformation;
+		if ( annotationProcessingOptions.areReturnValueConstraintsIgnoredFor( executable ) || Type.Kind.VOID.equals( methodInfo.returnType().kind() ) ) {
+			returnValueConstraints = Collections.emptySet();
+			typeArgumentsConstraints = Collections.emptySet();
+			commonInformation = new CommonConstraintInformation();
+		}
+		else {
+			// check for any constraints on return type only if it is not void
+			boolean isCascading = jandexHelper.isCascading( methodInfo.annotations() );
+			typeArgumentsConstraints = findTypeAnnotationConstraintsForMember(
+					new MemberInformation(
+							methodInfo.returnType(),
+							methodInfo.name(),
+							executable,
+							ConstraintLocation.forReturnValue( executable ),
+							beanClass
+					),
+					isCascading
+			).collect( Collectors.toSet() );
+
+			commonInformation = findCommonConstraintInformation(
+					methodInfo.returnType(),
+					methodInfo.annotations(),
+					!typeArgumentsConstraints.isEmpty(),
+					isCascading
+			);
+
+			returnValueConstraints = executableConstraints.containsKey( ConstraintDescriptorImpl.ConstraintType.GENERIC ) ?
+					executableConstraints.get( ConstraintDescriptorImpl.ConstraintType.GENERIC ) :
+					Collections.emptySet();
+		}
+
+		return new ConstrainedExecutable(
+				ConfigurationSource.JANDEX,
+				executable,
+				parameterConstraints.collect( Collectors.toList() ),
+				crossParameterConstraints,
+				returnValueConstraints,
+				typeArgumentsConstraints,
+				commonInformation.getGroupConversions(),
+				findCascadingTypeParameters( executable ),
+				commonInformation.getUnwrapMode()
+		);
+	}
+
+	private Stream<ConstrainedParameter> getParameterMetaData(Class<?> beanClass, Executable executable, MethodInfo methodInfo) {
+		if ( methodInfo.parameters().isEmpty() ) {
+			return Stream.empty();
+		}
+
+		//TODO: maybe parameter name provide can be changed and not use executable ?
+		List<String> parameterNames = parameterNameProvider.getParameterNames( executable );
+
+		List<ParameterInformation> parameters = CollectionHelper.newArrayList();
+		for ( int i = 0; i < parameterNames.size(); i++ ) {
+			parameters.add( new ParameterInformation( parameterNames.get( i ), i, methodInfo.parameters().get( i ), beanClass ) );
+		}
+
+		return parameters.stream()
+				.map( parameterInformation -> toConstrainedParameter( parameterInformation, executable ) );
+	}
+
+	private ConstrainedParameter toConstrainedParameter(ParameterInformation parameterInformation, Executable executable) {
+			CommonConstraintInformation commonInformation;
+			Stream<MetaConstraint<?>> parameterConstraints;
+			Set<MetaConstraint<?>> typeArgumentsConstraints;
+			Class<?> parameterType = jandexHelper.getClassForName( parameterInformation.getType().name() );
+
+		if ( annotationProcessingOptions.areParameterConstraintsIgnoredFor( executable, parameterInformation.getIndex() ) ) {
+			parameterConstraints = Stream.empty();
+			typeArgumentsConstraints = Collections.emptySet();
+			commonInformation = new CommonConstraintInformation();
+		}
+		else {
+			boolean isCascading = jandexHelper.isCascading( parameterInformation.getType().annotations() );
+			typeArgumentsConstraints = findTypeAnnotationConstraintsForMember(
+					new MemberInformation(
+							parameterInformation.getType(),
+							parameterInformation.getName(),
+							executable,
+							ConstraintLocation.forParameter( executable, parameterInformation.getIndex() ),
+							parameterInformation.getBeanClass()
+					),
+					isCascading
+			).collect( Collectors.toSet() );
+
+			commonInformation = findCommonConstraintInformation(
+					parameterInformation.getType(),
+					parameterInformation.getType().annotations(),
+					!typeArgumentsConstraints.isEmpty(),
+					isCascading
+			);
+
+			parameterConstraints = findMetaConstraints( parameterInformation, executable );
+		}
+
+		return new ConstrainedParameter(
+				ConfigurationSource.JANDEX,
+				executable,
+				parameterType,
+				parameterInformation.getIndex(),
+				parameterInformation.getName(),
+				parameterConstraints.collect( Collectors.toSet() ),
+				typeArgumentsConstraints,
+				commonInformation.getGroupConversions(),
+				findCascadingTypeParameters( executable ),
+				commonInformation.getUnwrapMode()
+		);
+	}
+
+	private Stream<MetaConstraint<?>> findMetaConstraints(Collection<AnnotationInstance> annotationInstances, Executable executable) {
+		return findConstraints( annotationInstances, executable )
+				.map( descriptor -> createMetaConstraint( executable, descriptor ) );
+	}
+
+	private Stream<MetaConstraint<?>> findMetaConstraints(ParameterInformation parameterInformation, Executable executable) {
+		return findConstraints( parameterInformation.getType().annotations(), executable )
+				.map( descriptor -> createMetaConstraint( executable, parameterInformation.getIndex(), descriptor ) );
+	}
+
+	private Executable findExecutable(Class<?> beanClass, MethodInfo methodInfo) {
+		try {
+			if ( isConstructor( methodInfo ) ) {
+				return beanClass.getDeclaredConstructor( methodInfo.parameters().stream()
+						.map( type -> jandexHelper.getClassForName( type.name() ) )
+						.toArray( size -> new Class<?>[size] ) );
+			}
+			else {
+				return beanClass.getDeclaredMethod(
+						methodInfo.name(),
+						methodInfo.parameters().stream()
+								.map( type -> jandexHelper.getClassForName( type.name() ) )
+								.toArray( size -> new Class<?>[size] )
+				);
+			}
+		}
+		catch (NoSuchMethodException e) {
+			// TODO add the parameter information to the log. It would probably be nice if Jandex could expose a method for that.
+			throw LOG.getUnableToFindMethodReferencedInJandexIndex( beanClass, methodInfo.name(), e );
+		}
+	}
+
+	private <A extends Annotation> MetaConstraint<A> createMetaConstraint(Executable member, ConstraintDescriptorImpl<A> descriptor) {
+		return new MetaConstraint<>(
+				descriptor,
+				ConstraintDescriptorImpl.ConstraintType.GENERIC.equals( descriptor.getConstraintType() ) ?
+						ConstraintLocation.forReturnValue( member ) : ConstraintLocation.forCrossParameter( member )
+		);
+	}
+
+	private <A extends Annotation> MetaConstraint<A> createMetaConstraint(Executable member, int parameterIndex, ConstraintDescriptorImpl<A> descriptor) {
+		return new MetaConstraint<>(
+				descriptor,
+				ConstraintLocation.forParameter( member, parameterIndex )
+		);
+	}
+
+	private boolean isConstructor(MethodInfo methodInfo) {
+		// currently, Jandex does not expose this in a practical way
+		return "<init>".equals( methodInfo.name() );
+	}
+
+	private boolean isSynthetic(MethodInfo methodInfo) {
+		// currently, Jandex does not expose this in a practical way
+		return ( methodInfo.flags() & ( SYNTHETIC | BRIDGE ) ) != 0;
+	}
+
+	/**
+	 * TODO: this method was directly copied from AnnotationMetaDataProvider, we will need to refactor this but it's
+	 * better to wait for the dust to settle a bit
+	 */
+	private List<TypeVariable<?>> findCascadingTypeParameters(Executable executable) {
+		boolean isArray;
+		TypeVariable<?>[] typeParameters;
+
+		if ( executable instanceof Method ) {
+			isArray =  ( (Method) executable ).getReturnType().isArray();
+			typeParameters = ( (Method) executable ).getReturnType().getTypeParameters();
+		}
+		else {
+			isArray = false;
+			typeParameters = ( (Constructor<?>) executable ).getDeclaringClass().getTypeParameters();
+		}
+		AnnotatedType annotatedType = executable.getAnnotatedReturnType();
+
+		List<TypeVariable<?>> cascadingTypeParameters = getCascadingTypeParameters( typeParameters, annotatedType );
+
+		if ( executable.isAnnotationPresent( Valid.class ) ) {
+			cascadingTypeParameters.add( isArray ? ArrayElement.INSTANCE : AnnotatedObject.INSTANCE );
+		}
+
+		return cascadingTypeParameters;
+	}
+
+	/**
+	 * Simple POJO that contains {@link Type}, name and index of a method parameter.
+	 */
+	private static class ParameterInformation {
+
+		private String name;
+		private int index;
+		private Type type;
+		private Class<?> beanClass;
+
+		public ParameterInformation(String name, int index, Type type, Class<?> beanClass) {
+			this.name = name;
+			this.index = index;
+			this.type = type;
+			this.beanClass = beanClass;
+		}
+
+		public String getName() {
+			return name;
+		}
+
+		public int getIndex() {
+			return index;
+		}
+
+		public Type getType() {
+			return type;
+		}
+
+		public Class<?> getBeanClass() {
+			return beanClass;
+		}
+	}
+}
diff --git a/engine/src/main/java/org/hibernate/validator/internal/metadata/jandex/util/JandexHelper.java b/engine/src/main/java/org/hibernate/validator/internal/metadata/jandex/util/JandexHelper.java
new file mode 100644
index 0000000000..57b1dd9703
--- /dev/null
+++ b/engine/src/main/java/org/hibernate/validator/internal/metadata/jandex/util/JandexHelper.java
@@ -0,0 +1,139 @@
+/*
+ * Hibernate Validator, declare and validate application constraints
+ *
+ * License: Apache License, Version 2.0
+ * See the license.txt file in the root directory or <http://www.apache.org/licenses/LICENSE-2.0>.
+ */
+package org.hibernate.validator.internal.metadata.jandex.util;
+
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Optional;
+
+import javax.validation.Valid;
+import javax.validation.ValidationException;
+
+import org.hibernate.validator.HibernateValidator;
+import org.hibernate.validator.internal.util.ReflectionHelper;
+import org.hibernate.validator.internal.util.annotationfactory.AnnotationDescriptor;
+import org.hibernate.validator.internal.util.logging.Log;
+import org.hibernate.validator.internal.util.logging.LoggerFactory;
+import org.hibernate.validator.internal.util.privilegedactions.LoadClass;
+import org.jboss.jandex.AnnotationInstance;
+import org.jboss.jandex.AnnotationValue;
+import org.jboss.jandex.DotName;
+import org.jboss.jandex.Type;
+
+/**
+ * Utility methods used for Jandex metadata retrieval.
+ *
+ * @author Marko Bekhta
+ * @author Guillaume Smet
+ */
+public final class JandexHelper {
+
+	private static final Log LOG = LoggerFactory.make();
+
+	private final ClassLoader classLoader;
+
+	public JandexHelper(ClassLoader classLoader) {
+		this.classLoader = classLoader;
+	}
+
+	public JandexHelper() {
+		this( HibernateValidator.class.getClassLoader() );
+	}
+
+	/**
+	 * Returns a class ({@link Class}) for a given class {@link DotName}.
+	 */
+	public Class<?> getClassForName(DotName className) {
+		// TODO: change how class are loaded (from GM: Using this one without passing a classloader may give us trouble due to classes not being visible to
+		// the implicitly used loader. You can check out org.hibernate.validator.internal.util.privilegedactions.LoadClass and its usage as a starting point.
+		try {
+			return run( LoadClass.action( className.toString(), classLoader, true ) );
+		}
+		catch (ValidationException e) {
+			throw LOG.getUnableToFindClassReferencedInJandexIndex( className.toString(), e );
+		}
+	}
+
+	/**
+	 * Indicates if the type is considered indexable (ie is an {@link Iterable}, an array or a {@link Map}).
+	 *
+	 * @param type the type to inspect.
+	 * @return Returns {@code true} if the type is indexable.
+	 */
+	public boolean isIndexable(Type type) {
+		// TODO: Can this property be somehow determined from a type parameter and without converting it to a class ???
+		return ReflectionHelper.isIndexable( getClassForName( type.name() ) );
+	}
+
+	/**
+	 * Checks if given type is a {@link Map} implementation.
+	 *
+	 * @param type a type to check
+	 * @return {@code true} if given type is an implementation of a {@link Map}, {@code false} otherwise
+	 */
+	public boolean isMap(Type type) {
+		// TODO: Can this property be somehow determined from a type parameter and without converting it to a class ???
+		return ReflectionHelper.isMap( getClassForName( type.name() ) );
+	}
+
+	/**
+	 * Checks if given type is an {@link Iterable} implementation.
+	 *
+	 * @param type a type to check
+	 * @return {@code true} if given type is an implementation of an {@link Iterable}, {@code false} otherwise
+	 */
+	public boolean isIterable(Type type) {
+		// TODO: Can this property be somehow determined from a type parameter and without converting it to a class ???
+		return ReflectionHelper.isIterable( getClassForName( type.name() ) );
+	}
+
+	/**
+	 * Finds an annotation of a given type inside the provided collection of annotations.
+	 */
+	public Optional<AnnotationInstance> findAnnotation(Collection<AnnotationInstance> annotations, Class<?> clazz) {
+		return annotations.stream()
+				.filter( annotation -> annotation.name().toString().equals( clazz.getName() ) )
+				.findAny();
+	}
+
+	/**
+	 * Converts the {@link AnnotationValue} to a value usable by an {@link AnnotationDescriptor}.
+	 */
+	public Object convertAnnotationValue(AnnotationValue annotationValue) {
+		if ( AnnotationValue.Kind.ARRAY.equals( annotationValue.kind() ) ) {
+			if ( AnnotationValue.Kind.CLASS.equals( annotationValue.componentKind() ) ) {
+				return Arrays.stream( annotationValue.asClassArray() )
+						.map( type -> getClassForName( type.name() ) )
+						.toArray( size -> new Class[size] );
+			}
+		}
+		else if ( AnnotationValue.Kind.CLASS.equals( annotationValue.kind() ) ) {
+			return getClassForName( annotationValue.asClass().name() );
+		}
+		return annotationValue.value();
+	}
+
+	/**
+	 * Checks if there's a {@link Valid} annotation present in the collection.
+	 */
+	public boolean isCascading(Collection<AnnotationInstance> annotations) {
+		return findAnnotation( annotations, Valid.class ).isPresent();
+	}
+
+	/**
+	 * Runs the given privileged action, using a privileged block if required.
+	 * <p>
+	 * <b>NOTE:</b> This must never be changed into a publicly available method to avoid execution of arbitrary
+	 * privileged actions within HV's protection domain.
+	 */
+	private static <T> T run(PrivilegedAction<T> action) {
+		return System.getSecurityManager() != null ? AccessController.doPrivileged( action ) : action.run();
+	}
+}
diff --git a/engine/src/main/java/org/hibernate/validator/internal/metadata/provider/JandexMetaDataProvider.java b/engine/src/main/java/org/hibernate/validator/internal/metadata/provider/JandexMetaDataProvider.java
new file mode 100644
index 0000000000..8c96b5d256
--- /dev/null
+++ b/engine/src/main/java/org/hibernate/validator/internal/metadata/provider/JandexMetaDataProvider.java
@@ -0,0 +1,268 @@
+/*
+ * Hibernate Validator, declare and validate application constraints
+ *
+ * License: Apache License, Version 2.0
+ * See the license.txt file in the root directory or <http://www.apache.org/licenses/LICENSE-2.0>.
+ */
+package org.hibernate.validator.internal.metadata.provider;
+
+import static org.hibernate.validator.internal.util.CollectionHelper.newArrayList;
+
+import java.lang.reflect.Method;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import javax.validation.Constraint;
+import javax.validation.GroupSequence;
+
+import org.hibernate.validator.group.GroupSequenceProvider;
+import org.hibernate.validator.internal.metadata.core.AnnotationProcessingOptions;
+import org.hibernate.validator.internal.metadata.core.ConstraintHelper;
+import org.hibernate.validator.internal.metadata.jandex.ClassConstraintsJandexBuilder;
+import org.hibernate.validator.internal.metadata.jandex.ConstrainedFieldJandexBuilder;
+import org.hibernate.validator.internal.metadata.jandex.ConstrainedMethodJandexBuilder;
+import org.hibernate.validator.internal.metadata.jandex.util.JandexHelper;
+import org.hibernate.validator.internal.metadata.raw.BeanConfiguration;
+import org.hibernate.validator.internal.metadata.raw.ConfigurationSource;
+import org.hibernate.validator.internal.metadata.raw.ConstrainedElement;
+import org.hibernate.validator.internal.util.Contracts;
+import org.hibernate.validator.internal.util.ExecutableParameterNameProvider;
+import org.hibernate.validator.internal.util.classhierarchy.ClassHierarchyHelper;
+import org.hibernate.validator.internal.util.logging.Log;
+import org.hibernate.validator.internal.util.logging.LoggerFactory;
+import org.hibernate.validator.internal.util.privilegedactions.GetMethods;
+import org.hibernate.validator.internal.util.privilegedactions.NewInstance;
+import org.hibernate.validator.spi.group.DefaultGroupSequenceProvider;
+import org.jboss.jandex.AnnotationInstance;
+import org.jboss.jandex.AnnotationTarget;
+import org.jboss.jandex.AnnotationTarget.Kind;
+import org.jboss.jandex.ClassInfo;
+import org.jboss.jandex.DotName;
+import org.jboss.jandex.IndexView;
+
+/**
+ * {@code MetaDataProvider} which reads the metadata from a Jandex index.
+ *
+ * @author Marko Bekhta
+ * @author Guillaume Smet
+ */
+public class JandexMetaDataProvider implements MetaDataProvider {
+
+	private static final Log LOG = LoggerFactory.make();
+
+	private static final DotName CONSTRAINT_ANNOTATION = DotName.createSimple( Constraint.class.getName() );
+
+	private final AnnotationProcessingOptions annotationProcessingOptions;
+
+	private final Map<DotName, BeanConfiguration<?>> configuredBeans;
+
+	public JandexMetaDataProvider(
+			ConstraintHelper constraintHelper,
+			JandexHelper jandexHelper,
+			IndexView indexView,
+			AnnotationProcessingOptions annotationProcessingOptions,
+			ExecutableParameterNameProvider parameterNameProvider) {
+		this.annotationProcessingOptions = annotationProcessingOptions;
+
+		List<DotName> constraintAnnotations = Collections.unmodifiableList( extractConstraintAnnotations( indexView ) );
+
+		this.configuredBeans = Collections.unmodifiableMap( extractConfiguredBeans( indexView,
+				constraintHelper, jandexHelper,
+				annotationProcessingOptions, parameterNameProvider,
+				constraintAnnotations ) );
+	}
+
+	private static List<DotName> extractConstraintAnnotations(IndexView indexView) {
+		return indexView.getAnnotations( CONSTRAINT_ANNOTATION ).stream()
+				.filter( ai -> Kind.CLASS.equals( ai.target().kind() ) )
+				.map( ai -> ai.target().asClass().name() )
+				.collect( Collectors.toList() );
+	}
+
+	private static Map<DotName, BeanConfiguration<?>> extractConfiguredBeans(IndexView indexView, ConstraintHelper constraintHelper, JandexHelper jandexHelper,
+			AnnotationProcessingOptions annotationProcessingOptions, ExecutableParameterNameProvider parameterNameProvider, List<DotName> constraintAnnotations) {
+		return findConstrainedBeans( indexView, constraintAnnotations ).stream()
+				.collect( Collectors.toMap(
+						classInfo -> classInfo.name(),
+						classInfo -> getBeanConfiguration(
+								constraintHelper,
+								jandexHelper,
+								classInfo,
+								annotationProcessingOptions,
+								parameterNameProvider,
+								constraintAnnotations
+						)
+				) );
+	}
+
+	private static Set<ClassInfo> findConstrainedBeans(IndexView indexView, List<DotName> constraintAnnotations) {
+		// TODO HV-644: not sure this is totally accurate. I'm especially wondering how it will behave with subclasses and such.
+		Set<ClassInfo> constrainedBeans = new HashSet<>();
+		for ( DotName constraintAnnotation : constraintAnnotations ) {
+			constrainedBeans.addAll( indexView.getAnnotations( constraintAnnotation ).stream()
+					.map( ai -> ai.target() )
+					.map( JandexMetaDataProvider::annotationInstanceToClassInfo )
+					.collect( Collectors.toSet() ) );
+		}
+		return constrainedBeans;
+	}
+
+	private static ClassInfo annotationInstanceToClassInfo(AnnotationTarget target) {
+		ClassInfo classInfo;
+		switch ( target.kind() ) {
+			case CLASS:
+				classInfo = target.asClass();
+				break;
+			case FIELD:
+				classInfo = target.asField().declaringClass();
+				break;
+			case METHOD:
+				classInfo = target.asMethod().declaringClass();
+				break;
+			case METHOD_PARAMETER:
+				classInfo = target.asMethodParameter().method().declaringClass();
+				break;
+			case TYPE:
+				classInfo = annotationInstanceToClassInfo( target.asType().enclosingTarget() );
+				break;
+			default:
+				throw new IllegalStateException( target.kind() + " is not supported here." );
+		}
+		return classInfo;
+	}
+
+	private static BeanConfiguration<?> getBeanConfiguration(ConstraintHelper constraintHelper, JandexHelper jandexHelper,
+			ClassInfo classInfo, AnnotationProcessingOptions annotationProcessingOptions, ExecutableParameterNameProvider parameterNameProvider,
+			List<DotName> constraintAnnotations) {
+		Class<?> bean = jandexHelper.getClassForName( classInfo.name() );
+		return new BeanConfiguration<>(
+				ConfigurationSource.JANDEX,
+				bean,
+				getConstrainedElements( constraintHelper, jandexHelper, classInfo, bean, annotationProcessingOptions, parameterNameProvider, constraintAnnotations )
+						.collect( Collectors.toSet() ),
+				getGroupSequence( jandexHelper, classInfo ).collect( Collectors.toList() ),
+				getGroupSequenceProvider( jandexHelper, classInfo )
+		);
+	}
+
+	private static Stream<? extends ConstrainedElement> getConstrainedElements(
+			ConstraintHelper constraintHelper,
+			JandexHelper jandexHelper,
+			ClassInfo classInfo,
+			Class<?> bean,
+			AnnotationProcessingOptions annotationProcessingOptions,
+			ExecutableParameterNameProvider parameterNameProvider,
+			List<DotName> constraintAnnotations
+	) {
+		// get constrained fields
+		Stream<ConstrainedElement> constrainedFieldStream = new ConstrainedFieldJandexBuilder(
+				constraintHelper,
+				jandexHelper,
+				annotationProcessingOptions,
+				constraintAnnotations
+		).getConstrainedFields( classInfo, bean );
+
+		// get constrained methods/constructors
+		Stream<ConstrainedElement> constrainedMethodStream = new ConstrainedMethodJandexBuilder(
+				constraintHelper,
+				jandexHelper,
+				annotationProcessingOptions,
+				parameterNameProvider,
+				constraintAnnotations
+		).getConstrainedExecutables( classInfo, bean );
+
+		// get class level constraints
+		Stream<ConstrainedElement> constrainedClassStream = new ClassConstraintsJandexBuilder(
+				constraintHelper,
+				jandexHelper,
+				annotationProcessingOptions,
+				constraintAnnotations
+		).getClassConstraints( classInfo, bean );
+
+		return Stream.of( constrainedClassStream, constrainedFieldStream, constrainedMethodStream )
+				.reduce( Stream::concat )
+				.orElse( Stream.empty() );
+	}
+
+	@Override
+	public AnnotationProcessingOptions getAnnotationProcessingOptions() {
+		return annotationProcessingOptions;
+	}
+
+	@Override
+	public <T> List<BeanConfiguration<? super T>> getBeanConfigurationForHierarchy(Class<T> beanClass) {
+		List<BeanConfiguration<? super T>> configurations = newArrayList();
+
+		for ( Class<? super T> clazz : ClassHierarchyHelper.getHierarchy( beanClass ) ) {
+			BeanConfiguration<? super T> configuration = getBeanConfiguration( clazz );
+			if ( configuration != null ) {
+				configurations.add( configuration );
+			}
+		}
+
+		return configurations;
+	}
+
+	@SuppressWarnings("unchecked")
+	protected <T> BeanConfiguration<T> getBeanConfiguration(Class<T> beanClass) {
+		Contracts.assertNotNull( beanClass );
+		return (BeanConfiguration<T>) configuredBeans.get( DotName.createSimple( beanClass.getName() ) );
+	}
+
+	private static Stream<Class<?>> getGroupSequence(JandexHelper jandexHelper, ClassInfo classInfo) {
+		Optional<AnnotationInstance> groupSequence = jandexHelper.findAnnotation( classInfo.classAnnotations(), GroupSequence.class );
+		if ( groupSequence.isPresent() ) {
+			return Arrays.stream( (Class<?>[]) jandexHelper.convertAnnotationValue( groupSequence.get().value() ) );
+		}
+		else {
+			return Stream.empty();
+		}
+	}
+
+	@SuppressWarnings("unchecked")
+	private static <T> DefaultGroupSequenceProvider<? super T> getGroupSequenceProvider(JandexHelper jandexHelper, ClassInfo classInfo) {
+		Optional<AnnotationInstance> groupSequenceProvider = jandexHelper.findAnnotation( classInfo.classAnnotations(), GroupSequenceProvider.class );
+		if ( groupSequenceProvider.isPresent() ) {
+			Class<? extends DefaultGroupSequenceProvider<? super T>> providerClass =
+					(Class<? extends DefaultGroupSequenceProvider<? super T>>) jandexHelper.convertAnnotationValue( groupSequenceProvider.get().value() );
+			return newGroupSequenceProviderClassInstance( jandexHelper.getClassForName( classInfo.name() ), providerClass );
+		}
+		return null;
+	}
+
+	/**
+	 * TODO: this method was directly copied from AnnotationMetaDataProvider, we will need to refactor this but it's
+	 * better to wait for the dust to settle a bit
+	 */
+	private static <T> DefaultGroupSequenceProvider<? super T> newGroupSequenceProviderClassInstance(Class<?> beanClass, Class<? extends DefaultGroupSequenceProvider<? super T>> providerClass) {
+		Method[] providerMethods = run( GetMethods.action( providerClass ) );
+		for ( Method method : providerMethods ) {
+			Class<?>[] paramTypes = method.getParameterTypes();
+			if ( "getValidationGroups".equals( method.getName() ) && !method.isBridge()
+					&& paramTypes.length == 1 && paramTypes[0].isAssignableFrom( beanClass ) ) {
+				return run( NewInstance.action( providerClass, "the default group sequence provider" ) );
+			}
+		}
+		throw LOG.getWrongDefaultGroupSequenceProviderTypeException( beanClass );
+	}
+
+	/**
+	 * Runs the given privileged action, using a privileged block if required.
+	 * <p>
+	 * <b>NOTE:</b> This must never be changed into a publicly available method to avoid execution of arbitrary
+	 * privileged actions within HV's protection domain.
+	 */
+	private static <T> T run(PrivilegedAction<T> action) {
+		return System.getSecurityManager() != null ? AccessController.doPrivileged( action ) : action.run();
+	}
+
+}
diff --git a/engine/src/main/java/org/hibernate/validator/internal/metadata/provider/package.html b/engine/src/main/java/org/hibernate/validator/internal/metadata/provider/package.html
index ec470e45f8..c7c5c507c2 100644
--- a/engine/src/main/java/org/hibernate/validator/internal/metadata/provider/package.html
+++ b/engine/src/main/java/org/hibernate/validator/internal/metadata/provider/package.html
@@ -9,6 +9,6 @@
 <head>
 </head>
 <body>
-<p>Abstraction of the meta data sources - annotation, xml, programmatic</p>
+<p>Abstraction of the meta data sources - annotation, xml, programmatic, jandex index</p>
 </body>
 </html>
diff --git a/engine/src/main/java/org/hibernate/validator/internal/metadata/raw/ConfigurationSource.java b/engine/src/main/java/org/hibernate/validator/internal/metadata/raw/ConfigurationSource.java
index fa0afe34e8..f744caf55c 100644
--- a/engine/src/main/java/org/hibernate/validator/internal/metadata/raw/ConfigurationSource.java
+++ b/engine/src/main/java/org/hibernate/validator/internal/metadata/raw/ConfigurationSource.java
@@ -24,7 +24,11 @@ public enum ConfigurationSource {
 	/**
 	 * The source of configuration is the programmatic API
 	 */
-	API( 2 );
+	API( 2 ),
+	/**
+	 * The source of configuration is Jandex index.
+	 */
+	JANDEX( 3 );
 
 	private int priority;
 
diff --git a/engine/src/main/java/org/hibernate/validator/internal/util/logging/Log.java b/engine/src/main/java/org/hibernate/validator/internal/util/logging/Log.java
index e60f9a81b8..96ab71f338 100644
--- a/engine/src/main/java/org/hibernate/validator/internal/util/logging/Log.java
+++ b/engine/src/main/java/org/hibernate/validator/internal/util/logging/Log.java
@@ -692,4 +692,17 @@ ConstraintDeclarationException getInconsistentValueUnwrappingConfigurationBetwee
 
 	@Message(id = 202, value = "Unable to get the current time from the clock provider")
 	ValidationException getUnableToGetCurrentTimeFromClockProvider(@Cause Exception e);
+
+	@Message(id = 203, value = "Error parsing Jandex index file.")
+	ValidationException getParsingJandexIndexException(@Cause Exception e);
+
+	@Message(id = 204, value = "Unable to find the class '%s' referenced in the Jandex index.")
+	ValidationException getUnableToFindClassReferencedInJandexIndex(String className, @Cause Exception e);
+
+	@Message(id = 205, value = "Unable to find the field '%2$s' referenced in the Jandex index for class '%1$s'.")
+	ValidationException getUnableToFindFieldReferencedInJandexIndex(@FormatWith(ClassObjectFormatter.class) Class<?> beanClass, String string, @Cause Exception e);
+
+	@Message(id = 206, value = "Unable to find the method '%2$s' referenced in the Jandex index for class '%1$s'.")
+	ValidationException getUnableToFindMethodReferencedInJandexIndex(@FormatWith(ClassObjectFormatter.class) Class<?> beanClass, String string, @Cause Exception e);
+
 }
diff --git a/engine/src/main/java/org/hibernate/validator/internal/util/privilegedactions/LoadClass.java b/engine/src/main/java/org/hibernate/validator/internal/util/privilegedactions/LoadClass.java
index 9e544f2301..4ac02af868 100644
--- a/engine/src/main/java/org/hibernate/validator/internal/util/privilegedactions/LoadClass.java
+++ b/engine/src/main/java/org/hibernate/validator/internal/util/privilegedactions/LoadClass.java
@@ -70,7 +70,7 @@ private Class<?> loadClassInValidatorNameSpace() {
 		final ClassLoader loader = HibernateValidator.class.getClassLoader();
 		Exception exception;
 		try {
-			return Class.forName( className, true, HibernateValidator.class.getClassLoader() );
+			return Class.forName( className, true, loader );
 		}
 		catch (ClassNotFoundException e) {
 			exception = e;
diff --git a/engine/src/test/java/org/hibernate/validator/test/internal/metadata/jandex/JandexMetaDataProviderTest.java b/engine/src/test/java/org/hibernate/validator/test/internal/metadata/jandex/JandexMetaDataProviderTest.java
new file mode 100644
index 0000000000..ccc10a0ca8
--- /dev/null
+++ b/engine/src/test/java/org/hibernate/validator/test/internal/metadata/jandex/JandexMetaDataProviderTest.java
@@ -0,0 +1,100 @@
+/*
+ * Hibernate Validator, declare and validate application constraints
+ *
+ * License: Apache License, Version 2.0
+ * See the license.txt file in the root directory or <http://www.apache.org/licenses/LICENSE-2.0>.
+ */
+package org.hibernate.validator.test.internal.metadata.jandex;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import javax.validation.constraints.Max;
+import javax.validation.constraints.Min;
+import javax.validation.constraints.NotNull;
+
+import org.assertj.core.api.ListAssert;
+import org.hibernate.validator.internal.engine.DefaultParameterNameProvider;
+import org.hibernate.validator.internal.metadata.core.AnnotationProcessingOptionsImpl;
+import org.hibernate.validator.internal.metadata.core.ConstraintHelper;
+import org.hibernate.validator.internal.metadata.jandex.ConstrainedFieldJandexBuilder;
+import org.hibernate.validator.internal.metadata.jandex.util.JandexHelper;
+import org.hibernate.validator.internal.metadata.provider.JandexMetaDataProvider;
+import org.hibernate.validator.internal.metadata.raw.BeanConfiguration;
+import org.hibernate.validator.internal.util.ExecutableParameterNameProvider;
+import org.hibernate.validator.test.internal.metadata.jandex.model.ConstrainedFieldJandexBuilderModel;
+import org.jboss.jandex.DotName;
+import org.jboss.jandex.IndexView;
+import org.jboss.jandex.Indexer;
+import org.jboss.jandex.MethodInfo;
+import org.jboss.jandex.Type;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+/**
+ * @author Marko Bekhta
+ * @author Guillaume Smet
+ */
+public class JandexMetaDataProviderTest {
+
+	private IndexView indexView;
+
+	@BeforeClass
+	public void setUp() throws IOException {
+		Class<?>[] classesToIndex = {
+				Min.class,
+				Max.class,
+				NotNull.class,
+				ConstrainedFieldJandexBuilderModel.class
+		};
+
+		Indexer indexer = new Indexer();
+		// Normally a direct file is opened, but classloader backed streams work as well.
+		for ( Class<?> classToIndex : classesToIndex ) {
+			try ( InputStream stream = getClass().getClassLoader().getResourceAsStream( classToIndex.getCanonicalName().replace( '.', '/' ) + ".class" ) ) {
+				indexer.index( stream );
+			}
+		}
+		indexView = indexer.complete();
+	}
+
+	/**
+	 * Simple test to verify that {@link ConstrainedFieldJandexBuilder} is working
+	 */
+	@Test
+	public void testGetConstrainedFields() {
+		JandexMetaDataProvider jandexMetaDataProvider = new JandexMetaDataProvider( new ConstraintHelper(), new JandexHelper(), indexView,
+				new AnnotationProcessingOptionsImpl(), new ExecutableParameterNameProvider( new DefaultParameterNameProvider() ) );
+
+		List<BeanConfiguration<? super ConstrainedFieldJandexBuilderModel>> beanConfigurations =
+				jandexMetaDataProvider.getBeanConfigurationForHierarchy( ConstrainedFieldJandexBuilderModel.class );
+
+		assertThat( beanConfigurations ).isNotEmpty();
+	}
+
+	@Test
+	public void validAnnotationIsMissing() {
+		MethodInfo method = indexView.getClassByName( DotName.createSimple( ConstrainedFieldJandexBuilderModel.class.getName() ) )
+				.methods().stream().filter( methodInfo -> methodInfo.name().equals( "someMethod1" ) )
+				.findAny().get();
+		ListAssert<Type> parametersAssert = new ListAssert<>( method.parameters() );
+		parametersAssert.hasSize( 2 );
+
+		ListAssert<String> annotations = new ListAssert<>( method.parameters().get( 0 ).annotations().stream()
+				.map( annotationInstance -> annotationInstance.name().toString() )
+				.collect( Collectors.toList() ) );
+		annotations.hasSize( 1 );
+		annotations.contains( "javax.validation.constraints.NotNull" );
+
+		annotations = new ListAssert<>( method.parameters().get( 1 ).annotations().stream()
+				.map( annotationInstance -> annotationInstance.name().toString() )
+				.collect( Collectors.toList() ) );
+		annotations.hasSize( 3 );
+		annotations.contains( "javax.validation.constraints.NotNull", "javax.validation.constraints.Size", "javax.validation.Valid" );
+	}
+
+}
diff --git a/engine/src/test/java/org/hibernate/validator/test/internal/metadata/jandex/model/ConstrainedFieldJandexBuilderModel.java b/engine/src/test/java/org/hibernate/validator/test/internal/metadata/jandex/model/ConstrainedFieldJandexBuilderModel.java
new file mode 100644
index 0000000000..0b3ac85c61
--- /dev/null
+++ b/engine/src/test/java/org/hibernate/validator/test/internal/metadata/jandex/model/ConstrainedFieldJandexBuilderModel.java
@@ -0,0 +1,65 @@
+/*
+ * Hibernate Validator, declare and validate application constraints
+ *
+ * License: Apache License, Version 2.0
+ * See the license.txt file in the root directory or <http://www.apache.org/licenses/LICENSE-2.0>.
+ */
+package org.hibernate.validator.test.internal.metadata.jandex.model;
+
+import java.util.List;
+import java.util.Optional;
+
+import javax.validation.Valid;
+import javax.validation.constraints.Max;
+import javax.validation.constraints.Min;
+import javax.validation.constraints.NotNull;
+import javax.validation.constraints.Size;
+import javax.validation.groups.ConvertGroup;
+
+import org.hibernate.validator.constraints.NotBlank;
+import org.hibernate.validator.test.internal.metadata.jandex.JandexMetaDataProviderTest;
+
+/**
+ * Simple bean class to be used in {@link JandexMetaDataProviderTest}.
+ *
+ * @author Marko Bekhta
+ */
+public class ConstrainedFieldJandexBuilderModel {
+
+	@Max(value = 1, groups = { Group1.class })
+	@ConvertGroup(from = Group1.class, to = Group2.class)
+	private String var1;
+
+	@Min(value = 2, groups = Group3.class)
+	@ConvertGroup(from = Group1.class, to = Group2.class)
+	private String var2;
+
+	private Optional<@NotBlank String> optional;
+
+	@Valid
+	private List<@NotNull String> list;
+
+	public ConstrainedFieldJandexBuilderModel(@Max(value = 1, groups = { Group1.class }) String var1, @Min(value = 2, groups = Group3.class) String var2) {
+		this.var1 = var1;
+		this.var2 = var2;
+	}
+
+	@Valid
+	@NotNull
+	public String someMethod1(@NotNull String param1, @Valid @NotNull @Size(min = 5) List<@NotNull String> param2) {
+		return "";
+	}
+
+	private interface Group1 {
+
+	}
+
+	private interface Group2 {
+
+	}
+
+	private interface Group3 {
+
+	}
+
+}
diff --git a/pom.xml b/pom.xml
index f988ed2820..c9824f387b 100644
--- a/pom.xml
+++ b/pom.xml
@@ -135,6 +135,9 @@
         <javax-money.version>1.0.1</javax-money.version>
         <moneta.version>1.1</moneta.version>
 
+        <!-- Version of Jandex to be used -->
+        <jandex.version>2.0.3.Final</jandex.version>
+
         <!-- WildFly patching infrastructure -->
         <wildfly-patch-gen-maven-plugin.version>2.0.1.Alpha3</wildfly-patch-gen-maven-plugin.version>
         <wildfly-patch-gen-maven-plugin.woodstox.version>5.0.3</wildfly-patch-gen-maven-plugin.woodstox.version>
@@ -365,6 +368,11 @@
                 <artifactId>guava</artifactId>
                 <version>20.0</version>
             </dependency>
+            <dependency>
+                <groupId>org.jboss</groupId>
+                <artifactId>jandex</artifactId>
+                <version>${jandex.version}</version>
+            </dependency>
         </dependencies>
     </dependencyManagement>