diff --git a/lib/factory_bot.rb b/lib/factory_bot.rb
index de541d0e6..4830c7cf4 100644
--- a/lib/factory_bot.rb
+++ b/lib/factory_bot.rb
@@ -7,7 +7,6 @@
 
 require "factory_bot/internal"
 require "factory_bot/definition_hierarchy"
-require "factory_bot/configuration"
 require "factory_bot/errors"
 require "factory_bot/factory_runner"
 require "factory_bot/strategy_syntax_method_registrar"
@@ -111,8 +110,8 @@ class << self
     #     set_sequence("factory_name/trait_name/sequence_name", 450)
     delegate :factories,
       :register_strategy,
-      :rewind_sequences,
       :rewind_sequence,
+      :rewind_sequences,
       :set_sequence,
       :strategy_by_name,
       to: Internal
diff --git a/lib/factory_bot/configuration.rb b/lib/factory_bot/configuration.rb
deleted file mode 100644
index ccfc3d9ca..000000000
--- a/lib/factory_bot/configuration.rb
+++ /dev/null
@@ -1,33 +0,0 @@
-module FactoryBot
-  # @api private
-  class Configuration
-    attr_reader(
-      :callback_names,
-      :factories,
-      :inline_sequences,
-      :sequences,
-      :strategies,
-      :traits
-    )
-
-    def initialize
-      @factories = Decorator::DisallowsDuplicatesRegistry.new(Registry.new("Factory"))
-      @sequences = Decorator::DisallowsDuplicatesRegistry.new(Registry.new("Sequence"))
-      @traits = Decorator::DisallowsDuplicatesRegistry.new(Registry.new("Trait"))
-      @strategies = Registry.new("Strategy")
-      @callback_names = Set.new
-      @definition = Definition.new(:configuration)
-      @inline_sequences = []
-
-      to_create(&:save!)
-      initialize_with { new }
-    end
-
-    delegate :to_create, :skip_create, :constructor, :before, :after,
-      :callback, :callbacks, to: :@definition
-
-    def initialize_with(&block)
-      @definition.define_constructor(&block)
-    end
-  end
-end
diff --git a/lib/factory_bot/definition.rb b/lib/factory_bot/definition.rb
index b393882a3..43f21b8f5 100644
--- a/lib/factory_bot/definition.rb
+++ b/lib/factory_bot/definition.rb
@@ -107,6 +107,7 @@ def register_enum(enum)
     def define_constructor(&block)
       @constructor = block
     end
+    alias_method :initialize_with, :define_constructor
 
     def before(*names, &block)
       callback(*names.map { |name| "before_#{name}" }, &block)
diff --git a/lib/factory_bot/internal.rb b/lib/factory_bot/internal.rb
index 77230cbf6..67c7a453d 100644
--- a/lib/factory_bot/internal.rb
+++ b/lib/factory_bot/internal.rb
@@ -1,3 +1,9 @@
+require "factory_bot/internal/definition"
+require "factory_bot/internal/factories"
+require "factory_bot/internal/sequences"
+require "factory_bot/internal/strategies"
+require "factory_bot/internal/traits"
+
 module FactoryBot
   # @api private
   module Internal
@@ -6,119 +12,46 @@ class << self
         :before,
         :callbacks,
         :constructor,
-        :factories,
         :initialize_with,
-        :inline_sequences,
-        :sequences,
         :skip_create,
         :strategies,
         :to_create,
-        :traits,
-        to: :configuration
-
-      def configuration
-        @configuration ||= Configuration.new
-      end
-
-      def reset_configuration
-        @configuration = nil
-      end
-
-      def register_inline_sequence(sequence)
-        inline_sequences.push(sequence)
-        sequence
-      end
-
-      def rewind_inline_sequences
-        inline_sequences.each(&:rewind)
-      end
-
-      def register_trait(trait)
-        trait.names.each do |name|
-          traits.register(name, trait)
-        end
-        trait
-      end
-
-      def trait_by_name(name, klass)
-        traits.find(name).tap { |t| t.klass = klass }
-      end
-
-      def register_sequence(sequence)
-        sequence.names.each do |name|
-          sequences.register(name, sequence)
-        end
-        sequence
-      end
-
-      def sequence_by_name(name)
-        sequences.find(name)
-      end
-
-      def rewind_sequences
-        sequences.each(&:rewind)
-        rewind_inline_sequences
-      end
-
-      def rewind_sequence(*uri_parts)
-        fail_argument_count(0, "1+") if uri_parts.empty?
+        to: Internal::Definition
 
-        uri = build_uri(uri_parts)
-        sequence = Sequence.find_by_uri(uri) || fail_unregistered_sequence(uri)
+      delegate :traits,
+        :register_trait,
+        :trait_by_name,
+        to: Internal::Traits
 
-        sequence.rewind
-      end
+      delegate :factories,
+        :register_factory,
+        :factory_by_name,
+        to: Internal::Factories
 
-      def set_sequence(*uri_parts, value)
-        uri = build_uri(uri_parts) || fail_argument_count(uri_parts.size, "2+")
-        sequence = Sequence.find(*uri) || fail_unregistered_sequence(uri)
-
-        sequence.set_value(value)
-      end
-
-      def register_factory(factory)
-        factory.names.each do |name|
-          factories.register(name, factory)
-        end
-        factory
-      end
-
-      def factory_by_name(name)
-        factories.find(name)
-      end
-
-      def register_strategy(strategy_name, strategy_class)
-        strategies.register(strategy_name, strategy_class)
-        StrategySyntaxMethodRegistrar.new(strategy_name).define_strategy_methods
-      end
-
-      def strategy_by_name(name)
-        strategies.find(name)
-      end
-
-      def register_default_strategies
-        register_strategy(:build, FactoryBot::Strategy::Build)
-        register_strategy(:create, FactoryBot::Strategy::Create)
-        register_strategy(:attributes_for, FactoryBot::Strategy::AttributesFor)
-        register_strategy(:build_stubbed, FactoryBot::Strategy::Stub)
-        register_strategy(:null, FactoryBot::Strategy::Null)
-      end
-
-      private
-
-      def build_uri(...)
-        FactoryBot::UriManager.build_uri(...)
-      end
-
-      def fail_argument_count(received, expected)
-        fail ArgumentError,
-          "wrong number of arguments (given #{received}, expected #{expected})"
-      end
+      delegate :sequences,
+        :inline_sequences,
+        :register_inline_sequence,
+        :rewind_inline_sequences,
+        :register_sequence,
+        :sequence_by_name,
+        :rewind_sequence,
+        :rewind_sequences,
+        :set_sequence,
+        to: Internal::Sequences
+
+      delegate :strategies,
+        :register_strategy,
+        :strategy_by_name,
+        :register_default_strategies,
+        to: Internal::Strategies
+    end
 
-      def fail_unregistered_sequence(uri)
-        fail KeyError,
-          "Sequence not registered: '#{uri}'."
-      end
+    def self.reset
+      Internal::Traits.reset
+      Internal::Factories.reset
+      Internal::Sequences.reset
+      Internal::Strategies.reset
+      Internal::Definition.reset
     end
   end
 end
diff --git a/lib/factory_bot/internal/definition.rb b/lib/factory_bot/internal/definition.rb
new file mode 100644
index 000000000..06bd9fc4c
--- /dev/null
+++ b/lib/factory_bot/internal/definition.rb
@@ -0,0 +1,29 @@
+module FactoryBot
+  module Internal
+    module Definition
+      def self.definition
+        @definition ||= FactoryBot::Definition.new(:configuration).tap do |definition|
+          definition.to_create(&:save!)
+          definition.initialize_with { new }
+        end
+      end
+
+      def self.reset
+        @definition = nil
+        definition
+      end
+
+      class << self
+        delegate :to_create,
+          :skip_create,
+          :constructor,
+          :before,
+          :after,
+          :callback,
+          :callbacks,
+          :initialize_with,
+          to: :definition
+      end
+    end
+  end
+end
diff --git a/lib/factory_bot/internal/factories.rb b/lib/factory_bot/internal/factories.rb
new file mode 100644
index 000000000..e92f7d438
--- /dev/null
+++ b/lib/factory_bot/internal/factories.rb
@@ -0,0 +1,24 @@
+module FactoryBot
+  module Internal
+    module Factories
+      def self.factories
+        @factories ||= Decorator::DisallowsDuplicatesRegistry.new(Registry.new("Factory"))
+      end
+
+      def self.reset
+        @factories&.clear
+      end
+
+      def self.register_factory(factory)
+        factory.names.each do |name|
+          factories.register(name, factory)
+        end
+        factory
+      end
+
+      def self.factory_by_name(name)
+        factories.find(name)
+      end
+    end
+  end
+end
diff --git a/lib/factory_bot/internal/sequences.rb b/lib/factory_bot/internal/sequences.rb
new file mode 100644
index 000000000..952539c12
--- /dev/null
+++ b/lib/factory_bot/internal/sequences.rb
@@ -0,0 +1,77 @@
+module FactoryBot
+  module Internal
+    module Sequences
+      def self.sequences
+        @sequences ||= Decorator::DisallowsDuplicatesRegistry.new(Registry.new("Sequence"))
+      end
+
+      def self.inline_sequences
+        @inline_sequences ||= []
+      end
+
+      def self.reset
+        @sequences&.clear
+        @inline_sequences = []
+        sequences
+      end
+
+      def self.register_inline_sequence(sequence)
+        inline_sequences.push(sequence)
+        sequence
+      end
+
+      def self.rewind_inline_sequences
+        inline_sequences.each(&:rewind)
+      end
+
+      def self.register_sequence(sequence)
+        sequence.names.each do |name|
+          sequences.register(name, sequence)
+        end
+        sequence
+      end
+
+      def self.sequence_by_name(name)
+        sequences.find(name)
+      end
+
+      def self.rewind_sequences
+        sequences.each(&:rewind)
+        rewind_inline_sequences
+      end
+
+      def self.rewind_sequence(*uri_parts)
+        fail_argument_count(0, "1+") if uri_parts.empty?
+
+        uri = build_uri(uri_parts)
+        sequence = Sequence.find_by_uri(uri) || fail_unregistered_sequence(uri)
+
+        sequence.rewind
+      end
+
+      def self.set_sequence(*uri_parts, value)
+        uri = build_uri(uri_parts) || fail_argument_count(uri_parts.size, "2+")
+        sequence = Sequence.find(*uri) || fail_unregistered_sequence(uri)
+
+        sequence.set_value(value)
+      end
+
+      def self.build_uri(...)
+        FactoryBot::UriManager.build_uri(...)
+      end
+      private_class_method :build_uri
+
+      def self.fail_argument_count(received, expected)
+        fail ArgumentError,
+          "wrong number of arguments (given #{received}, expected #{expected})"
+      end
+      private_class_method :fail_argument_count
+
+      def self.fail_unregistered_sequence(uri)
+        fail KeyError,
+          "Sequence not registered: '#{uri}'."
+      end
+      private_class_method :fail_unregistered_sequence
+    end
+  end
+end
diff --git a/lib/factory_bot/internal/strategies.rb b/lib/factory_bot/internal/strategies.rb
new file mode 100644
index 000000000..094450eb5
--- /dev/null
+++ b/lib/factory_bot/internal/strategies.rb
@@ -0,0 +1,30 @@
+module FactoryBot
+  module Internal
+    module Strategies
+      def self.strategies
+        @strategies ||= Registry.new("Strategy")
+      end
+
+      def self.reset
+        @strategies&.clear
+      end
+
+      def self.register_strategy(strategy_name, strategy_class)
+        strategies.register(strategy_name, strategy_class)
+        StrategySyntaxMethodRegistrar.new(strategy_name).define_strategy_methods
+      end
+
+      def self.strategy_by_name(name)
+        strategies.find(name)
+      end
+
+      def self.register_default_strategies
+        register_strategy(:build, FactoryBot::Strategy::Build)
+        register_strategy(:create, FactoryBot::Strategy::Create)
+        register_strategy(:attributes_for, FactoryBot::Strategy::AttributesFor)
+        register_strategy(:build_stubbed, FactoryBot::Strategy::Stub)
+        register_strategy(:null, FactoryBot::Strategy::Null)
+      end
+    end
+  end
+end
diff --git a/lib/factory_bot/internal/traits.rb b/lib/factory_bot/internal/traits.rb
new file mode 100644
index 000000000..080ea8086
--- /dev/null
+++ b/lib/factory_bot/internal/traits.rb
@@ -0,0 +1,24 @@
+module FactoryBot
+  module Internal
+    module Traits
+      def self.traits
+        @traits ||= Decorator::DisallowsDuplicatesRegistry.new(Registry.new("Trait"))
+      end
+
+      def self.reset
+        @traits&.clear
+      end
+
+      def self.register_trait(trait)
+        trait.names.each do |name|
+          traits.register(name, trait)
+        end
+        trait
+      end
+
+      def self.trait_by_name(name, klass)
+        traits.find(name).tap { |t| t.klass = klass }
+      end
+    end
+  end
+end
diff --git a/lib/factory_bot/reload.rb b/lib/factory_bot/reload.rb
index 3ef871943..6ccaf1585 100644
--- a/lib/factory_bot/reload.rb
+++ b/lib/factory_bot/reload.rb
@@ -1,6 +1,6 @@
 module FactoryBot
   def self.reload
-    Internal.reset_configuration
+    Internal.reset
     Internal.register_default_strategies
     find_definitions
   end
diff --git a/spec/factory_bot/internal_spec.rb b/spec/factory_bot/internal_spec.rb
index 747886cb1..98ab602f4 100644
--- a/spec/factory_bot/internal_spec.rb
+++ b/spec/factory_bot/internal_spec.rb
@@ -2,10 +2,9 @@
   describe ".register_trait" do
     it "registers the provided trait" do
       trait = FactoryBot::Trait.new(:admin)
-      configuration = FactoryBot::Internal.configuration
 
       expect { FactoryBot::Internal.register_trait(trait) }
-        .to change { configuration.traits.count }
+        .to change { FactoryBot::Internal::Traits.traits.count }
         .from(0)
         .to(1)
     end
@@ -32,10 +31,9 @@
   describe ".register_sequence" do
     it "registers the provided sequence" do
       sequence = FactoryBot::Sequence.new(:email)
-      configuration = FactoryBot::Internal.configuration
 
       expect { FactoryBot::Internal.register_sequence(sequence) }
-        .to change { configuration.sequences.count }
+        .to change { FactoryBot::Internal::Sequences.sequences.count }
         .from(0)
         .to(1)
     end
@@ -76,10 +74,9 @@
   describe ".register_factory" do
     it "registers the provided factory" do
       factory = FactoryBot::Factory.new(:object)
-      configuration = FactoryBot::Internal.configuration
 
       expect { FactoryBot::Internal.register_factory(factory) }
-        .to change { configuration.factories.count }
+        .to change { FactoryBot::Internal::Factories.factories.count }
         .from(0)
         .to(1)
     end
@@ -103,9 +100,8 @@
   describe ".register_factory" do
     it "registers the provided factory" do
       factory = FactoryBot::Factory.new(:object)
-      configuration = FactoryBot::Internal.configuration
       expect { FactoryBot::Internal.register_factory(factory) }
-        .to change { configuration.factories.count }
+        .to change { FactoryBot::Internal::Factories.factories.count }
         .from(0)
         .to(1)
     end
@@ -125,12 +121,11 @@
   end
 
   describe ".register_strategy" do
-    it "register the provided strategy name with the class" do
-      configuration = FactoryBot::Internal.configuration
-      initial_strategies_count = configuration.strategies.count
+    it "registers the provided strategy name with the class" do
+      initial_strategies_count = FactoryBot::Internal::Strategies.strategies.count
       expect {
         FactoryBot::Internal.register_strategy(:strategy_name, :strategy_class)
-      }.to change { configuration.strategies.count }
+      }.to change { FactoryBot::Internal::Strategies.strategies.count }
         .from(initial_strategies_count)
         .to(initial_strategies_count + 1)
     end