diff --git a/4.0_TODO b/4.0_TODO
index 0dd080d902..3d1da39217 100644
--- a/4.0_TODO
+++ b/4.0_TODO
@@ -6,3 +6,4 @@
 * Require @HStore annotation for HSTORE mapping / binding (remove legacy support for unqualified
   maps in Postgres plugin)
 * Throwables throwOnlyException only exists because of the above <X extends Exception> issue, so clean that up too
+* BeanMapper should throw if it can't find a nested type rather than default to `rs.getObject` (strictColumnMapping)
diff --git a/core/src/main/java/org/jdbi/v3/core/argument/BeanPropertyArguments.java b/core/src/main/java/org/jdbi/v3/core/argument/BeanPropertyArguments.java
index 9167f12a96..ba6b70fece 100644
--- a/core/src/main/java/org/jdbi/v3/core/argument/BeanPropertyArguments.java
+++ b/core/src/main/java/org/jdbi/v3/core/argument/BeanPropertyArguments.java
@@ -24,7 +24,10 @@
 /**
  * Inspect a {@link java.beans} style object and bind parameters
  * based on each of its discovered properties.
+ *
+ * @deprecated this should never have been public API
  */
+@Deprecated
 public class BeanPropertyArguments extends MethodReturnValueNamedArgumentFinder {
     private final PojoProperties<?> properties;
 
@@ -37,6 +40,15 @@ public BeanPropertyArguments(String prefix, Object bean) {
         properties = BeanPropertiesFactory.propertiesFor(obj.getClass());
     }
 
+    /**
+     * @param prefix an optional prefix (we insert a '.' as a separator)
+     * @param bean the bean to inspect and bind
+     */
+    protected BeanPropertyArguments(String prefix, Object bean, PojoProperties<?> properties) {
+        super(prefix, bean);
+        this.properties = properties;
+    }
+
     @Override
     protected Optional<TypedValue> getValue(String name, StatementContext ctx) {
         @SuppressWarnings("unchecked")
diff --git a/core/src/main/java/org/jdbi/v3/core/argument/internal/PojoPropertyArguments.java b/core/src/main/java/org/jdbi/v3/core/argument/internal/PojoPropertyArguments.java
index dabe817d87..24cfc826b2 100644
--- a/core/src/main/java/org/jdbi/v3/core/argument/internal/PojoPropertyArguments.java
+++ b/core/src/main/java/org/jdbi/v3/core/argument/internal/PojoPropertyArguments.java
@@ -13,57 +13,26 @@
  */
 package org.jdbi.v3.core.argument.internal;
 
-import java.util.Map;
-import java.util.Optional;
-
+import org.jdbi.v3.core.argument.BeanPropertyArguments;
 import org.jdbi.v3.core.argument.NamedArgumentFinder;
-import org.jdbi.v3.core.mapper.RowMapper;
-import org.jdbi.v3.core.mapper.reflect.BeanMapper;
-import org.jdbi.v3.core.mapper.reflect.internal.PojoProperties.PojoProperty;
+import org.jdbi.v3.core.mapper.reflect.internal.PojoPropertiesFactories;
 import org.jdbi.v3.core.statement.StatementContext;
-import org.jdbi.v3.core.statement.UnableToCreateStatementException;
 
 /**
- * Inspect a object and bind parameters via {@link BeanMapper}'s properties.
+ * This class only exists to use the protected BeanPropertyArguments constructor.
+ * When we can remove that class from public API, this class will easily merge into it.
  */
-public class PojoPropertyArguments extends MethodReturnValueNamedArgumentFinder {
-    private final Map<String, ? extends PojoProperty<?>> properties;
+@SuppressWarnings("deprecation")
+public class PojoPropertyArguments extends BeanPropertyArguments {
     private final StatementContext ctx;
 
-    /**
-     * @param prefix an optional prefix (we insert a '.' as a separator)
-     * @param bean the bean to inspect and bind
-     * @param ctx the statement context
-     */
     public PojoPropertyArguments(String prefix, Object bean, StatementContext ctx) {
-        super(prefix, bean);
+        super(prefix, bean, ctx.getConfig(PojoPropertiesFactories.class).propertiesOf(bean.getClass()));
         this.ctx = ctx;
-        final RowMapper<? extends Object> mapper = ctx.findRowMapperFor(bean.getClass())
-                .orElseThrow(() -> new UnableToCreateStatementException("Couldn't find registered property mapper for " + bean.getClass()));
-        if (!(mapper instanceof BeanMapper<?>)) {
-            throw new UnableToCreateStatementException("Registered mapper for " + bean.getClass() + " is not a property based mapper");
-        }
-        properties = ((BeanMapper<?>) mapper).getBeanInfo().getProperties();
-    }
-
-    @Override
-    protected Optional<TypedValue> getValue(String name, StatementContext ctx2) {
-        @SuppressWarnings("unchecked")
-        PojoProperty<Object> property = (PojoProperty<Object>) properties.get(name);
-        if (property == null) {
-            return Optional.empty();
-        }
-
-        return Optional.of(new TypedValue(property.getQualifiedType(), property.get(obj)));
     }
 
     @Override
     protected NamedArgumentFinder getNestedArgumentFinder(Object o) {
         return new PojoPropertyArguments(null, o, ctx);
     }
-
-    @Override
-    public String toString() {
-        return "{lazy bean property arguments \"" + obj + "\"}";
-    }
 }
diff --git a/core/src/main/java/org/jdbi/v3/core/mapper/immutables/ImmutablesPlugin.java b/core/src/main/java/org/jdbi/v3/core/mapper/immutables/ImmutablesPlugin.java
new file mode 100644
index 0000000000..fd1784e553
--- /dev/null
+++ b/core/src/main/java/org/jdbi/v3/core/mapper/immutables/ImmutablesPlugin.java
@@ -0,0 +1,144 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.jdbi.v3.core.mapper.immutables;
+
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.lang.reflect.Type;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+import org.jdbi.v3.core.Jdbi;
+import org.jdbi.v3.core.internal.JdbiOptionals;
+import org.jdbi.v3.core.internal.exceptions.Unchecked;
+import org.jdbi.v3.core.mapper.immutables.internal.ImmutablesMapperFactory;
+import org.jdbi.v3.core.mapper.reflect.internal.ImmutablesPropertiesFactory;
+import org.jdbi.v3.core.mapper.reflect.internal.PojoProperties;
+import org.jdbi.v3.core.mapper.reflect.internal.PojoPropertiesFactories;
+import org.jdbi.v3.core.spi.JdbiPlugin;
+import org.jdbi.v3.meta.Beta;
+
+/**
+ * Install support for an Immutables generated {@code Immutable} or {@code Modifiable} value type.
+ * Note that unlike most plugins, this plugin is expected to be installed multiple times, once for each value type you wish to handle.
+ */
+@Beta
+public class ImmutablesPlugin<S> implements JdbiPlugin {
+    private final Class<S> spec;
+    private final Class<? extends S> impl;
+    private final Function<Type, ? extends PojoProperties<S>> properties;
+
+    private ImmutablesPlugin(Class<S> spec, Class<? extends S> impl, Function<Type, ? extends PojoProperties<S>> properties) {
+        this.spec = spec;
+        this.impl = impl;
+        this.properties = properties;
+    }
+
+    /**
+     * Register bean arguments and row mapping for an {@code Immutable*} value class, expecting the default generated class and builder names.
+     * @param spec the specification interface or abstract class
+     * @param <S> the specification class
+     * @return a plugin that configures type mapping for the given class
+     */
+    public static <S> ImmutablesPlugin<S> forImmutable(Class<S> spec) {
+        final Class<? extends S> impl = classByPrefix("Immutable", spec);
+        return forImmutable(spec, impl, JdbiOptionals.findFirstPresent(
+                () -> nullaryMethodOf(spec, "builder"),
+                () -> nullaryMethodOf(impl, "builder"))
+                    .orElseThrow(() -> new IllegalArgumentException("Neither " + spec + " nor " + impl + " have a 'builder' method")));
+    }
+
+    /**
+     * Register bean arguments and row mapping for an {@code Immutable*} value class, using a supplied implementation and builder.
+     * @param spec the specification interface or abstract class
+     * @param impl the generated implementation class
+     * @param builder a supplier of new Builder instances
+     * @param <S> the specification class
+     * @param <I> the implementation class
+     * @return a plugin that configures type mapping for the given class
+     */
+    public static <S, I extends S> ImmutablesPlugin<S> forImmutable(Class<S> spec, Class<I> impl, Supplier<?> builder) {
+        return new ImmutablesPlugin<S>(spec, impl, ImmutablesPropertiesFactory.immutable(spec, builder));
+    }
+
+    /**
+     * Register bean arguments and row mapping for an {@code Modifiable*} value class, expecting the default generated class and public nullary constructor.
+     * @param spec the specification interface or abstract class
+     * @param <S> the specification class
+     * @return a plugin that configures type mapping for the given class
+     */
+    public static <S> ImmutablesPlugin<S> forModifiable(Class<S> spec) {
+        final Class<? extends S> impl = classByPrefix("Modifiable", spec);
+        return forModifiable(spec, impl,
+                nullaryMethodOf(impl, "create")
+                    .orElseGet(() -> constructorOf(impl)));
+    }
+
+    /**
+     * Register bean arguments and row mapping for an {@code Modifiable*} value class, using a supplied implementation and constructor.
+     * @param spec the specification interface or abstract class
+     * @param impl the modifiable class
+     * @param constructor a supplier of new Modifiable instances
+     * @param <S> the specification class
+     * @param <M> the modifiable class
+     * @return a plugin that configures type mapping for the given class
+     */
+    public static <S, M extends S> ImmutablesPlugin<S> forModifiable(Class<S> spec, Class<M> impl, Supplier<?> constructor) {
+        return new ImmutablesPlugin<S>(spec, impl, ImmutablesPropertiesFactory.modifiable(spec, () -> impl.cast(constructor.get())));
+    }
+
+    private static Optional<Supplier<?>> nullaryMethodOf(Class<?> impl, String methodName) {
+        try {
+            return Optional.of(Unchecked.supplier(MethodHandles.lookup()
+                                .unreflect(impl.getMethod(methodName))::invoke));
+        } catch (ReflectiveOperationException e) {
+            return Optional.empty();
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <S> Supplier<S> constructorOf(Class<S> impl) {
+        try {
+            return (Supplier<S>) Unchecked.supplier(MethodHandles.lookup().findConstructor(impl, MethodType.methodType(void.class))::invoke);
+        } catch (ReflectiveOperationException e) {
+            throw new IllegalArgumentException("Couldn't find public constructor of " + impl, e);
+        }
+    }
+
+    private static <S, Sub extends S> Class<? extends S> classByPrefix(String prefix, Class<S> spec) {
+        final String implName = spec.getPackage().getName() + '.' + prefix + spec.getSimpleName();
+        try {
+            return Class.forName(implName).asSubclass(spec);
+        } catch (ClassNotFoundException e) {
+            throw new IllegalArgumentException("Couldn't locate default implementation class " + implName, e);
+        }
+    }
+
+    @Override
+    public void customizeJdbi(Jdbi jdbi) {
+        jdbi.getConfig(PojoPropertiesFactories.class).register(new Factory());
+        jdbi.registerRowMapper(new ImmutablesMapperFactory<S>(spec, impl, properties));
+    }
+
+    class Factory implements Function<Type, Optional<PojoProperties<?>>> {
+        @Override
+        public Optional<PojoProperties<?>> apply(Type t) {
+            if (t == spec || t == impl) {
+                return Optional.of(properties.apply(t));
+            }
+            return Optional.empty();
+        }
+    }
+}
diff --git a/core/src/main/java/org/jdbi/v3/core/mapper/reflect/ImmutablesMapperFactory.java b/core/src/main/java/org/jdbi/v3/core/mapper/immutables/internal/ImmutablesMapperFactory.java
similarity index 59%
rename from core/src/main/java/org/jdbi/v3/core/mapper/reflect/ImmutablesMapperFactory.java
rename to core/src/main/java/org/jdbi/v3/core/mapper/immutables/internal/ImmutablesMapperFactory.java
index a1c9d6a3a5..4f663eb413 100644
--- a/core/src/main/java/org/jdbi/v3/core/mapper/reflect/ImmutablesMapperFactory.java
+++ b/core/src/main/java/org/jdbi/v3/core/mapper/immutables/internal/ImmutablesMapperFactory.java
@@ -11,48 +11,41 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.jdbi.v3.core.mapper.reflect;
+package org.jdbi.v3.core.mapper.immutables.internal;
 
 import java.lang.reflect.Type;
 import java.util.Optional;
 import java.util.function.Function;
-import java.util.function.Supplier;
-
 import org.jdbi.v3.core.config.ConfigRegistry;
 import org.jdbi.v3.core.generic.GenericTypes;
 import org.jdbi.v3.core.mapper.RowMapper;
 import org.jdbi.v3.core.mapper.RowMapperFactory;
-import org.jdbi.v3.core.mapper.reflect.internal.ImmutablesPropertiesFactory;
+import org.jdbi.v3.core.mapper.reflect.internal.PojoMapper;
 import org.jdbi.v3.core.mapper.reflect.internal.PojoProperties;
-import org.jdbi.v3.meta.Beta;
 
-@Beta
+/**
+ * Row mapper that inspects an {@code immutables}-style Immutable or Modifiable value class for properties
+ * and binds them in the style of {@link org.jdbi.v3.core.mapper.reflect.BeanMapper}.
+ * @param <T> the mapped value type
+ */
 public class ImmutablesMapperFactory<T> implements RowMapperFactory {
 
     private final Class<T> defn;
     private final Class<? extends T> impl;
-    private final Function<Type, PojoProperties<T>> properties;
+    private final Function<Type, ? extends PojoProperties<T>> properties;
 
-    private ImmutablesMapperFactory(Class<T> defn, Class<? extends T> impl, Function<Type, PojoProperties<T>> properties) {
+    public ImmutablesMapperFactory(Class<T> defn, Class<? extends T> impl, Function<Type, ? extends PojoProperties<T>> properties) {
         this.defn = defn;
         this.impl = impl;
         this.properties = properties;
     }
 
-    public static <T, I extends T, B> RowMapperFactory mapImmutable(Class<T> defn, Class<I> immutable, Supplier<B> builder) {
-        return new ImmutablesMapperFactory<>(defn, immutable, ImmutablesPropertiesFactory.immutable(defn, builder));
-    }
-
-    public static <T, M extends T> RowMapperFactory mapModifiable(Class<T> defn, Class<M> modifiable, Supplier<M> constructor) {
-        return new ImmutablesMapperFactory<>(defn, modifiable, ImmutablesPropertiesFactory.modifiable(defn, constructor));
-    }
-
     @SuppressWarnings("unchecked")
     @Override
     public Optional<RowMapper<?>> build(Type type, ConfigRegistry config) {
         Class<?> erasedType = GenericTypes.getErasedType(type);
         if (defn.equals(erasedType) || impl.equals(erasedType)) {
-            return Optional.of(PropertiesMapper.of((Class<T>) erasedType, properties.apply(type)));
+            return Optional.of(new PojoMapper<>((Class<T>) erasedType, properties.apply(type), ""));
         }
         return Optional.empty();
     }
diff --git a/core/src/main/java/org/jdbi/v3/core/mapper/reflect/BeanMapper.java b/core/src/main/java/org/jdbi/v3/core/mapper/reflect/BeanMapper.java
index df0f295a4d..81c368cf07 100644
--- a/core/src/main/java/org/jdbi/v3/core/mapper/reflect/BeanMapper.java
+++ b/core/src/main/java/org/jdbi/v3/core/mapper/reflect/BeanMapper.java
@@ -24,6 +24,7 @@
 import org.jdbi.v3.core.generic.GenericTypes;
 import org.jdbi.v3.core.mapper.ColumnMapper;
 import org.jdbi.v3.core.mapper.Nested;
+import org.jdbi.v3.core.mapper.NoSuchMapperException;
 import org.jdbi.v3.core.mapper.RowMapper;
 import org.jdbi.v3.core.mapper.RowMapperFactory;
 import org.jdbi.v3.core.mapper.SingleColumnMapper;
@@ -32,8 +33,6 @@
 import org.jdbi.v3.core.mapper.reflect.internal.PojoProperties.PojoBuilder;
 import org.jdbi.v3.core.mapper.reflect.internal.PojoProperties.PojoProperty;
 import org.jdbi.v3.core.statement.StatementContext;
-import org.jdbi.v3.meta.Beta;
-
 import static org.jdbi.v3.core.mapper.reflect.ReflectionMapperUtil.anyColumnsStartWithPrefix;
 import static org.jdbi.v3.core.mapper.reflect.ReflectionMapperUtil.findColumnIndex;
 import static org.jdbi.v3.core.mapper.reflect.ReflectionMapperUtil.getColumnNames;
@@ -46,7 +45,10 @@
  * properties.
  *
  * The mapped class must have a default constructor.
+ *
+ * @deprecated this class should not be public API, use {@link org.jdbi.v3.core.statement.SqlStatement#bindBean(Object)} instead.
  */
+@Deprecated
 public class BeanMapper<T> implements RowMapper<T> {
     static final String DEFAULT_PREFIX = "";
 
@@ -100,6 +102,7 @@ public static <T> RowMapper<T> of(Class<T> type, String prefix) {
         return new BeanMapper<>(type, prefix);
     }
 
+    protected boolean strictColumnMapping; // this should be default (only?) behavior but that's a breaking change
     protected final Class<T> type;
     protected final String prefix;
     private final PojoProperties<T> properties;
@@ -110,7 +113,7 @@ public static <T> RowMapper<T> of(Class<T> type, String prefix) {
         this(type, (PojoProperties<T>) BeanPropertiesFactory.propertiesFor(type), prefix);
     }
 
-    BeanMapper(Class<T> type, PojoProperties<T> properties, String prefix) {
+    protected BeanMapper(Class<T> type, PojoProperties<T> properties, String prefix) {
         this.type = type;
         this.properties = properties;
         this.prefix = prefix.toLowerCase();
@@ -198,15 +201,14 @@ private Optional<RowMapper<T>> specialize0(StatementContext ctx,
         });
     }
 
-    ColumnMapper<?> defaultColumnMapper(PojoProperty<T> property) {
+    private ColumnMapper<?> defaultColumnMapper(PojoProperty<T> property) {
+        if (strictColumnMapping) {
+            throw new NoSuchMapperException(String.format(
+                    "Couldn't find mapper for property '%s' of type '%s' from %s", property.getName(), property.getQualifiedType(), type));
+        }
         return (r, n, c) -> r.getObject(n);
     }
 
-    @Beta
-    public PojoProperties<T> getBeanInfo() {
-        return properties;
-    }
-
     private String getName(PojoProperty<T> property) {
         return property.getAnnotation(ColumnName.class)
                 .map(ColumnName::value)
diff --git a/core/src/main/java/org/jdbi/v3/core/mapper/reflect/PropertiesMapper.java b/core/src/main/java/org/jdbi/v3/core/mapper/reflect/PropertiesMapper.java
deleted file mode 100644
index 222b0b7274..0000000000
--- a/core/src/main/java/org/jdbi/v3/core/mapper/reflect/PropertiesMapper.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.jdbi.v3.core.mapper.reflect;
-
-import org.jdbi.v3.core.mapper.ColumnMapper;
-import org.jdbi.v3.core.mapper.NoSuchMapperException;
-import org.jdbi.v3.core.mapper.RowMapper;
-import org.jdbi.v3.core.mapper.RowMapperFactory;
-import org.jdbi.v3.core.mapper.reflect.internal.PojoProperties;
-import org.jdbi.v3.core.mapper.reflect.internal.PojoProperties.PojoProperty;
-
-class PropertiesMapper<T> extends BeanMapper<T> {
-    private PropertiesMapper(Class<T> type, PojoProperties<T> properties, String prefix) {
-        super(type, properties, prefix);
-    }
-
-    public static <T> RowMapperFactory factory(Class<T> type, PojoProperties<T> properties) {
-        return RowMapperFactory.of(type, PropertiesMapper.of(type, properties));
-    }
-
-    public static <T> RowMapperFactory factory(Class<T> type, PojoProperties<T> properties, String prefix) {
-        return RowMapperFactory.of(type, PropertiesMapper.of(type, properties, prefix));
-    }
-
-    public static <T> RowMapper<T> of(Class<T> type, PojoProperties<T> properties) {
-        return PropertiesMapper.of(type, properties, DEFAULT_PREFIX);
-    }
-
-    public static <T> RowMapper<T> of(Class<T> type, PojoProperties<T> properties, String prefix) {
-        return new PropertiesMapper<>(type, properties, prefix);
-    }
-
-    @Override
-    protected ColumnMapper<?> defaultColumnMapper(PojoProperty<T> property) {
-        throw new NoSuchMapperException(String.format(
-                "Couldn't find mapper for property '%s' of type '%s' from %s", property.getName(), property.getQualifiedType(), type));
-    }
-}
diff --git a/core/src/main/java/org/jdbi/v3/core/mapper/reflect/internal/PojoMapper.java b/core/src/main/java/org/jdbi/v3/core/mapper/reflect/internal/PojoMapper.java
new file mode 100644
index 0000000000..2a0c9a5590
--- /dev/null
+++ b/core/src/main/java/org/jdbi/v3/core/mapper/reflect/internal/PojoMapper.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.jdbi.v3.core.mapper.reflect.internal;
+
+import org.jdbi.v3.core.mapper.reflect.BeanMapper;
+
+/** This class only exists to extend BeanMapper with API that would otherwise be unavoidably public. */
+@SuppressWarnings("deprecation")
+public class PojoMapper<T> extends BeanMapper<T> {
+    public PojoMapper(Class<T> type, PojoProperties<T> properties, String prefix) {
+        super(type, properties, prefix);
+        strictColumnMapping = true;
+    }
+}
diff --git a/core/src/main/java/org/jdbi/v3/core/mapper/reflect/internal/PojoPropertiesFactories.java b/core/src/main/java/org/jdbi/v3/core/mapper/reflect/internal/PojoPropertiesFactories.java
new file mode 100644
index 0000000000..f5ff037400
--- /dev/null
+++ b/core/src/main/java/org/jdbi/v3/core/mapper/reflect/internal/PojoPropertiesFactories.java
@@ -0,0 +1,50 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.jdbi.v3.core.mapper.reflect.internal;
+
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Function;
+
+import org.jdbi.v3.core.config.JdbiConfig;
+import org.jdbi.v3.core.internal.JdbiOptionals;
+
+public class PojoPropertiesFactories implements JdbiConfig<PojoPropertiesFactories> {
+    private final List<Function<Type, Optional<PojoProperties<?>>>> factories = new ArrayList<>();
+
+    public PojoPropertiesFactories() {}
+
+    private PojoPropertiesFactories(PojoPropertiesFactories other) {
+        factories.addAll(other.factories);
+    }
+
+    public PojoPropertiesFactories register(Function<Type, Optional<PojoProperties<?>>> factory) {
+        factories.add(factory);
+        return this;
+    }
+
+    public PojoProperties<?> propertiesOf(Type type) {
+        return factories.stream()
+                .flatMap(ppf -> JdbiOptionals.stream(ppf.apply(type)))
+                .findFirst()
+                .orElseGet(() -> BeanPropertiesFactory.propertiesFor(type));
+    }
+
+    @Override
+    public PojoPropertiesFactories createCopy() {
+        return new PojoPropertiesFactories(this);
+    }
+}
diff --git a/core/src/main/java/org/jdbi/v3/core/qualifier/Qualifiers.java b/core/src/main/java/org/jdbi/v3/core/qualifier/Qualifiers.java
index 6de5f9b521..7b57f9b8e3 100644
--- a/core/src/main/java/org/jdbi/v3/core/qualifier/Qualifiers.java
+++ b/core/src/main/java/org/jdbi/v3/core/qualifier/Qualifiers.java
@@ -13,6 +13,8 @@
  */
 package org.jdbi.v3.core.qualifier;
 
+import static java.util.stream.Collectors.toSet;
+
 import java.lang.annotation.Annotation;
 import java.lang.reflect.AnnotatedElement;
 import java.util.Arrays;
@@ -21,8 +23,6 @@
 
 import org.jdbi.v3.meta.Beta;
 
-import static java.util.stream.Collectors.toSet;
-
 /**
  * Utility class for type qualifiers supported by Jdbi core.
  */
diff --git a/core/src/main/java/org/jdbi/v3/core/result/ResultBearing.java b/core/src/main/java/org/jdbi/v3/core/result/ResultBearing.java
index 69ff493a86..29ba654e72 100644
--- a/core/src/main/java/org/jdbi/v3/core/result/ResultBearing.java
+++ b/core/src/main/java/org/jdbi/v3/core/result/ResultBearing.java
@@ -179,6 +179,7 @@ default ResultIterable<?> mapTo(QualifiedType type) {
      * @param <T>  the bean type to map the result set rows to
      * @return a {@link ResultIterable} of the given type.
      */
+    @SuppressWarnings("deprecation")
     default <T> ResultIterable<T> mapToBean(Class<T> type) {
         return map(BeanMapper.of(type));
     }
diff --git a/core/src/main/java/org/jdbi/v3/core/statement/SqlStatement.java b/core/src/main/java/org/jdbi/v3/core/statement/SqlStatement.java
index c5cecb2def..48d1863bdb 100644
--- a/core/src/main/java/org/jdbi/v3/core/statement/SqlStatement.java
+++ b/core/src/main/java/org/jdbi/v3/core/statement/SqlStatement.java
@@ -166,6 +166,7 @@ public This bind(String name, Argument argument) {
      *
      * @return modified statement
      */
+    @SuppressWarnings("deprecation")
     public This bindBean(Object bean) {
         return bindNamedArgumentFinder(new BeanPropertyArguments(null, bean));
     }
@@ -180,6 +181,7 @@ public This bindBean(Object bean) {
      *
      * @return modified statement
      */
+    @SuppressWarnings("deprecation")
     public This bindBean(String prefix, Object bean) {
         return bindNamedArgumentFinder(new BeanPropertyArguments(prefix, bean));
     }
@@ -192,8 +194,8 @@ public This bindBean(String prefix, Object bean) {
      * @return modified statement
      */
     @Beta
-    public This bindProperties(Object pojo) {
-        return bindNamedArgumentFinder(new PojoPropertyArguments(null, pojo, getContext()));
+    public This bindPojo(Object pojo) {
+        return bindPojo(null, pojo);
     }
 
     /**
@@ -207,7 +209,7 @@ public This bindProperties(Object pojo) {
      * @return modified statement
      */
     @Beta
-    public This bindProperties(String prefix, Object pojo) {
+    public This bindPojo(String prefix, Object pojo) {
         return bindNamedArgumentFinder(new PojoPropertyArguments(prefix, pojo, getContext()));
     }
 
diff --git a/core/src/test/java/org/jdbi/v3/core/mapper/ImmutablesTest.java b/core/src/test/java/org/jdbi/v3/core/mapper/ImmutablesTest.java
index ac48ed78e8..73a923d488 100644
--- a/core/src/test/java/org/jdbi/v3/core/mapper/ImmutablesTest.java
+++ b/core/src/test/java/org/jdbi/v3/core/mapper/ImmutablesTest.java
@@ -19,8 +19,9 @@
 
 import org.immutables.value.Value;
 import org.jdbi.v3.core.Handle;
+import org.jdbi.v3.core.Jdbi;
 import org.jdbi.v3.core.generic.GenericType;
-import org.jdbi.v3.core.mapper.reflect.ImmutablesMapperFactory;
+import org.jdbi.v3.core.mapper.immutables.ImmutablesPlugin;
 import org.jdbi.v3.core.rule.H2DatabaseRule;
 import org.junit.Before;
 import org.junit.Rule;
@@ -30,19 +31,24 @@
 
 public class ImmutablesTest {
     @Rule
-    public H2DatabaseRule dbRule = new H2DatabaseRule();
+    public H2DatabaseRule dbRule = new H2DatabaseRule()
+        .withPlugin(ImmutablesPlugin.forImmutable(SubValue.class))
+        .withPlugin(ImmutablesPlugin.forImmutable(FooBarBaz.class))
+        .withPlugin(ImmutablesPlugin.forModifiable(FooBarBaz.class));
 
+    private Jdbi jdbi;
     private Handle h;
 
     @Before
     public void setup() {
+        jdbi = dbRule.getJdbi();
         h = dbRule.getSharedHandle();
         h.execute("create table immutables (t int, x varchar)");
-
-        h.registerRowMapper(ImmutablesMapperFactory.mapImmutable(SubValue.class, ImmutableSubValue.class, ImmutableSubValue::builder));
     }
 
     // tag::example[]
+    // First, install the plugin: ;
+
     @Value.Immutable
     public interface Train {
         String name();
@@ -52,12 +58,12 @@ public interface Train {
 
     @Test
     public void simpleTest() {
+        jdbi.installPlugin(ImmutablesPlugin.forImmutable(Train.class));
         h.execute("create table train (name varchar, carriages int, observation_car boolean)");
-        h.registerRowMapper(ImmutablesMapperFactory.mapImmutable(Train.class, ImmutableTrain.class, ImmutableTrain::builder));
 
         assertThat(
             h.createUpdate("insert into train(name, carriages, observation_car) values (:name, :carriages, :observationCar)")
-                .bindProperties(ImmutableTrain.builder().name("Zephyr").carriages(8).observationCar(true).build())
+                .bindPojo(ImmutableTrain.builder().name("Zephyr").carriages(8).observationCar(true).build())
                 .execute())
             .isEqualTo(1);
 
@@ -74,7 +80,7 @@ public void simpleTest() {
     public void parameterizedTest() {
         assertThat(
             h.createUpdate("insert into immutables(t, x) values (:t, :x)")
-                .bindProperties(ImmutableSubValue.<String, Integer>builder().t(42).x("foo").build())
+                .bindPojo(ImmutableSubValue.<String, Integer>builder().t(42).x("foo").build())
                 .execute())
             .isEqualTo(1);
 
@@ -106,12 +112,10 @@ public interface FooBarBaz {
 
     @Test
     public void testModifiable() {
-        h.registerRowMapper(ImmutablesMapperFactory.mapImmutable(FooBarBaz.class, ImmutableFooBarBaz.class, ImmutableFooBarBaz::builder));
-        h.registerRowMapper(ImmutablesMapperFactory.mapModifiable(FooBarBaz.class, ModifiableFooBarBaz.class, ModifiableFooBarBaz::create));
         h.execute("create table fbb (id serial, foo varchar, bar int, baz real)");
 
         assertThat(h.createUpdate("insert into fbb (id, foo, bar, baz) values (:id, :foo, :bar, :baz)")
-                .bindProperties(ModifiableFooBarBaz.create().setFoo("foo").setBar(42).setBaz(1.0))
+                .bindPojo(ModifiableFooBarBaz.create().setFoo("foo").setBar(42).setBaz(1.0))
                 .execute())
             .isEqualTo(1);
 
diff --git a/docs/src/adoc/index.adoc b/docs/src/adoc/index.adoc
index a5fce44cc7..74d177c0f3 100644
--- a/docs/src/adoc/index.adoc
+++ b/docs/src/adoc/index.adoc
@@ -3800,7 +3800,11 @@ to `Jdbi` properties binding and row mapping.
 [WARNING]
 Immutables support is still experimental and does not yet support custom naming schemes.
 
-Just tell us about your types, and we do the rest:
+Just tell us about your types by installing the plugin (possibly multiple times):
+
+`jdbi.installPlugin(ImmutablesPlugin.forImmutable(MyValueType.class))`
+
+and we do the rest:
 
 [source,java,indent=0]
 ----
diff --git a/pom.xml b/pom.xml
index 153385ed69..f9db44e7d1 100644
--- a/pom.xml
+++ b/pom.xml
@@ -84,6 +84,7 @@
         <dep.antlr.version>3.4</dep.antlr.version>
         <dep.checkstyle.version>8.10</dep.checkstyle.version>
         <dep.dokka.version>0.9.17</dep.dokka.version>
+        <dep.immutables.version>2.7.1</dep.immutables.version>
         <dep.jackson2.version>2.9.8</dep.jackson2.version>
         <dep.jetbrainsAnnotations.version>13.0</dep.jetbrainsAnnotations.version>
         <dep.kotlin.version>1.2.31</dep.kotlin.version>
@@ -242,7 +243,7 @@
             <dependency>
                 <groupId>org.immutables</groupId>
                 <artifactId>value</artifactId>
-                <version>2.7.1</version>
+                <version>${dep.immutables.version}</version>
             </dependency>
 
             <dependency>
@@ -506,6 +507,13 @@
                     <configuration>
                         <source>${project.build.targetJdk}</source>
                         <target>${project.build.targetJdk}</target>
+                        <annotationProcessorPaths>
+                            <annotationProcessorPath>
+                                <groupId>org.immutables</groupId>
+                                <artifactId>value</artifactId>
+                                <version>${dep.immutables.version}</version>
+                            </annotationProcessorPath>
+                        </annotationProcessorPaths>
                     </configuration>
                 </plugin>
                 <plugin>
diff --git a/postgres/pom.xml b/postgres/pom.xml
index 63d40d17cb..78f9f31bbc 100644
--- a/postgres/pom.xml
+++ b/postgres/pom.xml
@@ -60,6 +60,7 @@
             <artifactId>value</artifactId>
             <scope>test</scope>
         </dependency>
+
         <dependency>
             <groupId>org.jdbi</groupId>
             <artifactId>jdbi3-core</artifactId>
diff --git a/postgres/src/test/java/org/jdbi/v3/postgres/TestImmutablesHStore.java b/postgres/src/test/java/org/jdbi/v3/postgres/TestImmutablesHStore.java
index a11a443205..cbace59abd 100644
--- a/postgres/src/test/java/org/jdbi/v3/postgres/TestImmutablesHStore.java
+++ b/postgres/src/test/java/org/jdbi/v3/postgres/TestImmutablesHStore.java
@@ -18,10 +18,10 @@
 
 import org.immutables.value.Value;
 import org.jdbi.v3.core.Handle;
-import org.jdbi.v3.core.mapper.reflect.ImmutablesMapperFactory;
+import org.jdbi.v3.core.mapper.immutables.ImmutablesPlugin;
 import org.jdbi.v3.core.rule.PgDatabaseRule;
 import org.jdbi.v3.sqlobject.SqlObjectPlugin;
-import org.jdbi.v3.sqlobject.customizer.BindProperties;
+import org.jdbi.v3.sqlobject.customizer.BindPojo;
 import org.jdbi.v3.sqlobject.statement.SqlQuery;
 import org.jdbi.v3.sqlobject.statement.SqlUpdate;
 import org.junit.After;
@@ -34,14 +34,16 @@
 public class TestImmutablesHStore {
 
     @Rule
-    public PgDatabaseRule dbRule = new PgDatabaseRule().withPlugin(new PostgresPlugin()).withPlugin(new SqlObjectPlugin());
+    public PgDatabaseRule dbRule = new PgDatabaseRule()
+        .withPlugin(new PostgresPlugin())
+        .withPlugin(new SqlObjectPlugin())
+        .withPlugin(ImmutablesPlugin.forImmutable(Mappy.class));
 
     private Handle h;
 
     @Before
     public void setup() {
         h = dbRule.openHandle();
-        h.registerRowMapper(ImmutablesMapperFactory.mapImmutable(Mappy.class, ImmutableMappy.class, Mappy::builder));
         h.execute("create extension if not exists \"hstore\"");
         h.execute("create table mappy (numbers hstore not null)");
     }
@@ -87,7 +89,7 @@ public void testMap() {
 
     public interface MappyDao {
         @SqlUpdate("insert into mappy (numbers) values (:numbers)")
-        int insert(@BindProperties Mappy mappy);
+        int insert(@BindPojo Mappy mappy);
 
         @SqlQuery("select numbers from mappy")
         List<Mappy> select();
diff --git a/sqlobject/src/main/java/org/jdbi/v3/sqlobject/config/internal/RegisterBeanMapperImpl.java b/sqlobject/src/main/java/org/jdbi/v3/sqlobject/config/internal/RegisterBeanMapperImpl.java
index 78507bc75b..fe662f42b3 100644
--- a/sqlobject/src/main/java/org/jdbi/v3/sqlobject/config/internal/RegisterBeanMapperImpl.java
+++ b/sqlobject/src/main/java/org/jdbi/v3/sqlobject/config/internal/RegisterBeanMapperImpl.java
@@ -24,6 +24,7 @@
 
 public class RegisterBeanMapperImpl implements Configurer {
     @Override
+    @SuppressWarnings("deprecation")
     public void configureForType(ConfigRegistry registry, Annotation annotation, Class<?> sqlObjectType) {
         RegisterBeanMapper registerBeanMapper = (RegisterBeanMapper) annotation;
         Class<?> beanClass = registerBeanMapper.value();
diff --git a/sqlobject/src/main/java/org/jdbi/v3/sqlobject/customizer/BindProperties.java b/sqlobject/src/main/java/org/jdbi/v3/sqlobject/customizer/BindPojo.java
similarity index 86%
rename from sqlobject/src/main/java/org/jdbi/v3/sqlobject/customizer/BindProperties.java
rename to sqlobject/src/main/java/org/jdbi/v3/sqlobject/customizer/BindPojo.java
index 02b222cf81..e3913d99b5 100644
--- a/sqlobject/src/main/java/org/jdbi/v3/sqlobject/customizer/BindProperties.java
+++ b/sqlobject/src/main/java/org/jdbi/v3/sqlobject/customizer/BindPojo.java
@@ -18,15 +18,15 @@
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
-import org.jdbi.v3.sqlobject.customizer.internal.BindPropertiesFactory;
+import org.jdbi.v3.sqlobject.customizer.internal.BindPojoFactory;
 
 /**
  * Binds the properties of an object to a SQL statement.
  */
 @Retention(RetentionPolicy.RUNTIME)
 @Target({ElementType.PARAMETER})
-@SqlStatementCustomizingAnnotation(BindPropertiesFactory.class)
-public @interface BindProperties {
+@SqlStatementCustomizingAnnotation(BindPojoFactory.class)
+public @interface BindPojo {
     /**
      * Prefix to apply to each property. If specified, properties will be bound as
      * {@code prefix.propertyName}.
diff --git a/sqlobject/src/main/java/org/jdbi/v3/sqlobject/customizer/internal/BindPropertiesFactory.java b/sqlobject/src/main/java/org/jdbi/v3/sqlobject/customizer/internal/BindPojoFactory.java
similarity index 84%
rename from sqlobject/src/main/java/org/jdbi/v3/sqlobject/customizer/internal/BindPropertiesFactory.java
rename to sqlobject/src/main/java/org/jdbi/v3/sqlobject/customizer/internal/BindPojoFactory.java
index 3b85f73708..af837ce305 100644
--- a/sqlobject/src/main/java/org/jdbi/v3/sqlobject/customizer/internal/BindPropertiesFactory.java
+++ b/sqlobject/src/main/java/org/jdbi/v3/sqlobject/customizer/internal/BindPojoFactory.java
@@ -18,11 +18,11 @@
 import java.lang.reflect.Parameter;
 import java.lang.reflect.Type;
 
-import org.jdbi.v3.sqlobject.customizer.BindProperties;
+import org.jdbi.v3.sqlobject.customizer.BindPojo;
 import org.jdbi.v3.sqlobject.customizer.SqlStatementCustomizerFactory;
 import org.jdbi.v3.sqlobject.customizer.SqlStatementParameterCustomizer;
 
-public class BindPropertiesFactory implements SqlStatementCustomizerFactory {
+public class BindPojoFactory implements SqlStatementCustomizerFactory {
     @Override
     public SqlStatementParameterCustomizer createForParameter(Annotation annotation,
                                                               Class<?> sqlObjectType,
@@ -30,13 +30,13 @@ public SqlStatementParameterCustomizer createForParameter(Annotation annotation,
                                                               Parameter param,
                                                               int index,
                                                               Type type) {
-        BindProperties bind = (BindProperties) annotation;
+        BindPojo bind = (BindPojo) annotation;
         return (stmt, bean) -> {
             String prefix = bind.value();
             if (prefix.isEmpty()) {
-                stmt.bindProperties(bean);
+                stmt.bindPojo(bean);
             } else {
-                stmt.bindProperties(prefix, bean);
+                stmt.bindPojo(prefix, bean);
             }
         };
     }
diff --git a/sqlobject/src/test/java/org/jdbi/v3/sqlobject/TestBindProperties.java b/sqlobject/src/test/java/org/jdbi/v3/sqlobject/TestBindProperties.java
index 3e92b558a9..7c830edd0a 100644
--- a/sqlobject/src/test/java/org/jdbi/v3/sqlobject/TestBindProperties.java
+++ b/sqlobject/src/test/java/org/jdbi/v3/sqlobject/TestBindProperties.java
@@ -18,9 +18,9 @@
 import org.jdbi.v3.core.Handle;
 import org.jdbi.v3.core.mapper.ImmutableTrain;
 import org.jdbi.v3.core.mapper.ImmutablesTest.Train;
-import org.jdbi.v3.core.mapper.reflect.ImmutablesMapperFactory;
+import org.jdbi.v3.core.mapper.immutables.ImmutablesPlugin;
 import org.jdbi.v3.core.rule.H2DatabaseRule;
-import org.jdbi.v3.sqlobject.customizer.BindProperties;
+import org.jdbi.v3.sqlobject.customizer.BindPojo;
 import org.jdbi.v3.sqlobject.statement.SqlQuery;
 import org.jdbi.v3.sqlobject.statement.SqlUpdate;
 import org.junit.Before;
@@ -31,7 +31,9 @@
 
 public class TestBindProperties {
     @Rule
-    public H2DatabaseRule dbRule = new H2DatabaseRule().withPlugin(new SqlObjectPlugin());
+    public H2DatabaseRule dbRule = new H2DatabaseRule()
+        .withPlugin(new SqlObjectPlugin())
+        .withPlugin(ImmutablesPlugin.forImmutable(Train.class));
 
     private Handle h;
 
@@ -40,7 +42,6 @@ public class TestBindProperties {
     @Before
     public void setUp() {
         h = dbRule.getSharedHandle();
-        h.registerRowMapper(ImmutablesMapperFactory.mapImmutable(Train.class, ImmutableTrain.class, ImmutableTrain::builder));
         h.execute("create table train (name varchar, carriages int, observation_car boolean)");
 
         dao = h.attach(Dao.class);
@@ -63,7 +64,7 @@ public void testBindBean() {
 
     public interface Dao {
         @SqlUpdate("insert into train(name, carriages, observation_car) values (:name, :carriages, :observationCar)")
-        int insert(@BindProperties Train train);
+        int insert(@BindPojo Train train);
 
         @SqlQuery("select * from train")
         List<Train> getTrains();