diff --git a/README.md b/README.md
index e250795..2edf655 100644
--- a/README.md
+++ b/README.md
@@ -12,8 +12,8 @@ This [Dapper](https://github.com/SamSaffron/dapper-dot-net/) extension allows yo
 <hr>
 
 ### Usage
-Mapping properties:
-```
+#### Mapping properties using `EntityMap<TEntity>`
+```csharp
 public class ProductMap : EntityMap<Product>
 {
 	public ProductMap()
@@ -27,13 +27,54 @@ public class ProductMap : EntityMap<Product>
 }
 ```
 
-Initializing Dapper.FluentMap:
-
-```
+Initialization: 
+```csharp
 FluentMapper.Intialize(config =>
 					   {
-						   config.AddEntityMap(new ProductMap());
+						   config.AddMap(new ProductMap());
 					   });
 ```
 
-That's it. When querying the database using Dapper, the product name from column `strName` will be mapped to the `Name` property of the `Product` entity. `LastModifed` won't be mapped since we marked it as 'ignored'.
+#### Mapping properties using conventions
+
+You can create a convention by creating a class which derives from the `Convention` class. In the contructor you can configure the property conventions:
+```csharp
+public class TypePrefixConvention : Convention
+{
+    public TypePrefixConvention()
+    {
+        // Map all properties of type int and with the name 'id' to column 'autID'.
+        Properties<int>()
+            .Where(c => c.Name.ToLower() == "id")
+            .Configure(c => c.HasColumnName("autID"));
+
+        // Prefix all properties of type string with 'str' when mapping to column names.
+        Properties<string>()
+            .Configure(c => c.HasPrefix("str"));
+
+        // Prefix all properties of type int with 'int' when mapping to column names.
+        Properties<int>()
+            .Configure(c => c.HasPrefix("int"));
+    }
+}
+```
+
+When initializing Dapper.FluentMap with conventions, the entities on which a convention applies must be configured. You can choose to either configure the entities explicitly or scan a specified, or the current assembly.
+
+```csharp
+FluentMapper.Intialize(config =>
+	{
+		// Configure entities explicitly.
+		config.AddConvention(new TypePrefixConvention())
+				.ForEntity<Product>()
+				.ForEntity<Order>;
+
+		// Configure all entities in a certain assembly with an optional namespaces filter.
+		config.AddConvention(new TypePrefixConvention())
+				.ForEntitiesInAssembly(typeof (Product).Assembly, "App.Domain.Model");
+
+		// Configure all entities in the current assembly with an optional namespaces filter.
+		config.AddConvention(new TypePrefixConvention())
+				.ForEntitiesInCurrentAssembly("App.Domain.Model.Catalog", "App.Domain.Model.Order");
+	});
+```
diff --git a/Dapper.FluentMap.1.0.0.nupkg b/nuget/Dapper.FluentMap.1.0.0.nupkg
similarity index 100%
rename from Dapper.FluentMap.1.0.0.nupkg
rename to nuget/Dapper.FluentMap.1.0.0.nupkg
diff --git a/Dapper.FluentMap.1.0.1.nupkg b/nuget/Dapper.FluentMap.1.0.1.nupkg
similarity index 100%
rename from Dapper.FluentMap.1.0.1.nupkg
rename to nuget/Dapper.FluentMap.1.0.1.nupkg
diff --git a/Dapper.FluentMap.1.0.2.nupkg b/nuget/Dapper.FluentMap.1.0.2.nupkg
similarity index 100%
rename from Dapper.FluentMap.1.0.2.nupkg
rename to nuget/Dapper.FluentMap.1.0.2.nupkg
diff --git a/nuget/Dapper.FluentMap.1.1.0.nupkg b/nuget/Dapper.FluentMap.1.1.0.nupkg
new file mode 100644
index 0000000..e5620f2
Binary files /dev/null and b/nuget/Dapper.FluentMap.1.1.0.nupkg differ
diff --git a/src/Dapper.FluentMap/Configuration/FluentConventionConfiguration.cs b/src/Dapper.FluentMap/Configuration/FluentConventionConfiguration.cs
new file mode 100644
index 0000000..434b2e7
--- /dev/null
+++ b/src/Dapper.FluentMap/Configuration/FluentConventionConfiguration.cs
@@ -0,0 +1,142 @@
+using System;
+using System.ComponentModel;
+using System.Linq;
+using System.Reflection;
+using Dapper.FluentMap.Conventions;
+using Dapper.FluentMap.Mapping;
+using Dapper.FluentMap.Utils;
+
+namespace Dapper.FluentMap.Configuration
+{
+    /// <summary>
+    /// Defines methods for configuring conventions.
+    /// </summary>
+    public class FluentConventionConfiguration
+    {
+        private readonly Convention _convention;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FluentConventionConfiguration"/> class,
+        /// allowing configuration of conventions.
+        /// </summary>
+        /// <param name="convention">The convention.</param>
+        public FluentConventionConfiguration(Convention convention)
+        {
+            _convention = convention;
+        }
+
+        /// <summary>
+        /// Configures the current covention for the specified entity type.
+        /// </summary>
+        /// <typeparam name="T">The type of the entity.</typeparam>
+        /// <returns>The current instance of <see cref="T:Dapper.FluentMap.Conventions.FluentMapConventionConfiguration"/>.</returns>
+        public FluentConventionConfiguration ForEntity<T>()
+        {
+            Type type = typeof (T);
+            MapProperties(type);
+
+            FluentMapper.TypeConventions.AddOrUpdate(type, _convention);
+            FluentMapper.AddConventionTypeMap<T>();
+            return this;
+        }
+
+        /// <summary>
+        /// Configures the current convention for all the entities in current assembly filtered by the specified namespaces.
+        /// </summary>
+        /// <param name="namespaces">An array of namespaces which filter the types in the current assembly. This parameter is optional.</param>
+        /// <returns>The current instance of <see cref="T:Dapper.FluentMap.Conventions.FluentMapConventionConfiguration"/>.</returns>
+        public FluentConventionConfiguration ForEntitiesInCurrentAssembly(params string[] namespaces)
+        {
+            foreach (var type in Assembly.GetCallingAssembly()
+                                         .GetExportedTypes()
+                                         .Where(type => namespaces.Length == 0 || namespaces.Any(n => type.Namespace == n)))
+            {
+                MapProperties(type);
+                FluentMapper.TypeConventions.AddOrUpdate(type, _convention);
+                FluentMapper.AddConventionTypeMap(type);
+            }
+
+            return this;
+        }
+
+        /// <summary>
+        /// Configures the current convention for all entities in the specified assembly filtered by the specified namespaces.
+        /// </summary>
+        /// <param name="assembly">The assembly to scan for entities.</param>
+        /// <param name="namespaces">An array of namespaces which filter the types in <paramref name="assembly"/>. This parameter is optional.</param>
+        /// <returns>The current instance of <see cref="T:Dapper.FluentMap.Conventions.FluentMapConventionConfiguration"/>.</returns>
+        public FluentConventionConfiguration ForEntitiesInAssembly(Assembly assembly, params string[] namespaces)
+        {
+            foreach (var type in assembly.GetExportedTypes().Where(t => namespaces.Any(n => n.Contains(t.Namespace))))
+            {
+                MapProperties(type);
+                FluentMapper.TypeConventions.AddOrUpdate(type, _convention);
+                FluentMapper.AddConventionTypeMap(type);
+            }
+
+            return this;
+        }
+
+        private void MapProperties(Type type)
+        {
+            var properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
+
+            foreach (var property in properties)
+            {
+                // Find the convention configurations for the convetion with either none or matching property predicates.
+                foreach (var config in _convention.ConventionConfigurations
+                                                  .Where(c => c.PropertyPredicates.Count <= 0 ||
+                                                              c.PropertyPredicates.All(e => e(property))))
+                {
+                    if (!string.IsNullOrEmpty(config.Config.ColumnName))
+                    {
+                        AddConventionPropertyMap(property, config.Config.ColumnName);
+                        break;
+                    }
+
+                    if (!string.IsNullOrEmpty(config.Config.Prefix))
+                    {
+                        AddConventionPropertyMap(property, config.Config.Prefix + property.Name);
+                        break;
+                    }
+                }
+            }
+        }
+
+        private void AddConventionPropertyMap(PropertyInfo property, string columnName)
+        {
+            var map = new PropertyMap(property, columnName);
+            _convention.PropertyMaps.Add(map);
+        }
+
+        #region EditorBrowsableStates
+        /// <inheritdoc/>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public override string ToString()
+        {
+            return base.ToString();
+        }
+
+        /// <inheritdoc/>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public override bool Equals(object obj)
+        {
+            return base.Equals(obj);
+        }
+
+        /// <inheritdoc/>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();
+        }
+
+        /// <inheritdoc/>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public new Type GetType()
+        {
+            return base.GetType();
+        }
+        #endregion
+    }
+}
diff --git a/src/Dapper.FluentMap/Configuration/FluentMapConfiguration.cs b/src/Dapper.FluentMap/Configuration/FluentMapConfiguration.cs
new file mode 100644
index 0000000..5f48013
--- /dev/null
+++ b/src/Dapper.FluentMap/Configuration/FluentMapConfiguration.cs
@@ -0,0 +1,67 @@
+using System;
+using System.ComponentModel;
+using Dapper.FluentMap.Conventions;
+using Dapper.FluentMap.Mapping;
+
+namespace Dapper.FluentMap.Configuration
+{
+    /// <summary>
+    /// Defines methods for configuring Dapper.FluentMap.
+    /// </summary>
+    public class FluentMapConfiguration
+    {
+        /// <summary>
+        /// Adds the specified <see cref="T:Dapper.FluentMap.Mapping.EntityMap"/> to the configuration of Dapper.FluentMap.
+        /// </summary>
+        /// <typeparam name="TEntity">The type argument of the entity.</typeparam>
+        /// <param name="mapper">An instance of the EntityMap classs containing the entity mapping configuration.</param>
+        public void AddMap<TEntity>(EntityMap<TEntity> mapper) where TEntity : class
+        {
+            FluentMapper.EntityMappers.Add(typeof (TEntity), mapper);
+            FluentMapper.AddTypeMap<TEntity>();
+        }
+
+        /// <summary>
+        /// Adds the specified <see cref="T:Dapper.FluentMap.Conventions.Convention"/> to the configuration of Dapper.FluentMap.
+        /// </summary>
+        /// <param name="convention">An instance of the <see cref="T:Dapper.FluentMap.Conventions.Convention"/> class.</param>
+        /// <returns>
+        /// An instance of <see cref="T:Dapper.FluentMap.Conventions.FluentMapConventionConfiguration"/> 
+        /// which allows configuration of the convention.
+        /// </returns>
+        public FluentConventionConfiguration AddConvention(Convention convention)
+        {
+            return new FluentConventionConfiguration(convention);
+        }
+
+        #region EditorBrowsableStates
+        /// <inheritdoc/>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public override string ToString()
+        {
+            return base.ToString();
+        }
+
+        /// <inheritdoc/>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public override bool Equals(object obj)
+        {
+            return base.Equals(obj);
+        }
+
+        /// <inheritdoc/>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();
+        }
+
+        /// <inheritdoc/>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public new Type GetType()
+        {
+            return base.GetType();
+        }
+        #endregion
+    }
+}
diff --git a/src/Dapper.FluentMap/Conventions/Convention.cs b/src/Dapper.FluentMap/Conventions/Convention.cs
new file mode 100644
index 0000000..2e2aa6a
--- /dev/null
+++ b/src/Dapper.FluentMap/Conventions/Convention.cs
@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using Dapper.FluentMap.Mapping;
+
+namespace Dapper.FluentMap.Conventions
+{
+    /// <summary>
+    /// Represents a convention for mapping entity properties to column names.
+    /// </summary>
+    public abstract class Convention
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="T:Dapper.FluentMap.Conventions.Convention"/> class.
+        /// </summary>
+        protected Convention()
+        {
+            ConventionConfigurations = new List<PropertyConventionConfiguration>();
+            PropertyMaps = new List<PropertyMap>();
+        }
+
+        internal IList<PropertyConventionConfiguration> ConventionConfigurations { get; private set; }
+
+        internal IList<PropertyMap> PropertyMaps { get; private set; }
+
+        /// <summary>
+        /// Configures a convention that applies on all properties of the entity.
+        /// </summary>
+        /// <returns>A configuration object for the convention.</returns>
+        protected PropertyConventionConfiguration Properties()
+        {
+            var config = new PropertyConventionConfiguration();
+            ConventionConfigurations.Add(config);
+
+            return config;
+        }
+
+        /// <summary>
+        /// Configures a convention that applies on all the properties of a specified type of the entity.
+        /// </summary>
+        /// <typeparam name="T">The type of the properties that the convention will apply to.</typeparam>
+        /// <returns>A configuration object for the convention.</returns>
+        protected PropertyConventionConfiguration Properties<T>()
+        {
+            // Get the underlying type for a nullale type. (int? -> int)
+            Type underlyingType = Nullable.GetUnderlyingType(typeof (T)) ?? typeof (T);
+            var config = new PropertyConventionConfiguration().Where(p => p.PropertyType == underlyingType);
+            ConventionConfigurations.Add(config);
+
+            return config;
+        }
+
+        #region EditorBrowsableStates
+        /// <inheritdoc/>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public override string ToString()
+        {
+            return base.ToString();
+        }
+
+        /// <inheritdoc/>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public override bool Equals(object obj)
+        {
+            return base.Equals(obj);
+        }
+
+        /// <inheritdoc/>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();
+        }
+
+        /// <inheritdoc/>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public new Type GetType()
+        {
+            return base.GetType();
+        }
+        #endregion
+    }
+}
diff --git a/src/Dapper.FluentMap/Conventions/ConventionPropertyConfiguration.cs b/src/Dapper.FluentMap/Conventions/ConventionPropertyConfiguration.cs
new file mode 100644
index 0000000..032b6dc
--- /dev/null
+++ b/src/Dapper.FluentMap/Conventions/ConventionPropertyConfiguration.cs
@@ -0,0 +1,67 @@
+using System;
+using System.ComponentModel;
+
+namespace Dapper.FluentMap.Conventions
+{
+    /// <summary>
+    /// Represents configuration of a property via conventions.
+    /// </summary>
+    public class ConventionPropertyConfiguration
+    {
+        internal string ColumnName { get; private set; }
+
+        internal string Prefix { get; private set; }
+
+        /// <summary>
+        /// Configures the name of the database column used to store the property.
+        /// </summary>
+        /// <param name="columnName">The name of the database column.</param>
+        /// <returns>The same instance of <see cref="T:Dapper.FluentMap.Conventions.ConventionPropertyConfiguration"/>.</returns>
+        public ConventionPropertyConfiguration HasColumnName(string columnName)
+        {
+            ColumnName = columnName;
+            return this;
+        }
+
+        /// <summary>
+        /// Configures the prefix of the database column used to store the property.
+        /// </summary>
+        /// <param name="prefix">The prefix of the database column.</param>
+        /// <returns>The same instance of <see cref="T:Dapper.FluentMap.Conventions.ConventionPropertyConfiguration"/>.</returns>
+        public ConventionPropertyConfiguration HasPrefix(string prefix)
+        {
+            Prefix = prefix;
+            return this;
+        }
+        
+        #region EditorBrowsableStates
+        /// <inheritdoc/>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public override string ToString()
+        {
+            return base.ToString();
+        }
+
+        /// <inheritdoc/>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public override bool Equals(object obj)
+        {
+            return base.Equals(obj);
+        }
+
+        /// <inheritdoc/>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();
+        }
+
+        /// <inheritdoc/>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public new Type GetType()
+        {
+            return base.GetType();
+        }
+        #endregion
+    }
+}
diff --git a/src/Dapper.FluentMap/Conventions/PropertyConventionConfiguration.cs b/src/Dapper.FluentMap/Conventions/PropertyConventionConfiguration.cs
new file mode 100644
index 0000000..08da724
--- /dev/null
+++ b/src/Dapper.FluentMap/Conventions/PropertyConventionConfiguration.cs
@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Reflection;
+
+namespace Dapper.FluentMap.Conventions
+{
+    /// <summary>
+    /// Represents the configuration for a convention.
+    /// </summary>
+    public class PropertyConventionConfiguration
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PropertyConventionConfiguration"/> class, 
+        /// allowing configuration for a convention.
+        /// </summary>
+        public PropertyConventionConfiguration()
+        {
+            PropertyPredicates = new List<Func<PropertyInfo, bool>>();
+        }
+
+        internal IList<Func<PropertyInfo, bool>> PropertyPredicates { get; private set; }
+
+        internal ConventionPropertyConfiguration Config { get; private set; }
+
+        /// <summary>
+        /// Filters the properties that this convention applies to based on a predicate.
+        /// </summary>
+        /// <param name="predicate">A function to test each property for a condition.</param>
+        /// <returns>The same instance of <see cref="T:Dapper.FluentMap.Conventions.PropertyConventionConfiguration"/>.</returns>
+        public PropertyConventionConfiguration Where(Func<PropertyInfo, bool> predicate)
+        {
+            PropertyPredicates.Add(predicate);
+            return this;
+        }
+
+        /// <summary>
+        /// Configures the properties that this convention applies to.
+        /// </summary>
+        /// <param name="configure">An action that performs configuration against <see cref="T:Dapper.FluentMap.Conventions.ConventionPropertyConfiguration"/>.</param>
+        public void Configure(Action<ConventionPropertyConfiguration> configure)
+        {
+            var config = new ConventionPropertyConfiguration();
+            Config = config;
+            configure(config);
+        }
+
+        #region EditorBrowsableStates
+        /// <inheritdoc/>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public override string ToString()
+        {
+            return base.ToString();
+        }
+
+        /// <inheritdoc/>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public override bool Equals(object obj)
+        {
+            return base.Equals(obj);
+        }
+
+        /// <inheritdoc/>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();
+        }
+
+        /// <inheritdoc/>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public new Type GetType()
+        {
+            return base.GetType();
+        }
+        #endregion
+    }
+}
diff --git a/src/Dapper.FluentMap/Dapper.FluentMap.csproj b/src/Dapper.FluentMap/Dapper.FluentMap.csproj
index 63060ac..af74e48 100644
--- a/src/Dapper.FluentMap/Dapper.FluentMap.csproj
+++ b/src/Dapper.FluentMap/Dapper.FluentMap.csproj
@@ -45,14 +45,20 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="EntityMap.cs" />
-    <Compile Include="FluentMapConfiguration.cs" />
+    <Compile Include="Conventions\Convention.cs" />
+    <Compile Include="Conventions\ConventionPropertyConfiguration.cs" />
+    <Compile Include="Conventions\PropertyConventionConfiguration.cs" />
+    <Compile Include="Configuration\FluentConventionConfiguration.cs" />
+    <Compile Include="Mapping\EntityMap.cs" />
+    <Compile Include="Configuration\FluentMapConfiguration.cs" />
     <Compile Include="FluentMapper.cs" />
-    <Compile Include="FluentMapTypeMap.cs" />
-    <Compile Include="MultiTypeMap.cs" />
+    <Compile Include="TypeMaps\FluentConventionTypeMap.cs" />
+    <Compile Include="TypeMaps\FluentTypeMap.cs" />
+    <Compile Include="TypeMaps\MultiTypeMap.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="PropertyMap.cs" />
-    <Compile Include="ReflectionHelper.cs" />
+    <Compile Include="Mapping\PropertyMap.cs" />
+    <Compile Include="Utils\DictionaryExtensions.cs" />
+    <Compile Include="Utils\ReflectionHelper.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config">
diff --git a/src/Dapper.FluentMap/FluentMapConfiguration.cs b/src/Dapper.FluentMap/FluentMapConfiguration.cs
deleted file mode 100644
index 704a102..0000000
--- a/src/Dapper.FluentMap/FluentMapConfiguration.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-namespace Dapper.FluentMap
-{
-    /// <summary>
-    /// Defines methods for configuring Dapper.FluentMap.
-    /// </summary>
-    public interface IFluentMapConfiguration
-    {
-        /// <summary>
-        /// Adds the specified EntityMap to the configuration of Dapper.FluentMap.
-        /// </summary>
-        /// <typeparam name="TEntity">The type argument of the entity.</typeparam>
-        /// <param name="mapper">An instance of the EntityMap classs containing the entity mapping configuration.</param>
-        void AddEntityMap<TEntity>(EntityMap<TEntity> mapper) where TEntity : class;
-    }
-
-    public class FluentMapConfiguration : IFluentMapConfiguration
-    {
-        public void AddEntityMap<TEntity>(EntityMap<TEntity> mapper) where TEntity : class
-        {
-            FluentMapper.EntityMappers.Add(typeof (TEntity), mapper);
-            FluentMapper.AddTypeMap<TEntity>();
-        }
-    }
-}
diff --git a/src/Dapper.FluentMap/FluentMapper.cs b/src/Dapper.FluentMap/FluentMapper.cs
index 358f648..16af4b9 100644
--- a/src/Dapper.FluentMap/FluentMapper.cs
+++ b/src/Dapper.FluentMap/FluentMapper.cs
@@ -1,5 +1,9 @@
 using System;
 using System.Collections.Generic;
+using Dapper.FluentMap.Configuration;
+using Dapper.FluentMap.Conventions;
+using Dapper.FluentMap.Mapping;
+using Dapper.FluentMap.TypeMaps;
 
 namespace Dapper.FluentMap
 {
@@ -8,25 +12,30 @@ namespace Dapper.FluentMap
     /// </summary>
     public static class FluentMapper
     {
-        private static readonly IFluentMapConfiguration _configuration = new FluentMapConfiguration();
+        private static readonly FluentMapConfiguration _configuration = new FluentMapConfiguration();
 
         /// <summary>
         /// Gets the dictionary containing the entity mapping per entity type.
         /// </summary>
         internal static readonly IDictionary<Type, EntityMap> EntityMappers = new Dictionary<Type, EntityMap>();
 
+        /// <summary>
+        /// Gets the dictionairy containing the conventions per entity type.
+        /// </summary>
+        internal static readonly IDictionary<Type, IList<Convention>> TypeConventions = new Dictionary<Type, IList<Convention>>();
+
         /// <summary>
         /// Initializes Dapper.FluentMap with the specified configuration. 
         /// This is method should be called when the application starts or when the first mapping is needed.
         /// </summary>
         /// <param name="configure">A callback containing the configuration of Dapper.FluentMap.</param>
-        public static void Intialize(Action<IFluentMapConfiguration> configure)
+        public static void Intialize(Action<FluentMapConfiguration> configure)
         {
             configure(_configuration);
         }
 
         /// <summary>
-        /// Registers a Dapper type map for the specified <typeparamref name="TEntity"/>.
+        /// Registers a Dapper type map using fluent mapping for the specified <typeparamref name="TEntity"/>.
         /// </summary>
         /// <typeparam name="TEntity">The type of the entity.</typeparam>
         internal static void AddTypeMap<TEntity>()
@@ -35,7 +44,7 @@ internal static void AddTypeMap<TEntity>()
         }
 
         /// <summary>
-        /// Registers a Dapper type map for the specified <paramref name="entityType"/>.
+        /// Registers a Dapper type map using fluent mapping for the specified <paramref name="entityType"/>.
         /// </summary>
         /// <param name="entityType">The type of the entity.</param>
         internal static void AddTypeMap(Type entityType)
@@ -43,5 +52,24 @@ internal static void AddTypeMap(Type entityType)
             var instance = (SqlMapper.ITypeMap)Activator.CreateInstance(typeof (FluentMapTypeMap<>).MakeGenericType(entityType));
             SqlMapper.SetTypeMap(entityType, instance);
         }
+
+        /// <summary>
+        /// Registers a Dapper type map using conventions for the specified <typeparamref name="TEntity"/>.
+        /// </summary>
+        /// <typeparam name="TEntity">The type of the entity.</typeparam>
+        internal static void AddConventionTypeMap<TEntity>()
+        {
+            SqlMapper.SetTypeMap(typeof (TEntity), new FluentConventionTypeMap<TEntity>());
+        }
+
+        /// <summary>
+        /// Registers a Dapper type map using conventions for the specified <paramref name="entityType"/>.
+        /// </summary>
+        /// <param name="entityType">The type of the entity.</param>
+        internal static void AddConventionTypeMap(Type entityType)
+        {
+            var instance = (SqlMapper.ITypeMap)Activator.CreateInstance(typeof (FluentConventionTypeMap<>).MakeGenericType(entityType));
+            SqlMapper.SetTypeMap(entityType, instance);
+        }
     }
 }
diff --git a/src/Dapper.FluentMap/EntityMap.cs b/src/Dapper.FluentMap/Mapping/EntityMap.cs
similarity index 96%
rename from src/Dapper.FluentMap/EntityMap.cs
rename to src/Dapper.FluentMap/Mapping/EntityMap.cs
index 22940ff..ac4e5af 100644
--- a/src/Dapper.FluentMap/EntityMap.cs
+++ b/src/Dapper.FluentMap/Mapping/EntityMap.cs
@@ -2,8 +2,9 @@
 using System.Collections.Generic;
 using System.Linq.Expressions;
 using System.Reflection;
+using Dapper.FluentMap.Utils;
 
-namespace Dapper.FluentMap
+namespace Dapper.FluentMap.Mapping
 {
     /// <summary>
     /// Represents a non-typed mapping of an entity.
diff --git a/src/Dapper.FluentMap/Mapping/PropertyMap.cs b/src/Dapper.FluentMap/Mapping/PropertyMap.cs
new file mode 100644
index 0000000..43bc3c5
--- /dev/null
+++ b/src/Dapper.FluentMap/Mapping/PropertyMap.cs
@@ -0,0 +1,102 @@
+using System;
+using System.ComponentModel;
+using System.Reflection;
+
+namespace Dapper.FluentMap.Mapping
+{
+    /// <summary>
+    /// Represents the mapping of a property.
+    /// </summary>
+    public class PropertyMap
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="T:Dapper.FluentMap.PropertyMap"/> using 
+        /// the specified <see cref="T:System.Reflecion.PropertyInfo"/> object representing the property to map.
+        /// </summary>
+        /// <param name="info">The <see cref="T:System.Reflection.PropertyInfo"/> object representing to the property to map.</param>
+        internal PropertyMap(PropertyInfo info)
+        {
+            PropertyInfo = info;
+            ColumnName = info.Name;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="T:Dapper.FluentMap.PropertyMap"/> using 
+        /// the specified <see cref="T:System.Reflecion.PropertyInfo"/> object representing the property to map 
+        /// and column name to map the property to.
+        /// </summary>
+        /// <param name="info">The <see cref="T:System.Reflection.PropertyInfo"/> object representing to the property to map.</param>
+        /// <param name="columnName">The column name in the database to map the property to.</param>
+        internal PropertyMap(PropertyInfo info, string columnName)
+        {
+            PropertyInfo = info;
+            ColumnName = columnName;
+        }
+
+        /// <summary>
+        /// Gets the name of the column in the data store.
+        /// </summary>
+        internal string ColumnName { get; private set; }
+
+        /// <summary>
+        /// Gets a value indicating wether the property should be ignored when mapping.
+        /// </summary>
+        internal bool Ignored { get; private set; }
+
+        /// <summary>
+        /// Gets the <see cref="T:System.Reflecion.PropertyInfo"/> object for the current property.
+        /// </summary>
+        internal PropertyInfo PropertyInfo { get; private set; }
+
+        /// <summary>
+        /// Maps the current property to the specified column name.
+        /// </summary>
+        /// <param name="columnName">The name of the column in the data store.</param>
+        /// <returns>The current <see cref="T:Dapper.FluentMap.Mapping.PropertyMap"/> instance. This enables a fluent API.</returns>
+        public PropertyMap ToColumn(string columnName)
+        {
+            ColumnName = columnName;
+            return this;
+        }
+
+        /// <summary>
+        /// Marks the current property as ignored, resulting in the property not being mapped by Dapper.
+        /// </summary>
+        /// <returns>The current <see cref="T:Dapper.FluentMap.Mapping.PropertyMap"/> instance. This enables a fluent API.</returns>
+        public PropertyMap Ignore()
+        {
+            Ignored = true;
+            return this;
+        }
+        
+        #region EditorBrowsableStates
+        /// <inheritdoc/>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public override string ToString()
+        {
+            return base.ToString();
+        }
+
+        /// <inheritdoc/>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public override bool Equals(object obj)
+        {
+            return base.Equals(obj);
+        }
+
+        /// <inheritdoc/>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();
+        }
+
+        /// <inheritdoc/>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public new Type GetType()
+        {
+            return base.GetType();
+        }
+        #endregion
+    }
+}
diff --git a/src/Dapper.FluentMap/Properties/AssemblyInfo.cs b/src/Dapper.FluentMap/Properties/AssemblyInfo.cs
index a511002..0422143 100644
--- a/src/Dapper.FluentMap/Properties/AssemblyInfo.cs
+++ b/src/Dapper.FluentMap/Properties/AssemblyInfo.cs
@@ -32,5 +32,4 @@
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.2.0")]
-[assembly: AssemblyFileVersion("1.0.2.0")]
+[assembly: AssemblyVersion("1.1.0")]
diff --git a/src/Dapper.FluentMap/PropertyMap.cs b/src/Dapper.FluentMap/PropertyMap.cs
deleted file mode 100644
index 883bffd..0000000
--- a/src/Dapper.FluentMap/PropertyMap.cs
+++ /dev/null
@@ -1,54 +0,0 @@
-using System.Reflection;
-
-namespace Dapper.FluentMap
-{
-    public class PropertyMap
-    {
-        /// <summary>
-        /// Initializes a new instance of the <see cref="T:Dapper.FluentMap.PropertyMap"/> using 
-        /// the specified <see cref="T:System.Reflecion.PropertyInfo"/> object representing the property to map.
-        /// </summary>
-        /// <param name="info"></param>
-        public PropertyMap(PropertyInfo info)
-        {
-            PropertyInfo = info;
-            ColumnName = info.Name;
-        }
-
-        /// <summary>
-        /// Gets the name of the column in the data store.
-        /// </summary>
-        internal string ColumnName { get; private set; }
-
-        /// <summary>
-        /// Gets a value indicating wether the property should be ignored when mapping.
-        /// </summary>
-        internal bool Ignored { get; private set; }
-
-        /// <summary>
-        /// Gets the <see cref="T:System.Reflecion.PropertyInfo"/> object for the current property.
-        /// </summary>
-        internal PropertyInfo PropertyInfo { get; private set; }
-
-        /// <summary>
-        /// Maps the current property to the specified column name.
-        /// </summary>
-        /// <param name="columnName">The name of the column in the data store.</param>
-        /// <returns>The current <see cref="T:Dapper.FluentMap.PropertyMap"/> instance. This enables a fluent API.</returns>
-        public PropertyMap ToColumn(string columnName)
-        {
-            ColumnName = columnName;
-            return this;
-        }
-
-        /// <summary>
-        /// Marks the current property as ignored, resulting in the property not being mapped by Dapper.
-        /// </summary>
-        /// <returns>The current <see cref="T:Dapper.FluentMap.PropertyMap"/> instance. This enables a fluent API.</returns>
-        public PropertyMap Ignore()
-        {
-            Ignored = true;
-            return this;
-        }
-    }
-}
diff --git a/src/Dapper.FluentMap/TypeMaps/FluentConventionTypeMap.cs b/src/Dapper.FluentMap/TypeMaps/FluentConventionTypeMap.cs
new file mode 100644
index 0000000..073e27a
--- /dev/null
+++ b/src/Dapper.FluentMap/TypeMaps/FluentConventionTypeMap.cs
@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using Dapper.FluentMap.Conventions;
+
+namespace Dapper.FluentMap.TypeMaps
+{
+    /// <summary>
+    /// Represents a Dapper type mapping strategy which first tries to map the type using a <see cref="T:Dapper.CustomPropertyTypeMap"/>
+    /// with the configured conventions. <see cref="T:Dapper.DefaultTypeMap"/> is used as fallback mapping strategy.
+    /// </summary>
+    /// <typeparam name="TEntity">The type of the entity.</typeparam>
+    internal class FluentConventionTypeMap<TEntity> : MultiTypeMap
+    {
+        /// <summary>
+        /// Intializes a new instance of the <see cref="T:Dapper.FluentMap.FluentMapTypeMapper"/> class 
+        /// which uses the <see cref="T:Dapper.CustomPropertyTypeMap"/> and <see cref="T:Dapper.DefaultTypeMap"/>
+        /// as mapping strategies.
+        /// </summary>
+        public FluentConventionTypeMap()
+            : base(new CustomPropertyTypeMap(typeof (TEntity), GetPropertyInfo), new DefaultTypeMap(typeof (TEntity)))
+        {
+        }
+
+        private static PropertyInfo GetPropertyInfo(Type type, string columnName)
+        {
+            string cacheKey = string.Format("{0};{1}", type.FullName, columnName);
+
+            PropertyInfo info;
+            if (TypePropertyMapCache.TryGetValue(cacheKey, out info))
+            {
+                return info;
+            }
+
+            IList<Convention> conventions;
+            if (FluentMapper.TypeConventions.TryGetValue(type, out conventions))
+            {
+                foreach (var convention in conventions)
+                {
+                    var maps = convention.PropertyMaps.Where(c => c.ColumnName == columnName).ToList();
+
+                    if (maps.Count > 1)
+                    {
+                        const string msg = "Finding mappings for column '{0}' yielded more than 1 PropertyMap. The conventions should be more specific. Type: '{1}'. Convention: '{2}'.";
+                        throw new Exception(string.Format(msg, columnName, type, convention));
+                    }
+
+                    if (maps.Count == 0)
+                    {
+                        return null;
+                    }
+
+                    info = maps[0].PropertyInfo;
+                    TypePropertyMapCache.Add(cacheKey, info);
+                    return info;
+                }
+            }
+
+            // If we get here, the property was not mapped.
+            TypePropertyMapCache.Add(cacheKey, null);
+            return null;
+        }
+    }
+}
diff --git a/src/Dapper.FluentMap/FluentMapTypeMap.cs b/src/Dapper.FluentMap/TypeMaps/FluentTypeMap.cs
similarity index 84%
rename from src/Dapper.FluentMap/FluentMapTypeMap.cs
rename to src/Dapper.FluentMap/TypeMaps/FluentTypeMap.cs
index 223b8d0..5623710 100644
--- a/src/Dapper.FluentMap/FluentMapTypeMap.cs
+++ b/src/Dapper.FluentMap/TypeMaps/FluentTypeMap.cs
@@ -1,15 +1,16 @@
 using System;
 using System.Linq;
 using System.Reflection;
+using Dapper.FluentMap.Mapping;
 
-namespace Dapper.FluentMap
+namespace Dapper.FluentMap.TypeMaps
 {
     /// <summary>
     /// Represents a Dapper type mapping strategy which first tries to map the type using a <see cref="T:Dapper.CustomPropertyTypeMap"/>, 
     /// if that fails, the <see cref="T:Dapper.DefaultTypeMap"/> is used as mapping strategy.
     /// </summary>
     /// <typeparam name="TEntity">The type of the entity.</typeparam>
-    public class FluentMapTypeMap<TEntity> : MultiTypeMap
+    internal class FluentMapTypeMap<TEntity> : MultiTypeMap
     {
         /// <summary>
         /// Intializes a new instance of the <see cref="T:Dapper.FluentMap.FluentMapTypeMapper"/> class 
@@ -26,7 +27,7 @@ private static PropertyInfo GetPropertyInfo(Type type, string columnName)
             string cacheKey = string.Format("{0};{1}", type.FullName, columnName);
 
             PropertyInfo info;
-            if (_typePropertyMapCache.TryGetValue(cacheKey, out info))
+            if (TypePropertyMapCache.TryGetValue(cacheKey, out info))
             {
                 return info;
             }
@@ -43,14 +44,14 @@ private static PropertyInfo GetPropertyInfo(Type type, string columnName)
                 {
                     if (!propertyMap.Ignored)
                     {
-                        _typePropertyMapCache.Add(cacheKey, propertyMap.PropertyInfo);
+                        TypePropertyMapCache.Add(cacheKey, propertyMap.PropertyInfo);
                         return propertyMap.PropertyInfo;
                     }
                 }
             }
 
             // If we get here, the property was not mapped.
-            _typePropertyMapCache.Add(cacheKey, null);
+            TypePropertyMapCache.Add(cacheKey, null);
             return null;
         }
     }
diff --git a/src/Dapper.FluentMap/MultiTypeMap.cs b/src/Dapper.FluentMap/TypeMaps/MultiTypeMap.cs
similarity index 82%
rename from src/Dapper.FluentMap/MultiTypeMap.cs
rename to src/Dapper.FluentMap/TypeMaps/MultiTypeMap.cs
index bc589ef..424e1df 100644
--- a/src/Dapper.FluentMap/MultiTypeMap.cs
+++ b/src/Dapper.FluentMap/TypeMaps/MultiTypeMap.cs
@@ -2,18 +2,19 @@
 using System.Collections.Generic;
 using System.Reflection;
 
-namespace Dapper.FluentMap
+namespace Dapper.FluentMap.TypeMaps
 {
     /// <summary>
     /// Represents a Dapper type mapping strategy which consists of multiple strategies.
     /// </summary>
-    public abstract class MultiTypeMap : SqlMapper.ITypeMap
+    internal abstract class MultiTypeMap : SqlMapper.ITypeMap
     {
-        protected static readonly Dictionary<string, PropertyInfo> _typePropertyMapCache = new Dictionary<string, PropertyInfo>();
         private readonly IEnumerable<SqlMapper.ITypeMap> _mappers;
+        private static readonly Dictionary<string, PropertyInfo> _typePropertyMapCache = new Dictionary<string, PropertyInfo>();
 
         /// <summary>
-        /// Initializes an instance of the <see cref="MultiTypeMap"/> class with the specified Dapper type mappers.
+        /// Initializes an instance of the <see cref="T:Dapper.FluentMap.TypeMaps.MultiTypeMap"/> 
+        /// class with the specified Dapper type mappers.
         /// </summary>
         /// <param name="mappers">The type mapping strategies to be used when mapping.</param>
         protected MultiTypeMap(params SqlMapper.ITypeMap[] mappers)
@@ -88,5 +89,13 @@ public SqlMapper.IMemberMap GetMember(string columnName)
             }
             return null;
         }
+
+        protected static Dictionary<string, PropertyInfo> TypePropertyMapCache
+        {
+            get
+            {
+                return _typePropertyMapCache;
+            }
+        }
     }
 }
diff --git a/src/Dapper.FluentMap/Utils/DictionaryExtensions.cs b/src/Dapper.FluentMap/Utils/DictionaryExtensions.cs
new file mode 100644
index 0000000..37086f4
--- /dev/null
+++ b/src/Dapper.FluentMap/Utils/DictionaryExtensions.cs
@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+
+namespace Dapper.FluentMap.Utils
+{
+    internal static class DictionaryExtensions
+    {
+        internal static void AddOrUpdate<TKey, TValue>(this IDictionary<TKey, IList<TValue>> dict, TKey key, TValue value)
+        {
+            if (dict.ContainsKey(key))
+            {
+                dict[key].Add(value);
+            }
+            else
+            {
+                dict.Add(key, new[] { value });
+            }
+        }
+    }
+}
diff --git a/src/Dapper.FluentMap/ReflectionHelper.cs b/src/Dapper.FluentMap/Utils/ReflectionHelper.cs
similarity index 82%
rename from src/Dapper.FluentMap/ReflectionHelper.cs
rename to src/Dapper.FluentMap/Utils/ReflectionHelper.cs
index e24d796..e627519 100644
--- a/src/Dapper.FluentMap/ReflectionHelper.cs
+++ b/src/Dapper.FluentMap/Utils/ReflectionHelper.cs
@@ -1,19 +1,19 @@
 using System.Linq.Expressions;
 using System.Reflection;
 
-namespace Dapper.FluentMap
+namespace Dapper.FluentMap.Utils
 {
     /// <summary>
     /// Provides helper methods for reflection operations.
     /// </summary>
-    public static class ReflectionHelper
+    internal static class ReflectionHelper
     {
         /// <summary>
-        /// Returns the MemberInfo for the specified lamba expression.
+        /// Returns the <see cref="T:System.Reflection.MemberInfo"/> for the specified lamba expression.
         /// </summary>
         /// <param name="lambda">A lamba expression containing a MemberExpression.</param>
         /// <returns>A MemberInfo object for the member in the specified lambda expression.</returns>
-        public static MemberInfo GetMemberInfo(LambdaExpression lambda)
+        internal static MemberInfo GetMemberInfo(LambdaExpression lambda)
         {
             Expression expr = lambda;
             while (true)