diff --git a/deployment/ccip/changeset/accept_ownership_test.go b/deployment/ccip/changeset/accept_ownership_test.go
index 796db6aed09..11309e69c2c 100644
--- a/deployment/ccip/changeset/accept_ownership_test.go
+++ b/deployment/ccip/changeset/accept_ownership_test.go
@@ -6,22 +6,14 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/smartcontractkit/ccip-owner-contracts/pkg/gethwrappers"
 
-	commonchangeset "github.com/smartcontractkit/chainlink/deployment/common/changeset"
-	"github.com/smartcontractkit/chainlink/deployment/environment/memory"
-
 	"github.com/stretchr/testify/require"
 	"golang.org/x/exp/maps"
 
-	"github.com/smartcontractkit/chainlink/v2/core/logger"
+	commonchangeset "github.com/smartcontractkit/chainlink/deployment/common/changeset"
 )
 
 func Test_NewAcceptOwnershipChangeset(t *testing.T) {
-	e := NewMemoryEnvironmentWithJobsAndContracts(t, logger.TestLogger(t), memory.MemoryEnvironmentConfig{
-		Chains:             2,
-		NumOfUsersPerChain: 1,
-		Nodes:              4,
-		Bootstraps:         1,
-	}, &TestConfigs{})
+	e := NewMemoryEnvironment(t)
 	state, err := LoadOnchainState(e.Env)
 	require.NoError(t, err)
 
diff --git a/deployment/ccip/changeset/cs_active_candidate_test.go b/deployment/ccip/changeset/cs_active_candidate_test.go
index 0fb29242794..e07d2fb700c 100644
--- a/deployment/ccip/changeset/cs_active_candidate_test.go
+++ b/deployment/ccip/changeset/cs_active_candidate_test.go
@@ -12,7 +12,6 @@ import (
 	"github.com/smartcontractkit/chainlink-testing-framework/lib/utils/testcontext"
 
 	"github.com/smartcontractkit/chainlink/deployment/ccip/changeset/internal"
-	"github.com/smartcontractkit/chainlink/deployment/environment/memory"
 	cctypes "github.com/smartcontractkit/chainlink/v2/core/capabilities/ccip/types"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/router"
 
@@ -22,20 +21,14 @@ import (
 
 	commonchangeset "github.com/smartcontractkit/chainlink/deployment/common/changeset"
 	"github.com/smartcontractkit/chainlink/deployment/common/proposalutils"
-
-	"github.com/smartcontractkit/chainlink/v2/core/logger"
 )
 
 func TestActiveCandidate(t *testing.T) {
 	t.Skipf("to be enabled after latest cl-ccip is compatible")
 
-	lggr := logger.TestLogger(t)
-	tenv := NewMemoryEnvironmentWithJobsAndContracts(t, lggr, memory.MemoryEnvironmentConfig{
-		Chains:             3,
-		NumOfUsersPerChain: 1,
-		Nodes:              5,
-		Bootstraps:         1,
-	}, nil)
+	tenv := NewMemoryEnvironment(t,
+		WithChains(3),
+		WithNodes(5))
 	e := tenv.Env
 	state, err := LoadOnchainState(tenv.Env)
 	require.NoError(t, err)
diff --git a/deployment/ccip/changeset/cs_add_chain_test.go b/deployment/ccip/changeset/cs_add_chain_test.go
index c8d872236c2..b7d9e2083ef 100644
--- a/deployment/ccip/changeset/cs_add_chain_test.go
+++ b/deployment/ccip/changeset/cs_add_chain_test.go
@@ -10,7 +10,6 @@ import (
 	"github.com/smartcontractkit/chainlink/deployment/ccip/changeset/internal"
 	commonchangeset "github.com/smartcontractkit/chainlink/deployment/common/changeset"
 	commontypes "github.com/smartcontractkit/chainlink/deployment/common/types"
-	"github.com/smartcontractkit/chainlink/deployment/environment/memory"
 	"github.com/smartcontractkit/chainlink/v2/core/capabilities/ccip/types"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -34,12 +33,10 @@ import (
 
 func TestAddChainInbound(t *testing.T) {
 	// 4 chains where the 4th is added after initial deployment.
-	e := NewMemoryEnvironmentWithJobs(t, logger.TestLogger(t), memory.MemoryEnvironmentConfig{
-		Chains:             4,
-		NumOfUsersPerChain: 1,
-		Nodes:              4,
-		Bootstraps:         1,
-	})
+	e := NewMemoryEnvironment(t,
+		WithChains(4),
+		WithJobsOnly(),
+	)
 	state, err := LoadOnchainState(e.Env)
 	require.NoError(t, err)
 	// Take first non-home chain as the new chain.
diff --git a/deployment/ccip/changeset/cs_add_lane_test.go b/deployment/ccip/changeset/cs_add_lane_test.go
index fbceeaa8472..7f1374a1725 100644
--- a/deployment/ccip/changeset/cs_add_lane_test.go
+++ b/deployment/ccip/changeset/cs_add_lane_test.go
@@ -11,18 +11,12 @@ import (
 	"github.com/smartcontractkit/chainlink-testing-framework/lib/utils/testcontext"
 
 	"github.com/smartcontractkit/chainlink/deployment"
-	"github.com/smartcontractkit/chainlink/deployment/environment/memory"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/offramp"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/router"
-	"github.com/smartcontractkit/chainlink/v2/core/logger"
 )
 
 func TestAddLanesWithTestRouter(t *testing.T) {
-	e := NewMemoryEnvironmentWithJobsAndContracts(t, logger.TestLogger(t), memory.MemoryEnvironmentConfig{
-		Chains:     2,
-		Nodes:      4,
-		Bootstraps: 1,
-	}, nil)
+	e := NewMemoryEnvironment(t)
 	// Here we have CR + nodes set up, but no CCIP contracts deployed.
 	state, err := LoadOnchainState(e.Env)
 	require.NoError(t, err)
@@ -72,11 +66,7 @@ func TestAddLane(t *testing.T) {
 
 	t.Parallel()
 	// We add more chains to the chainlink nodes than the number of chains where CCIP is deployed.
-	e := NewMemoryEnvironmentWithJobsAndContracts(t, logger.TestLogger(t), memory.MemoryEnvironmentConfig{
-		Chains:     2,
-		Nodes:      4,
-		Bootstraps: 1,
-	}, nil)
+	e := NewMemoryEnvironment(t)
 	// Here we have CR + nodes set up, but no CCIP contracts deployed.
 	state, err := LoadOnchainState(e.Env)
 	require.NoError(t, err)
diff --git a/deployment/ccip/changeset/cs_deploy_chain_test.go b/deployment/ccip/changeset/cs_deploy_chain_test.go
index 234d73cc4b5..1f5d3666958 100644
--- a/deployment/ccip/changeset/cs_deploy_chain_test.go
+++ b/deployment/ccip/changeset/cs_deploy_chain_test.go
@@ -99,12 +99,7 @@ func TestDeployChainContractsChangeset(t *testing.T) {
 }
 
 func TestDeployCCIPContracts(t *testing.T) {
-	lggr := logger.TestLogger(t)
-	e := NewMemoryEnvironmentWithJobsAndContracts(t, lggr, memory.MemoryEnvironmentConfig{
-		Chains:     2,
-		Nodes:      4,
-		Bootstraps: 1,
-	}, nil)
+	e := NewMemoryEnvironment(t)
 	// Deploy all the CCIP contracts.
 	state, err := LoadOnchainState(e.Env)
 	require.NoError(t, err)
diff --git a/deployment/ccip/changeset/state_test.go b/deployment/ccip/changeset/state_test.go
index 6e679c265dc..3587332fff2 100644
--- a/deployment/ccip/changeset/state_test.go
+++ b/deployment/ccip/changeset/state_test.go
@@ -4,19 +4,10 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/require"
-
-	"github.com/smartcontractkit/chainlink/deployment/environment/memory"
-	"github.com/smartcontractkit/chainlink/v2/core/logger"
 )
 
 func TestSmokeState(t *testing.T) {
-	lggr := logger.TestLogger(t)
-	tenv := NewMemoryEnvironmentWithJobsAndContracts(t, lggr, memory.MemoryEnvironmentConfig{
-		Chains:             3,
-		Nodes:              4,
-		Bootstraps:         1,
-		NumOfUsersPerChain: 1,
-	}, nil)
+	tenv := NewMemoryEnvironment(t, WithChains(3))
 	state, err := LoadOnchainState(tenv.Env)
 	require.NoError(t, err)
 	_, err = state.View(tenv.Env.AllChainSelectors())
diff --git a/deployment/ccip/changeset/test_environment.go b/deployment/ccip/changeset/test_environment.go
index 542bce3c12c..d5b79eb90b5 100644
--- a/deployment/ccip/changeset/test_environment.go
+++ b/deployment/ccip/changeset/test_environment.go
@@ -1,11 +1,27 @@
 package changeset
 
 import (
+	"context"
 	"fmt"
 	"math/big"
 	"testing"
+	"time"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/smartcontractkit/ccip-owner-contracts/pkg/gethwrappers"
+	cciptypes "github.com/smartcontractkit/chainlink-ccip/pkg/types/ccipocr3"
+	"github.com/smartcontractkit/chainlink-ccip/pluginconfig"
+	commonconfig "github.com/smartcontractkit/chainlink-common/pkg/config"
+	"github.com/smartcontractkit/chainlink-common/pkg/logger"
+	jobv1 "github.com/smartcontractkit/chainlink-protos/job-distributor/v1/job"
+	"github.com/smartcontractkit/chainlink-testing-framework/lib/utils/testcontext"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/zap/zapcore"
 
 	"github.com/smartcontractkit/chainlink/deployment"
+	commonchangeset "github.com/smartcontractkit/chainlink/deployment/common/changeset"
+	commontypes "github.com/smartcontractkit/chainlink/deployment/common/types"
+	"github.com/smartcontractkit/chainlink/deployment/environment/memory"
 )
 
 type EnvType string
@@ -28,6 +44,7 @@ type TestConfigs struct {
 	IsMultiCall3             bool
 	OCRConfigOverride        func(CCIPOCRParams) CCIPOCRParams
 	RMNEnabled               bool
+	NumOfRMNNodes            int
 	LinkPrice                *big.Int
 	WethPrice                *big.Int
 }
@@ -42,17 +59,21 @@ func (t *TestConfigs) Validate() error {
 	if t.Bootstraps < 1 {
 		return fmt.Errorf("bootstraps must be at least 1")
 	}
+	if t.Type == Memory && t.RMNEnabled {
+		return fmt.Errorf("cannot run RMN tests in memory mode")
+	}
 	return nil
 }
 
 func DefaultTestConfigs() *TestConfigs {
 	return &TestConfigs{
-		Chains:             2,
-		NumOfUsersPerChain: 1,
-		Nodes:              4,
-		Bootstraps:         1,
-		LinkPrice:          MockLinkPrice,
-		WethPrice:          MockWethPrice,
+		Chains:                2,
+		NumOfUsersPerChain:    1,
+		Nodes:                 4,
+		Bootstraps:            1,
+		LinkPrice:             MockLinkPrice,
+		WethPrice:             MockWethPrice,
+		CreateJobAndContracts: true,
 	}
 }
 
@@ -63,10 +84,30 @@ func WithMultiCall3() TestOps {
 		testCfg.IsMultiCall3 = true
 	}
 }
+func WithEnvironmentType(t EnvType) TestOps {
+	return func(testCfg *TestConfigs) {
+		testCfg.Type = t
+	}
+}
+
+func WithJobsOnly() TestOps {
+	return func(testCfg *TestConfigs) {
+		testCfg.CreateJobAndContracts = false
+		testCfg.CreateJob = true
+	}
+}
 
-func WithRMNEnabled() TestOps {
+func WithNoJobsAndContracts() TestOps {
+	return func(testCfg *TestConfigs) {
+		testCfg.CreateJobAndContracts = false
+		testCfg.CreateJob = false
+	}
+}
+
+func WithRMNEnabled(numOfNode int) TestOps {
 	return func(testCfg *TestConfigs) {
 		testCfg.RMNEnabled = true
+		testCfg.NumOfRMNNodes = numOfNode
 	}
 }
 
@@ -119,3 +160,271 @@ type TestEnvironment interface {
 	DeployedEnvironment() DeployedEnv
 	MockUSDCAttestationServer(t *testing.T, isUSDCAttestationMissing bool) string
 }
+
+type DeployedEnv struct {
+	Env          deployment.Environment
+	HomeChainSel uint64
+	FeedChainSel uint64
+	ReplayBlocks map[uint64]uint64
+	Users        map[uint64][]*bind.TransactOpts
+}
+
+func (d *DeployedEnv) SetupJobs(t *testing.T) {
+	ctx := testcontext.Get(t)
+	out, err := CCIPCapabilityJobspec(d.Env, struct{}{})
+	require.NoError(t, err)
+	for nodeID, jobs := range out.JobSpecs {
+		for _, job := range jobs {
+			// Note these auto-accept
+			_, err := d.Env.Offchain.ProposeJob(ctx,
+				&jobv1.ProposeJobRequest{
+					NodeId: nodeID,
+					Spec:   job,
+				})
+			require.NoError(t, err)
+		}
+	}
+	// Wait for plugins to register filters?
+	// TODO: Investigate how to avoid.
+	time.Sleep(30 * time.Second)
+	ReplayLogs(t, d.Env.Offchain, d.ReplayBlocks)
+}
+
+type MemoryEnvironment struct {
+	DeployedEnv
+	chains map[uint64]deployment.Chain
+}
+
+func (m *MemoryEnvironment) DeployedEnvironment() DeployedEnv {
+	return m.DeployedEnv
+}
+
+func (m *MemoryEnvironment) StartChains(t *testing.T, tc *TestConfigs) {
+	ctx := testcontext.Get(t)
+	chains, users := memory.NewMemoryChains(t, tc.Chains, tc.NumOfUsersPerChain)
+	m.chains = chains
+	homeChainSel, feedSel := allocateCCIPChainSelectors(chains)
+	replayBlocks, err := LatestBlocksByChain(ctx, chains)
+	require.NoError(t, err)
+	m.DeployedEnv = DeployedEnv{
+		HomeChainSel: homeChainSel,
+		FeedChainSel: feedSel,
+		ReplayBlocks: replayBlocks,
+		Users:        users,
+	}
+}
+
+func (m *MemoryEnvironment) StartNodes(t *testing.T, tc *TestConfigs, crConfig deployment.CapabilityRegistryConfig) {
+	require.NotNil(t, m.chains, "start chains first, chains are empty")
+	require.NotNil(t, m.DeployedEnv, "start chains and initiate deployed env first before starting nodes")
+	nodes := memory.NewNodes(t, zapcore.InfoLevel, m.chains, tc.Nodes, tc.Bootstraps, crConfig)
+	ctx := testcontext.Get(t)
+	lggr := logger.Test(t)
+	for _, node := range nodes {
+		require.NoError(t, node.App.Start(ctx))
+		t.Cleanup(func() {
+			require.NoError(t, node.App.Stop())
+		})
+	}
+	m.DeployedEnv.Env = memory.NewMemoryEnvironmentFromChainsNodes(func() context.Context { return ctx }, lggr, m.chains, nodes)
+}
+
+func (m *MemoryEnvironment) MockUSDCAttestationServer(t *testing.T, isUSDCAttestationMissing bool) string {
+	server := mockAttestationResponse(isUSDCAttestationMissing)
+	endpoint := server.URL
+	t.Cleanup(func() {
+		server.Close()
+	})
+	return endpoint
+}
+
+// NewMemoryEnvironment creates an in-memory environment based on the testconfig requested
+func NewMemoryEnvironment(t *testing.T, opts ...TestOps) DeployedEnv {
+	testCfg := DefaultTestConfigs()
+	for _, opt := range opts {
+		opt(testCfg)
+	}
+	env := &MemoryEnvironment{}
+	if testCfg.CreateJobAndContracts {
+		return NewEnvironmentWithJobsAndContracts(t, testCfg, env)
+	}
+	if testCfg.CreateJob {
+		return NewEnvironmentWithJobs(t, testCfg, env)
+	}
+	return NewEnvironment(t, testCfg, env)
+}
+
+func NewEnvironment(t *testing.T, tc *TestConfigs, tEnv TestEnvironment) DeployedEnv {
+	lggr := logger.Test(t)
+	tEnv.StartChains(t, tc)
+	dEnv := tEnv.DeployedEnvironment()
+	require.NotEmpty(t, dEnv.FeedChainSel)
+	require.NotEmpty(t, dEnv.HomeChainSel)
+	require.NotEmpty(t, dEnv.Env.Chains)
+	ab := deployment.NewMemoryAddressBook()
+	crConfig := DeployTestContracts(t, lggr, ab, dEnv.HomeChainSel, dEnv.FeedChainSel, dEnv.Env.Chains, tc.LinkPrice, tc.WethPrice)
+	tEnv.StartNodes(t, tc, crConfig)
+
+	envNodes, err := deployment.NodeInfo(dEnv.Env.NodeIDs, dEnv.Env.Offchain)
+	require.NoError(t, err)
+	dEnv.Env.ExistingAddresses = ab
+	_, err = deployHomeChain(lggr, dEnv.Env, dEnv.Env.ExistingAddresses, dEnv.Env.Chains[dEnv.HomeChainSel],
+		NewTestRMNStaticConfig(),
+		NewTestRMNDynamicConfig(),
+		NewTestNodeOperator(dEnv.Env.Chains[dEnv.HomeChainSel].DeployerKey.From),
+		map[string][][32]byte{
+			"NodeOperator": envNodes.NonBootstraps().PeerIDs(),
+		},
+	)
+	require.NoError(t, err)
+
+	return tEnv.DeployedEnvironment()
+}
+
+func NewEnvironmentWithJobsAndContracts(t *testing.T, tc *TestConfigs, tEnv TestEnvironment) DeployedEnv {
+	var err error
+	e := NewEnvironment(t, tc, tEnv)
+	allChains := e.Env.AllChainSelectors()
+	mcmsCfg := make(map[uint64]commontypes.MCMSWithTimelockConfig)
+
+	for _, c := range e.Env.AllChainSelectors() {
+		mcmsCfg[c] = commontypes.MCMSWithTimelockConfig{
+			Canceller:         commonchangeset.SingleGroupMCMS(t),
+			Bypasser:          commonchangeset.SingleGroupMCMS(t),
+			Proposer:          commonchangeset.SingleGroupMCMS(t),
+			TimelockExecutors: e.Env.AllDeployerKeys(),
+			TimelockMinDelay:  big.NewInt(0),
+		}
+	}
+	var (
+		usdcChains   []uint64
+		isMulticall3 bool
+	)
+	if tc != nil {
+		if tc.IsUSDC {
+			usdcChains = allChains
+		}
+		isMulticall3 = tc.IsMultiCall3
+	}
+	// Need to deploy prerequisites first so that we can form the USDC config
+	// no proposals to be made, timelock can be passed as nil here
+	e.Env, err = commonchangeset.ApplyChangesets(t, e.Env, nil, []commonchangeset.ChangesetApplication{
+		{
+			Changeset: commonchangeset.WrapChangeSet(commonchangeset.DeployLinkToken),
+			Config:    allChains,
+		},
+		{
+			Changeset: commonchangeset.WrapChangeSet(DeployPrerequisites),
+			Config: DeployPrerequisiteConfig{
+				ChainSelectors: allChains,
+				Opts: []PrerequisiteOpt{
+					WithUSDCChains(usdcChains),
+					WithMulticall3(isMulticall3),
+				},
+			},
+		},
+		{
+			Changeset: commonchangeset.WrapChangeSet(commonchangeset.DeployMCMSWithTimelock),
+			Config:    mcmsCfg,
+		},
+		{
+			Changeset: commonchangeset.WrapChangeSet(DeployChainContracts),
+			Config: DeployChainContractsConfig{
+				ChainSelectors:    allChains,
+				HomeChainSelector: e.HomeChainSel,
+			},
+		},
+	})
+	require.NoError(t, err)
+
+	state, err := LoadOnchainState(e.Env)
+	require.NoError(t, err)
+	// Assert USDC set up as expected.
+	for _, chain := range usdcChains {
+		require.NotNil(t, state.Chains[chain].MockUSDCTokenMessenger)
+		require.NotNil(t, state.Chains[chain].MockUSDCTransmitter)
+		require.NotNil(t, state.Chains[chain].USDCTokenPool)
+	}
+	// Assert link present
+	require.NotNil(t, state.Chains[e.FeedChainSel].LinkToken)
+	require.NotNil(t, state.Chains[e.FeedChainSel].Weth9)
+
+	tokenConfig := NewTestTokenConfig(state.Chains[e.FeedChainSel].USDFeeds)
+	var tokenDataProviders []pluginconfig.TokenDataObserverConfig
+	if len(usdcChains) > 0 {
+		endpoint := tEnv.MockUSDCAttestationServer(t, tc.IsUSDCAttestationMissing)
+		cctpContracts := make(map[cciptypes.ChainSelector]pluginconfig.USDCCCTPTokenConfig)
+		for _, usdcChain := range usdcChains {
+			cctpContracts[cciptypes.ChainSelector(usdcChain)] = pluginconfig.USDCCCTPTokenConfig{
+				SourcePoolAddress:            state.Chains[usdcChain].USDCTokenPool.Address().String(),
+				SourceMessageTransmitterAddr: state.Chains[usdcChain].MockUSDCTransmitter.Address().String(),
+			}
+		}
+		tokenDataProviders = append(tokenDataProviders, pluginconfig.TokenDataObserverConfig{
+			Type:    pluginconfig.USDCCCTPHandlerType,
+			Version: "1.0",
+			USDCCCTPObserverConfig: &pluginconfig.USDCCCTPObserverConfig{
+				Tokens:                 cctpContracts,
+				AttestationAPI:         endpoint,
+				AttestationAPITimeout:  commonconfig.MustNewDuration(time.Second),
+				AttestationAPIInterval: commonconfig.MustNewDuration(500 * time.Millisecond),
+			}})
+	}
+	// Build the per chain config.
+	chainConfigs := make(map[uint64]CCIPOCRParams)
+	timelocksPerChain := make(map[uint64]*gethwrappers.RBACTimelock)
+	for _, chain := range allChains {
+		timelocksPerChain[chain] = state.Chains[chain].Timelock
+		tokenInfo := tokenConfig.GetTokenInfo(e.Env.Logger, state.Chains[chain].LinkToken, state.Chains[chain].Weth9)
+		ocrParams := DefaultOCRParams(e.FeedChainSel, tokenInfo, tokenDataProviders)
+		if tc.OCRConfigOverride != nil {
+			ocrParams = tc.OCRConfigOverride(ocrParams)
+		}
+		chainConfigs[chain] = ocrParams
+	}
+	// Deploy second set of changesets to deploy and configure the CCIP contracts.
+	e.Env, err = commonchangeset.ApplyChangesets(t, e.Env, timelocksPerChain, []commonchangeset.ChangesetApplication{
+		{
+			Changeset: commonchangeset.WrapChangeSet(ConfigureNewChains),
+			Config: NewChainsConfig{
+				HomeChainSel:       e.HomeChainSel,
+				FeedChainSel:       e.FeedChainSel,
+				ChainConfigByChain: chainConfigs,
+			},
+		},
+		{
+			Changeset: commonchangeset.WrapChangeSet(CCIPCapabilityJobspec),
+		},
+	})
+	require.NoError(t, err)
+
+	ReplayLogs(t, e.Env.Offchain, e.ReplayBlocks)
+
+	state, err = LoadOnchainState(e.Env)
+	require.NoError(t, err)
+	require.NotNil(t, state.Chains[e.HomeChainSel].CapabilityRegistry)
+	require.NotNil(t, state.Chains[e.HomeChainSel].CCIPHome)
+	require.NotNil(t, state.Chains[e.HomeChainSel].RMNHome)
+	for _, chain := range allChains {
+		require.NotNil(t, state.Chains[chain].LinkToken)
+		require.NotNil(t, state.Chains[chain].Weth9)
+		require.NotNil(t, state.Chains[chain].TokenAdminRegistry)
+		require.NotNil(t, state.Chains[chain].RegistryModule)
+		require.NotNil(t, state.Chains[chain].Router)
+		require.NotNil(t, state.Chains[chain].RMNRemote)
+		require.NotNil(t, state.Chains[chain].TestRouter)
+		require.NotNil(t, state.Chains[chain].NonceManager)
+		require.NotNil(t, state.Chains[chain].FeeQuoter)
+		require.NotNil(t, state.Chains[chain].OffRamp)
+		require.NotNil(t, state.Chains[chain].OnRamp)
+	}
+	return e
+}
+
+// NewEnvironmentWithJobs creates a new CCIP environment
+// with capreg, fee tokens, feeds, nodes and jobs set up.
+func NewEnvironmentWithJobs(t *testing.T, tc *TestConfigs, tEnv TestEnvironment) DeployedEnv {
+	e := NewEnvironment(t, tc, tEnv)
+	e.SetupJobs(t)
+	return e
+}
diff --git a/deployment/ccip/changeset/test_helpers.go b/deployment/ccip/changeset/test_helpers.go
index 77918ab311e..75801d99cff 100644
--- a/deployment/ccip/changeset/test_helpers.go
+++ b/deployment/ccip/changeset/test_helpers.go
@@ -11,30 +11,20 @@ import (
 	"testing"
 	"time"
 
-	jobv1 "github.com/smartcontractkit/chainlink-protos/job-distributor/v1/job"
 	"golang.org/x/sync/errgroup"
 
-	mapset "github.com/deckarep/golang-set/v2"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/pkg/errors"
-	"github.com/smartcontractkit/ccip-owner-contracts/pkg/gethwrappers"
 
-	"github.com/smartcontractkit/chainlink-ccip/pluginconfig"
-	commonconfig "github.com/smartcontractkit/chainlink-common/pkg/config"
-
-	commonchangeset "github.com/smartcontractkit/chainlink/deployment/common/changeset"
-	commontypes "github.com/smartcontractkit/chainlink/deployment/common/types"
 	"github.com/smartcontractkit/chainlink/v2/core/services/relay"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/stretchr/testify/require"
 
-	"go.uber.org/multierr"
-	"go.uber.org/zap/zapcore"
-
 	chainsel "github.com/smartcontractkit/chain-selectors"
+	"go.uber.org/multierr"
 
 	"github.com/smartcontractkit/chainlink-testing-framework/lib/utils/testcontext"
 
@@ -89,274 +79,6 @@ func Context(tb testing.TB) context.Context {
 	return ctx
 }
 
-type DeployedEnv struct {
-	Env          deployment.Environment
-	HomeChainSel uint64
-	FeedChainSel uint64
-	ReplayBlocks map[uint64]uint64
-	Users        map[uint64][]*bind.TransactOpts
-}
-
-func (d *DeployedEnv) SetupJobs(t *testing.T) {
-	ctx := testcontext.Get(t)
-	out, err := CCIPCapabilityJobspec(d.Env, struct{}{})
-	require.NoError(t, err)
-	for nodeID, jobs := range out.JobSpecs {
-		for _, job := range jobs {
-			// Note these auto-accept
-			_, err := d.Env.Offchain.ProposeJob(ctx,
-				&jobv1.ProposeJobRequest{
-					NodeId: nodeID,
-					Spec:   job,
-				})
-			require.NoError(t, err)
-		}
-	}
-	// Wait for plugins to register filters?
-	// TODO: Investigate how to avoid.
-	time.Sleep(30 * time.Second)
-	ReplayLogs(t, d.Env.Offchain, d.ReplayBlocks)
-}
-
-type MemoryEnvironment struct {
-	DeployedEnv
-	chains map[uint64]deployment.Chain
-}
-
-func (m *MemoryEnvironment) DeployedEnvironment() DeployedEnv {
-	return m.DeployedEnv
-}
-
-func (m *MemoryEnvironment) StartChains(t *testing.T, tc *TestConfigs) {
-	ctx := testcontext.Get(t)
-	chains, users := memory.NewMemoryChains(t, tc.Chains, tc.NumOfUsersPerChain)
-	m.chains = chains
-	homeChainSel, feedSel := allocateCCIPChainSelectors(chains)
-	replayBlocks, err := LatestBlocksByChain(ctx, chains)
-	require.NoError(t, err)
-	m.DeployedEnv = DeployedEnv{
-		HomeChainSel: homeChainSel,
-		FeedChainSel: feedSel,
-		ReplayBlocks: replayBlocks,
-		Users:        users,
-	}
-}
-
-func (m *MemoryEnvironment) StartNodes(t *testing.T, tc *TestConfigs, crConfig deployment.CapabilityRegistryConfig) {
-	require.NotNil(t, m.chains, "start chains first, chains are empty")
-	require.NotNil(t, m.DeployedEnv, "start chains and initiate deployed env first before starting nodes")
-	nodes := memory.NewNodes(t, zapcore.InfoLevel, m.chains, tc.Nodes, tc.Bootstraps, crConfig)
-	ctx := testcontext.Get(t)
-	lggr := logger.Test(t)
-	for _, node := range nodes {
-		require.NoError(t, node.App.Start(ctx))
-		t.Cleanup(func() {
-			require.NoError(t, node.App.Stop())
-		})
-	}
-	m.DeployedEnv.Env = memory.NewMemoryEnvironmentFromChainsNodes(func() context.Context { return ctx }, lggr, m.chains, nodes)
-}
-
-func (m *MemoryEnvironment) MockUSDCAttestationServer(t *testing.T, isUSDCAttestationMissing bool) string {
-	server := mockAttestationResponse(isUSDCAttestationMissing)
-	endpoint := server.URL
-	t.Cleanup(func() {
-		server.Close()
-	})
-	return endpoint
-}
-
-// NewMemoryEnvironment creates an in-memory environment based on the testconfig requested
-func NewMemoryEnvironment(t *testing.T, opts ...TestOps) DeployedEnv {
-	testCfg := DefaultTestConfigs()
-	for _, opt := range opts {
-		opt(testCfg)
-	}
-	env := &MemoryEnvironment{}
-	if testCfg.CreateJobAndContracts {
-		return NewEnvironmentWithJobsAndContracts(t, testCfg, env)
-	}
-	if testCfg.CreateJob {
-		return NewEnvironmentWithJobs(t, testCfg, env)
-	}
-	return NewEnvironment(t, testCfg, env)
-}
-
-func NewEnvironment(t *testing.T, tc *TestConfigs, tEnv TestEnvironment) DeployedEnv {
-	lggr := logger.Test(t)
-	tEnv.StartChains(t, tc)
-	dEnv := tEnv.DeployedEnvironment()
-	require.NotEmpty(t, dEnv.FeedChainSel)
-	require.NotEmpty(t, dEnv.HomeChainSel)
-	require.NotEmpty(t, dEnv.Env.Chains)
-	ab := deployment.NewMemoryAddressBook()
-	crConfig := DeployTestContracts(t, lggr, ab, dEnv.HomeChainSel, dEnv.FeedChainSel, dEnv.Env.Chains, tc.LinkPrice, tc.WethPrice)
-	tEnv.StartNodes(t, tc, crConfig)
-
-	envNodes, err := deployment.NodeInfo(dEnv.Env.NodeIDs, dEnv.Env.Offchain)
-	require.NoError(t, err)
-	dEnv.Env.ExistingAddresses = ab
-	_, err = deployHomeChain(lggr, dEnv.Env, dEnv.Env.ExistingAddresses, dEnv.Env.Chains[dEnv.HomeChainSel],
-		NewTestRMNStaticConfig(),
-		NewTestRMNDynamicConfig(),
-		NewTestNodeOperator(dEnv.Env.Chains[dEnv.HomeChainSel].DeployerKey.From),
-		map[string][][32]byte{
-			"NodeOperator": envNodes.NonBootstraps().PeerIDs(),
-		},
-	)
-	require.NoError(t, err)
-
-	return tEnv.DeployedEnvironment()
-}
-
-func NewEnvironmentWithJobsAndContracts(t *testing.T, tc *TestConfigs, tEnv TestEnvironment) DeployedEnv {
-	var err error
-	e := NewEnvironment(t, tc, tEnv)
-	allChains := e.Env.AllChainSelectors()
-	mcmsCfg := make(map[uint64]commontypes.MCMSWithTimelockConfig)
-
-	for _, c := range e.Env.AllChainSelectors() {
-		mcmsCfg[c] = commontypes.MCMSWithTimelockConfig{
-			Canceller:         commonchangeset.SingleGroupMCMS(t),
-			Bypasser:          commonchangeset.SingleGroupMCMS(t),
-			Proposer:          commonchangeset.SingleGroupMCMS(t),
-			TimelockExecutors: e.Env.AllDeployerKeys(),
-			TimelockMinDelay:  big.NewInt(0),
-		}
-	}
-	var (
-		usdcChains   []uint64
-		isMulticall3 bool
-	)
-	if tc != nil {
-		if tc.IsUSDC {
-			usdcChains = allChains
-		}
-		isMulticall3 = tc.IsMultiCall3
-	}
-	// Need to deploy prerequisites first so that we can form the USDC config
-	// no proposals to be made, timelock can be passed as nil here
-	e.Env, err = commonchangeset.ApplyChangesets(t, e.Env, nil, []commonchangeset.ChangesetApplication{
-		{
-			Changeset: commonchangeset.WrapChangeSet(commonchangeset.DeployLinkToken),
-			Config:    allChains,
-		},
-		{
-			Changeset: commonchangeset.WrapChangeSet(DeployPrerequisites),
-			Config: DeployPrerequisiteConfig{
-				ChainSelectors: allChains,
-				Opts: []PrerequisiteOpt{
-					WithUSDCChains(usdcChains),
-					WithMulticall3(isMulticall3),
-				},
-			},
-		},
-		{
-			Changeset: commonchangeset.WrapChangeSet(commonchangeset.DeployMCMSWithTimelock),
-			Config:    mcmsCfg,
-		},
-		{
-			Changeset: commonchangeset.WrapChangeSet(DeployChainContracts),
-			Config: DeployChainContractsConfig{
-				ChainSelectors:    allChains,
-				HomeChainSelector: e.HomeChainSel,
-			},
-		},
-	})
-	require.NoError(t, err)
-
-	state, err := LoadOnchainState(e.Env)
-	require.NoError(t, err)
-	// Assert USDC set up as expected.
-	for _, chain := range usdcChains {
-		require.NotNil(t, state.Chains[chain].MockUSDCTokenMessenger)
-		require.NotNil(t, state.Chains[chain].MockUSDCTransmitter)
-		require.NotNil(t, state.Chains[chain].USDCTokenPool)
-	}
-	// Assert link present
-	require.NotNil(t, state.Chains[e.FeedChainSel].LinkToken)
-	require.NotNil(t, state.Chains[e.FeedChainSel].Weth9)
-
-	tokenConfig := NewTestTokenConfig(state.Chains[e.FeedChainSel].USDFeeds)
-	var tokenDataProviders []pluginconfig.TokenDataObserverConfig
-	if len(usdcChains) > 0 {
-		endpoint := tEnv.MockUSDCAttestationServer(t, tc.IsUSDCAttestationMissing)
-		cctpContracts := make(map[cciptypes.ChainSelector]pluginconfig.USDCCCTPTokenConfig)
-		for _, usdcChain := range usdcChains {
-			cctpContracts[cciptypes.ChainSelector(usdcChain)] = pluginconfig.USDCCCTPTokenConfig{
-				SourcePoolAddress:            state.Chains[usdcChain].USDCTokenPool.Address().String(),
-				SourceMessageTransmitterAddr: state.Chains[usdcChain].MockUSDCTransmitter.Address().String(),
-			}
-		}
-		tokenDataProviders = append(tokenDataProviders, pluginconfig.TokenDataObserverConfig{
-			Type:    pluginconfig.USDCCCTPHandlerType,
-			Version: "1.0",
-			USDCCCTPObserverConfig: &pluginconfig.USDCCCTPObserverConfig{
-				Tokens:                 cctpContracts,
-				AttestationAPI:         endpoint,
-				AttestationAPITimeout:  commonconfig.MustNewDuration(time.Second),
-				AttestationAPIInterval: commonconfig.MustNewDuration(500 * time.Millisecond),
-			}})
-	}
-	// Build the per chain config.
-	chainConfigs := make(map[uint64]CCIPOCRParams)
-	timelocksPerChain := make(map[uint64]*gethwrappers.RBACTimelock)
-	for _, chain := range allChains {
-		timelocksPerChain[chain] = state.Chains[chain].Timelock
-		tokenInfo := tokenConfig.GetTokenInfo(e.Env.Logger, state.Chains[chain].LinkToken, state.Chains[chain].Weth9)
-		ocrParams := DefaultOCRParams(e.FeedChainSel, tokenInfo, tokenDataProviders)
-		if tc.OCRConfigOverride != nil {
-			ocrParams = tc.OCRConfigOverride(ocrParams)
-		}
-		chainConfigs[chain] = ocrParams
-	}
-	// Deploy second set of changesets to deploy and configure the CCIP contracts.
-	e.Env, err = commonchangeset.ApplyChangesets(t, e.Env, timelocksPerChain, []commonchangeset.ChangesetApplication{
-		{
-			Changeset: commonchangeset.WrapChangeSet(ConfigureNewChains),
-			Config: NewChainsConfig{
-				HomeChainSel:       e.HomeChainSel,
-				FeedChainSel:       e.FeedChainSel,
-				ChainConfigByChain: chainConfigs,
-			},
-		},
-		{
-			Changeset: commonchangeset.WrapChangeSet(CCIPCapabilityJobspec),
-		},
-	})
-	require.NoError(t, err)
-
-	ReplayLogs(t, e.Env.Offchain, e.ReplayBlocks)
-
-	state, err = LoadOnchainState(e.Env)
-	require.NoError(t, err)
-	require.NotNil(t, state.Chains[e.HomeChainSel].CapabilityRegistry)
-	require.NotNil(t, state.Chains[e.HomeChainSel].CCIPHome)
-	require.NotNil(t, state.Chains[e.HomeChainSel].RMNHome)
-	for _, chain := range allChains {
-		require.NotNil(t, state.Chains[chain].LinkToken)
-		require.NotNil(t, state.Chains[chain].Weth9)
-		require.NotNil(t, state.Chains[chain].TokenAdminRegistry)
-		require.NotNil(t, state.Chains[chain].RegistryModule)
-		require.NotNil(t, state.Chains[chain].Router)
-		require.NotNil(t, state.Chains[chain].RMNRemote)
-		require.NotNil(t, state.Chains[chain].TestRouter)
-		require.NotNil(t, state.Chains[chain].NonceManager)
-		require.NotNil(t, state.Chains[chain].FeeQuoter)
-		require.NotNil(t, state.Chains[chain].OffRamp)
-		require.NotNil(t, state.Chains[chain].OnRamp)
-	}
-	return e
-}
-
-// NewEnvironmentWithJobs creates a new CCIP environment
-// with capreg, fee tokens, feeds, nodes and jobs set up.
-func NewEnvironmentWithJobs(t *testing.T, tc *TestConfigs, tEnv TestEnvironment) DeployedEnv {
-	e := NewEnvironment(t, tc, tEnv)
-	e.SetupJobs(t)
-	return e
-}
-
 func ReplayLogs(t *testing.T, oc deployment.OffchainClient, replayBlocks map[uint64]uint64) {
 	switch oc := oc.(type) {
 	case *memory.JobClient:
@@ -844,35 +566,6 @@ func ConfirmRequestOnSourceAndDest(t *testing.T, env deployment.Environment, sta
 	return nil
 }
 
-// TODO: Remove this to replace with ApplyChangeset
-func ProcessChangeset(t *testing.T, e deployment.Environment, c deployment.ChangesetOutput) {
-
-	// TODO: Add support for jobspecs as well
-
-	// sign and execute all proposals provided
-	if len(c.Proposals) != 0 {
-		state, err := LoadOnchainState(e)
-		require.NoError(t, err)
-		for _, prop := range c.Proposals {
-			chains := mapset.NewSet[uint64]()
-			for _, op := range prop.Transactions {
-				chains.Add(uint64(op.ChainIdentifier))
-			}
-
-			signed := commonchangeset.SignProposal(t, e, &prop)
-			for _, sel := range chains.ToSlice() {
-				commonchangeset.ExecuteProposal(t, e, signed, state.Chains[sel].Timelock, sel)
-			}
-		}
-	}
-
-	// merge address books
-	if c.AddressBook != nil {
-		err := e.ExistingAddresses.Merge(c.AddressBook)
-		require.NoError(t, err)
-	}
-}
-
 func DeployTransferableToken(
 	lggr logger.Logger,
 	chains map[uint64]deployment.Chain,
diff --git a/deployment/ccip/changeset/view_test.go b/deployment/ccip/changeset/view_test.go
index 934b937f7b5..11430bfbddf 100644
--- a/deployment/ccip/changeset/view_test.go
+++ b/deployment/ccip/changeset/view_test.go
@@ -4,19 +4,10 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/require"
-
-	"github.com/smartcontractkit/chainlink/deployment/environment/memory"
-	"github.com/smartcontractkit/chainlink/v2/core/logger"
 )
 
 func TestSmokeView(t *testing.T) {
-	lggr := logger.TestLogger(t)
-	tenv := NewMemoryEnvironmentWithJobsAndContracts(t, lggr, memory.MemoryEnvironmentConfig{
-		Chains:             3,
-		Nodes:              4,
-		Bootstraps:         1,
-		NumOfUsersPerChain: 1,
-	}, nil)
+	tenv := NewMemoryEnvironment(t, WithChains(3))
 	_, err := ViewCCIP(tenv.Env)
 	require.NoError(t, err)
 }
diff --git a/integration-tests/smoke/ccip/ccip_batching_test.go b/integration-tests/smoke/ccip/ccip_batching_test.go
index 8c3615fbb20..1f05c8e02a5 100644
--- a/integration-tests/smoke/ccip/ccip_batching_test.go
+++ b/integration-tests/smoke/ccip/ccip_batching_test.go
@@ -14,7 +14,8 @@ import (
 
 	"github.com/smartcontractkit/chainlink-ccip/pkg/types/ccipocr3"
 	"github.com/smartcontractkit/chainlink-common/pkg/merklemulti"
-	"github.com/smartcontractkit/chainlink/deployment/environment/memory"
+
+	testsetups "github.com/smartcontractkit/chainlink/integration-tests/testsetups/ccip"
 
 	"github.com/smartcontractkit/chainlink/deployment"
 	"github.com/smartcontractkit/chainlink/deployment/ccip/changeset"
@@ -22,7 +23,6 @@ import (
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/onramp"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/router"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/shared/generated/multicall3"
-	"github.com/smartcontractkit/chainlink/v2/core/logger"
 )
 
 const (
@@ -39,18 +39,12 @@ type batchTestSetup struct {
 
 func newBatchTestSetup(t *testing.T) batchTestSetup {
 	// Setup 3 chains, with 2 lanes going to the dest.
-	e := changeset.NewMemoryEnvironmentWithJobsAndContracts(
+	e, _ := testsetups.NewIntegrationEnvironment(
 		t,
-		logger.TestLogger(t),
-		memory.MemoryEnvironmentConfig{
-			Chains:             3,
-			Nodes:              4,
-			Bootstraps:         1,
-			NumOfUsersPerChain: 2,
-		},
-		&changeset.TestConfigs{
-			IsMultiCall3: true,
-		},
+		changeset.WithMultiCall3(),
+		changeset.WithEnvironmentType(changeset.Memory),
+		changeset.WithChains(3),
+		changeset.WithUsersPerChain(2),
 	)
 
 	state, err := changeset.LoadOnchainState(e.Env)
diff --git a/integration-tests/smoke/ccip/ccip_fee_boosting_test.go b/integration-tests/smoke/ccip/ccip_fee_boosting_test.go
index 1fe9d5817c9..97331e2d968 100644
--- a/integration-tests/smoke/ccip/ccip_fee_boosting_test.go
+++ b/integration-tests/smoke/ccip/ccip_fee_boosting_test.go
@@ -10,7 +10,9 @@ import (
 	"github.com/pkg/errors"
 
 	"github.com/smartcontractkit/chainlink-common/pkg/config"
+
 	commonchangeset "github.com/smartcontractkit/chainlink/deployment/common/changeset"
+	testsetups "github.com/smartcontractkit/chainlink/integration-tests/testsetups/ccip"
 
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
@@ -20,7 +22,6 @@ import (
 	"github.com/smartcontractkit/chainlink-common/pkg/utils/tests"
 	"github.com/smartcontractkit/chainlink-testing-framework/lib/utils/testcontext"
 
-	"github.com/smartcontractkit/chainlink/deployment/environment/memory"
 	"github.com/smartcontractkit/chainlink/v2/core/capabilities/ccip/ccipevm"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/fee_quoter"
 
@@ -30,7 +31,6 @@ import (
 	"github.com/smartcontractkit/chainlink/deployment/ccip/changeset"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/onramp"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/router"
-	"github.com/smartcontractkit/chainlink/v2/core/logger"
 )
 
 var (
@@ -39,24 +39,22 @@ var (
 )
 
 func Test_CCIPFeeBoosting(t *testing.T) {
-	e := changeset.NewMemoryEnvironmentWithJobsAndContracts(t, logger.TestLogger(t),
-		memory.MemoryEnvironmentConfig{
-			Chains:     2,
-			Nodes:      4,
-			Bootstraps: 1,
-		}, &changeset.TestConfigs{
-			OCRConfigOverride: func(params changeset.CCIPOCRParams) changeset.CCIPOCRParams {
-				// Only 1 boost (=OCR round) is enough to cover the fee
-				params.ExecuteOffChainConfig.RelativeBoostPerWaitHour = 10
-				// Disable token price updates
-				params.CommitOffChainConfig.TokenPriceBatchWriteFrequency = *config.MustNewDuration(1_000_000 * time.Hour)
-				// Disable gas price updates
-				params.CommitOffChainConfig.RemoteGasPriceBatchWriteFrequency = *config.MustNewDuration(1_000_000 * time.Hour)
-				// Disable token price updates
-				params.CommitOffChainConfig.TokenInfo = nil
-				return params
-			},
-		})
+	e, _ := testsetups.NewIntegrationEnvironment(
+		t,
+		changeset.WithMultiCall3(),
+		changeset.WithEnvironmentType(changeset.Memory),
+		changeset.WithOCRConfigOverride(func(params changeset.CCIPOCRParams) changeset.CCIPOCRParams {
+			// Only 1 boost (=OCR round) is enough to cover the fee
+			params.ExecuteOffChainConfig.RelativeBoostPerWaitHour = 10
+			// Disable token price updates
+			params.CommitOffChainConfig.TokenPriceBatchWriteFrequency = *config.MustNewDuration(1_000_000 * time.Hour)
+			// Disable gas price updates
+			params.CommitOffChainConfig.RemoteGasPriceBatchWriteFrequency = *config.MustNewDuration(1_000_000 * time.Hour)
+			// Disable token price updates
+			params.CommitOffChainConfig.TokenInfo = nil
+			return params
+		}),
+	)
 
 	state, err := changeset.LoadOnchainState(e.Env)
 	require.NoError(t, err)
diff --git a/integration-tests/smoke/ccip/ccip_fees_test.go b/integration-tests/smoke/ccip/ccip_fees_test.go
index 791ba8f2619..366507bcad3 100644
--- a/integration-tests/smoke/ccip/ccip_fees_test.go
+++ b/integration-tests/smoke/ccip/ccip_fees_test.go
@@ -14,7 +14,7 @@ import (
 
 	"github.com/smartcontractkit/chainlink/deployment"
 	"github.com/smartcontractkit/chainlink/deployment/ccip/changeset"
-	"github.com/smartcontractkit/chainlink/deployment/environment/memory"
+	testsetups "github.com/smartcontractkit/chainlink/integration-tests/testsetups/ccip"
 	"github.com/smartcontractkit/chainlink/v2/core/chains/evm/assets"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/router"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/generated/weth9_wrapper"
@@ -101,11 +101,11 @@ func setupTokens(
 
 func Test_CCIPFees(t *testing.T) {
 	t.Parallel()
-	tenv := changeset.NewMemoryEnvironmentWithJobsAndContracts(t, logger.TestLogger(t), memory.MemoryEnvironmentConfig{
-		Chains:     2,
-		Nodes:      4,
-		Bootstraps: 1,
-	}, nil)
+	tenv, _ := testsetups.NewIntegrationEnvironment(
+		t,
+		changeset.WithMultiCall3(),
+		changeset.WithEnvironmentType(changeset.Memory),
+	)
 	e := tenv.Env
 
 	allChains := tenv.Env.AllChainSelectors()
diff --git a/integration-tests/smoke/ccip/ccip_gas_price_updates_test.go b/integration-tests/smoke/ccip/ccip_gas_price_updates_test.go
index 221d35bd992..bb8b4e5da92 100644
--- a/integration-tests/smoke/ccip/ccip_gas_price_updates_test.go
+++ b/integration-tests/smoke/ccip/ccip_gas_price_updates_test.go
@@ -12,27 +12,27 @@ import (
 
 	"github.com/smartcontractkit/chainlink-common/pkg/config"
 	"github.com/smartcontractkit/chainlink-common/pkg/utils/tests"
+
 	"github.com/smartcontractkit/chainlink/deployment"
 	"github.com/smartcontractkit/chainlink/deployment/ccip/changeset"
 	testsetups "github.com/smartcontractkit/chainlink/integration-tests/testsetups/ccip"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/fee_quoter"
-	"github.com/smartcontractkit/chainlink/v2/core/logger"
 )
 
 // Test_CCIPGasPriceUpdates tests that chain fee price updates are propagated correctly when
 // price reaches some deviation threshold or when the price has expired.
 func Test_CCIPGasPriceUpdates(t *testing.T) {
-	lggr := logger.TestLogger(t)
 	ctx := changeset.Context(t)
 	callOpts := &bind.CallOpts{Context: ctx}
 
 	var gasPriceExpiry = 5 * time.Second
-	e, _, _ := testsetups.NewLocalDevEnvironmentWithDefaultPrice(t, lggr, &changeset.TestConfigs{
-		OCRConfigOverride: func(params changeset.CCIPOCRParams) changeset.CCIPOCRParams {
+	e, _ := testsetups.NewIntegrationEnvironment(t,
+		changeset.WithEnvironmentType(changeset.Docker),
+		changeset.WithOCRConfigOverride(func(params changeset.CCIPOCRParams) changeset.CCIPOCRParams {
 			params.CommitOffChainConfig.RemoteGasPriceBatchWriteFrequency = *config.MustNewDuration(gasPriceExpiry)
 			return params
-		},
-	})
+		}),
+	)
 	state, err := changeset.LoadOnchainState(e.Env)
 	require.NoError(t, err)
 	require.NoError(t, changeset.AddLanesForAll(e.Env, state))
diff --git a/integration-tests/smoke/ccip/ccip_message_limitations_test.go b/integration-tests/smoke/ccip/ccip_message_limitations_test.go
index 902d07aec5c..b3d2ecd3952 100644
--- a/integration-tests/smoke/ccip/ccip_message_limitations_test.go
+++ b/integration-tests/smoke/ccip/ccip_message_limitations_test.go
@@ -17,15 +17,15 @@ import (
 	"github.com/smartcontractkit/chainlink/deployment/ccip/changeset"
 	testsetups "github.com/smartcontractkit/chainlink/integration-tests/testsetups/ccip"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/router"
-	"github.com/smartcontractkit/chainlink/v2/core/logger"
 )
 
 func Test_CCIPMessageLimitations(t *testing.T) {
-	lggr := logger.TestLogger(t)
 	ctx := testcontext.Get(t)
 	callOpts := &bind.CallOpts{Context: ctx}
 
-	testEnv, _, _ := testsetups.NewLocalDevEnvironmentWithDefaultPrice(t, lggr, &changeset.TestConfigs{})
+	testEnv, _ := testsetups.NewIntegrationEnvironment(t,
+		changeset.WithEnvironmentType(changeset.Docker),
+	)
 	chains := maps.Keys(testEnv.Env.Chains)
 
 	onChainState, err := changeset.LoadOnchainState(testEnv.Env)
diff --git a/integration-tests/smoke/ccip/ccip_messaging_test.go b/integration-tests/smoke/ccip/ccip_messaging_test.go
index 07e237451c8..18a0531c844 100644
--- a/integration-tests/smoke/ccip/ccip_messaging_test.go
+++ b/integration-tests/smoke/ccip/ccip_messaging_test.go
@@ -18,11 +18,10 @@ import (
 
 	"github.com/smartcontractkit/chainlink/deployment"
 	"github.com/smartcontractkit/chainlink/deployment/ccip/changeset"
-	"github.com/smartcontractkit/chainlink/deployment/environment/memory"
+	testsetups "github.com/smartcontractkit/chainlink/integration-tests/testsetups/ccip"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/offramp"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/onramp"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/router"
-	"github.com/smartcontractkit/chainlink/v2/core/logger"
 )
 
 type testCaseSetup struct {
@@ -48,11 +47,10 @@ type messagingTestCaseOutput struct {
 func Test_CCIPMessaging(t *testing.T) {
 	// Setup 2 chains and a single lane.
 	ctx := changeset.Context(t)
-	e := changeset.NewMemoryEnvironmentWithJobsAndContracts(t, logger.TestLogger(t), memory.MemoryEnvironmentConfig{
-		Chains:     2,
-		Nodes:      4,
-		Bootstraps: 1,
-	}, nil)
+	e, _ := testsetups.NewIntegrationEnvironment(
+		t,
+		changeset.WithEnvironmentType(changeset.Memory),
+	)
 
 	state, err := changeset.LoadOnchainState(e.Env)
 	require.NoError(t, err)
diff --git a/integration-tests/smoke/ccip/ccip_ooo_execution_test.go b/integration-tests/smoke/ccip/ccip_ooo_execution_test.go
index 86ddd07ec85..b0b1e4f9e66 100644
--- a/integration-tests/smoke/ccip/ccip_ooo_execution_test.go
+++ b/integration-tests/smoke/ccip/ccip_ooo_execution_test.go
@@ -12,9 +12,10 @@ import (
 
 	"github.com/smartcontractkit/chainlink-ccip/pkg/types/ccipocr3"
 	"github.com/smartcontractkit/chainlink-common/pkg/utils/tests"
+
 	"github.com/smartcontractkit/chainlink/deployment"
 	"github.com/smartcontractkit/chainlink/deployment/ccip/changeset"
-	"github.com/smartcontractkit/chainlink/deployment/environment/memory"
+	testsetups "github.com/smartcontractkit/chainlink/integration-tests/testsetups/ccip"
 	"github.com/smartcontractkit/chainlink/v2/core/chains/evm/utils"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/router"
 	"github.com/smartcontractkit/chainlink/v2/core/logger"
@@ -32,16 +33,13 @@ import (
 func Test_OutOfOrderExecution(t *testing.T) {
 	lggr := logger.TestLogger(t)
 	ctx := tests.Context(t)
-	config := &changeset.TestConfigs{
-		IsUSDC:                   true,
-		IsUSDCAttestationMissing: true,
-	}
-	tenv := changeset.NewMemoryEnvironmentWithJobsAndContracts(t, logger.TestLogger(t), memory.MemoryEnvironmentConfig{
-		Chains:             2,
-		Nodes:              4,
-		Bootstraps:         1,
-		NumOfUsersPerChain: 2,
-	}, config)
+	tenv, _ := testsetups.NewIntegrationEnvironment(
+		t,
+		changeset.WithUSDC(),
+		changeset.WithUSDCAttestationMissing(),
+		changeset.WithEnvironmentType(changeset.Memory),
+		changeset.WithUsersPerChain(2),
+	)
 
 	e := tenv.Env
 	state, err := changeset.LoadOnchainState(e)
diff --git a/integration-tests/smoke/ccip/ccip_rmn_test.go b/integration-tests/smoke/ccip/ccip_rmn_test.go
index 6cd6bd9d63f..740c525d037 100644
--- a/integration-tests/smoke/ccip/ccip_rmn_test.go
+++ b/integration-tests/smoke/ccip/ccip_rmn_test.go
@@ -22,9 +22,9 @@ import (
 	"github.com/smartcontractkit/chainlink-protos/job-distributor/v1/node"
 	"github.com/smartcontractkit/chainlink-testing-framework/lib/utils/osutil"
 	"github.com/smartcontractkit/chainlink-testing-framework/lib/utils/testcontext"
-	"github.com/smartcontractkit/chainlink/deployment/environment/devenv"
 
 	"github.com/smartcontractkit/chainlink/deployment/ccip/changeset"
+	"github.com/smartcontractkit/chainlink/deployment/environment/devenv"
 
 	"github.com/smartcontractkit/chainlink/deployment"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/rmn_home"
@@ -32,7 +32,6 @@ import (
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/router"
 
 	testsetups "github.com/smartcontractkit/chainlink/integration-tests/testsetups/ccip"
-	"github.com/smartcontractkit/chainlink/v2/core/logger"
 )
 
 func TestRMN_TwoMessagesOnTwoLanesIncludingBatching(t *testing.T) {
@@ -244,7 +243,10 @@ func runRmnTestCase(t *testing.T, tc rmnTestCase) {
 	ctx := testcontext.Get(t)
 	t.Logf("Running RMN test case: %s", tc.name)
 
-	envWithRMN, rmnCluster := testsetups.NewLocalDevEnvironmentWithRMN(t, logger.TestLogger(t), len(tc.rmnNodes))
+	envWithRMN, rmnCluster := testsetups.NewIntegrationEnvironment(t,
+		changeset.WithEnvironmentType(changeset.Docker),
+		changeset.WithRMNEnabled(len(tc.rmnNodes)),
+	)
 	t.Logf("envWithRmn: %#v", envWithRMN)
 
 	tc.populateFields(t, envWithRMN, rmnCluster)
diff --git a/integration-tests/smoke/ccip/ccip_token_price_updates_test.go b/integration-tests/smoke/ccip/ccip_token_price_updates_test.go
index 6a193397d7e..8f3cec6fe64 100644
--- a/integration-tests/smoke/ccip/ccip_token_price_updates_test.go
+++ b/integration-tests/smoke/ccip/ccip_token_price_updates_test.go
@@ -16,25 +16,24 @@ import (
 	"github.com/smartcontractkit/chainlink-common/pkg/config"
 	"github.com/smartcontractkit/chainlink-common/pkg/utils/tests"
 	"github.com/smartcontractkit/chainlink-protos/job-distributor/v1/node"
+
 	"github.com/smartcontractkit/chainlink/deployment"
 	"github.com/smartcontractkit/chainlink/deployment/ccip/changeset"
 	testsetups "github.com/smartcontractkit/chainlink/integration-tests/testsetups/ccip"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/fee_quoter"
-	"github.com/smartcontractkit/chainlink/v2/core/logger"
 )
 
 func Test_CCIPTokenPriceUpdates(t *testing.T) {
-	lggr := logger.TestLogger(t)
 	ctx := changeset.Context(t)
 	callOpts := &bind.CallOpts{Context: ctx}
 
 	var tokenPriceExpiry = 5 * time.Second
-	e, _, _ := testsetups.NewLocalDevEnvironmentWithDefaultPrice(t, lggr, &changeset.TestConfigs{
-		OCRConfigOverride: func(params changeset.CCIPOCRParams) changeset.CCIPOCRParams {
+	e, _ := testsetups.NewIntegrationEnvironment(t,
+		changeset.WithEnvironmentType(changeset.Docker),
+		changeset.WithOCRConfigOverride(func(params changeset.CCIPOCRParams) changeset.CCIPOCRParams {
 			params.CommitOffChainConfig.TokenPriceBatchWriteFrequency = *config.MustNewDuration(tokenPriceExpiry)
 			return params
-		},
-	})
+		}))
 	state, err := changeset.LoadOnchainState(e.Env)
 	require.NoError(t, err)
 	require.NoError(t, changeset.AddLanesForAll(e.Env, state))
diff --git a/integration-tests/smoke/ccip/ccip_token_transfer_test.go b/integration-tests/smoke/ccip/ccip_token_transfer_test.go
index fa054268901..5637522169d 100644
--- a/integration-tests/smoke/ccip/ccip_token_transfer_test.go
+++ b/integration-tests/smoke/ccip/ccip_token_transfer_test.go
@@ -12,7 +12,7 @@ import (
 	"github.com/smartcontractkit/chainlink-common/pkg/utils/tests"
 
 	"github.com/smartcontractkit/chainlink/deployment/ccip/changeset"
-	"github.com/smartcontractkit/chainlink/deployment/environment/memory"
+	testsetups "github.com/smartcontractkit/chainlink/integration-tests/testsetups/ccip"
 	"github.com/smartcontractkit/chainlink/v2/core/chains/evm/utils"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/router"
 	"github.com/smartcontractkit/chainlink/v2/core/logger"
@@ -21,14 +21,10 @@ import (
 func TestTokenTransfer(t *testing.T) {
 	lggr := logger.TestLogger(t)
 	ctx := tests.Context(t)
-	config := &changeset.TestConfigs{}
-
-	tenv := changeset.NewMemoryEnvironmentWithJobsAndContracts(t, logger.TestLogger(t), memory.MemoryEnvironmentConfig{
-		Chains:             2,
-		Nodes:              4,
-		Bootstraps:         1,
-		NumOfUsersPerChain: 3,
-	}, config)
+
+	tenv, _ := testsetups.NewIntegrationEnvironment(t,
+		changeset.WithEnvironmentType(changeset.Memory),
+		changeset.WithUsersPerChain(3))
 
 	e := tenv.Env
 	state, err := changeset.LoadOnchainState(e)
diff --git a/integration-tests/smoke/ccip/ccip_usdc_test.go b/integration-tests/smoke/ccip/ccip_usdc_test.go
index bfb731a91ac..4caff3efa7f 100644
--- a/integration-tests/smoke/ccip/ccip_usdc_test.go
+++ b/integration-tests/smoke/ccip/ccip_usdc_test.go
@@ -14,7 +14,7 @@ import (
 
 	"github.com/smartcontractkit/chainlink/deployment"
 	"github.com/smartcontractkit/chainlink/deployment/ccip/changeset"
-	"github.com/smartcontractkit/chainlink/deployment/environment/memory"
+	testsetups "github.com/smartcontractkit/chainlink/integration-tests/testsetups/ccip"
 	"github.com/smartcontractkit/chainlink/v2/core/chains/evm/utils"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/router"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/shared/generated/burn_mint_erc677"
@@ -32,15 +32,12 @@ import (
 func TestUSDCTokenTransfer(t *testing.T) {
 	lggr := logger.TestLogger(t)
 	ctx := tests.Context(t)
-	config := &changeset.TestConfigs{
-		IsUSDC: true,
-	}
-	tenv := changeset.NewMemoryEnvironmentWithJobsAndContracts(t, lggr, memory.MemoryEnvironmentConfig{
-		Chains:             3,
-		NumOfUsersPerChain: 3,
-		Nodes:              4,
-		Bootstraps:         1,
-	}, config)
+	tenv, _ := testsetups.NewIntegrationEnvironment(t,
+		changeset.WithEnvironmentType(changeset.Memory),
+		changeset.WithUsersPerChain(3),
+		changeset.WithChains(3),
+		changeset.WithUSDC(),
+	)
 
 	e := tenv.Env
 	state, err := changeset.LoadOnchainState(e)
diff --git a/integration-tests/testsetups/ccip/test_helpers.go b/integration-tests/testsetups/ccip/test_helpers.go
index b4a99f4a8de..268cf28e805 100644
--- a/integration-tests/testsetups/ccip/test_helpers.go
+++ b/integration-tests/testsetups/ccip/test_helpers.go
@@ -61,7 +61,7 @@ func (l *DeployedLocalDevEnvironment) DeployedEnvironment() changeset.DeployedEn
 	return l.DeployedEnv
 }
 
-func (l *DeployedLocalDevEnvironment) StartChains(t *testing.T, _ changeset.TestConfigs) {
+func (l *DeployedLocalDevEnvironment) StartChains(t *testing.T, _ *changeset.TestConfigs) {
 	envConfig, testEnv, cfg := CreateDockerEnv(t)
 	l.devEnvTestCfg = cfg
 	l.testEnv = testEnv
@@ -75,7 +75,7 @@ func (l *DeployedLocalDevEnvironment) StartChains(t *testing.T, _ changeset.Test
 	l.DeployedEnv.Users = users
 }
 
-func (l *DeployedLocalDevEnvironment) StartNodes(t *testing.T, _ changeset.TestConfigs, crConfig deployment.CapabilityRegistryConfig) {
+func (l *DeployedLocalDevEnvironment) StartNodes(t *testing.T, _ *changeset.TestConfigs, crConfig deployment.CapabilityRegistryConfig) {
 	require.NotNil(t, l.testEnv, "docker env is empty, start chains first")
 	require.NotEmpty(t, l.devEnvTestCfg, "integration test config is empty, start chains first")
 	require.NotNil(t, l.devEnvCfg, "dev environment config is empty, start chains first")
@@ -129,37 +129,50 @@ func (l *DeployedLocalDevEnvironment) RestartChainlinkNodes(t *testing.T) error
 	return errGrp.Wait()
 }
 
-func NewIntegrationEnvironment(opts ...changeset.TestOps) (changeset.DeployedEnv, devenv.RMNCluster) {
+func NewIntegrationEnvironment(t *testing.T, opts ...changeset.TestOps) (changeset.DeployedEnv, devenv.RMNCluster) {
 	testCfg := changeset.DefaultTestConfigs()
 	for _, opt := range opts {
 		opt(testCfg)
 	}
-
-}
-
-func NewLocalDevEnvironmentWithRMN(
-	t *testing.T,
-	lggr logger.Logger,
-	numRmnNodes int,
-) (changeset.DeployedEnv, devenv.RMNCluster) {
-	env := NewLocalDevEnvironment()
-	changeset.NewEnvironmentWithJobsAndContracts()
-	tenv, dockerenv, testCfg := NewLocalDevEnvironmentWithDefaultPrice(t, lggr, nil)
-	l := logging.GetTestLogger(t)
-	config := GenerateTestRMNConfig(t, numRmnNodes, tenv, MustNetworksToRPCMap(dockerenv.EVMNetworks))
-	require.NotNil(t, testCfg.CCIP)
-	rmnCluster, err := devenv.NewRMNCluster(
-		t, l,
-		[]string{dockerenv.DockerNetwork.ID},
-		config,
-		testCfg.CCIP.RMNConfig.GetProxyImage(),
-		testCfg.CCIP.RMNConfig.GetProxyVersion(),
-		testCfg.CCIP.RMNConfig.GetAFN2ProxyImage(),
-		testCfg.CCIP.RMNConfig.GetAFN2ProxyVersion(),
-		dockerenv.LogStream,
-	)
-	require.NoError(t, err)
-	return tenv, *rmnCluster
+	switch testCfg.Type {
+	case changeset.Memory:
+		memEnv := changeset.NewMemoryEnvironment(t, opts...)
+		return memEnv, devenv.RMNCluster{}
+	case changeset.Docker:
+		dockerEnv := &DeployedLocalDevEnvironment{}
+		if testCfg.RMNEnabled {
+			deployedEnv := changeset.NewEnvironmentWithJobsAndContracts(t, testCfg, dockerEnv)
+			l := logging.GetTestLogger(t)
+			require.NotNil(t, dockerEnv.testEnv, "empty docker environment")
+			config := GenerateTestRMNConfig(t, testCfg.NumOfRMNNodes, deployedEnv, MustNetworksToRPCMap(dockerEnv.testEnv.EVMNetworks))
+			require.NotNil(t, dockerEnv.devEnvTestCfg.CCIP)
+			rmnCluster, err := devenv.NewRMNCluster(
+				t, l,
+				[]string{dockerEnv.testEnv.DockerNetwork.ID},
+				config,
+				dockerEnv.devEnvTestCfg.CCIP.RMNConfig.GetProxyImage(),
+				dockerEnv.devEnvTestCfg.CCIP.RMNConfig.GetProxyVersion(),
+				dockerEnv.devEnvTestCfg.CCIP.RMNConfig.GetAFN2ProxyImage(),
+				dockerEnv.devEnvTestCfg.CCIP.RMNConfig.GetAFN2ProxyVersion(),
+				dockerEnv.testEnv.LogStream,
+			)
+			require.NoError(t, err)
+			return deployedEnv, *rmnCluster
+		}
+		if testCfg.CreateJobAndContracts {
+			deployedEnv := changeset.NewEnvironmentWithJobsAndContracts(t, testCfg, dockerEnv)
+			require.NotNil(t, dockerEnv.testEnv, "empty docker environment")
+			return deployedEnv, devenv.RMNCluster{}
+		}
+		if testCfg.CreateJob {
+			deployedEnv := changeset.NewEnvironmentWithJobs(t, testCfg, dockerEnv)
+			require.NotNil(t, dockerEnv.testEnv, "empty docker environment")
+			return deployedEnv, devenv.RMNCluster{}
+		}
+	default:
+		require.Failf(t, "Type %s not supported in integration tests choose between %s and %s", string(testCfg.Type), changeset.Memory, changeset.Docker)
+	}
+	return changeset.DeployedEnv{}, devenv.RMNCluster{}
 }
 
 func MustNetworksToRPCMap(evmNetworks []*blockchain.EVMNetwork) map[uint64]string {