diff --git a/src/hooks/tests/use-add-site.test.tsx b/src/hooks/tests/use-add-site.test.tsx
index c56433daf..d1f24d416 100644
--- a/src/hooks/tests/use-add-site.test.tsx
+++ b/src/hooks/tests/use-add-site.test.tsx
@@ -3,10 +3,9 @@ import { renderHook, act } from '@testing-library/react';
 import nock from 'nock';
 import { Provider } from 'react-redux';
 import { useSyncSites } from 'src/hooks/sync-sites';
-import { useAddSite } from 'src/hooks/use-add-site';
+import { useAddSite, CreateSiteFormValues } from 'src/hooks/use-add-site';
 import { useContentTabs } from 'src/hooks/use-content-tabs';
 import { useSiteDetails } from 'src/hooks/use-site-details';
-import { getWordPressProvider } from 'src/lib/wordpress-provider';
 import { store } from 'src/stores';
 import { setProviderConstants } from 'src/stores/provider-constants-slice';
 import type { SyncSite } from 'src/modules/sync/types';
@@ -19,22 +18,24 @@ jest.mock( 'src/hooks/use-import-export', () => ( {
 	useImportExport: () => ( {
 		importFile: jest.fn(),
 		clearImportState: jest.fn(),
+		importState: {},
 	} ),
 } ) );
 
 const mockConnectWpcomSites = jest.fn().mockResolvedValue( undefined );
+const mockShowOpenFolderDialog = jest.fn();
+const mockGenerateProposedSitePath = jest.fn();
+const mockComparePaths = jest.fn().mockResolvedValue( false );
+
 jest.mock( 'src/lib/get-ipc-api', () => ( {
 	getIpcApi: () => ( {
-		generateProposedSitePath: jest.fn().mockResolvedValue( {
-			path: '/default/path',
-			name: 'Default Site',
-			isEmpty: true,
-			isWordPress: false,
-		} ),
+		generateProposedSitePath: mockGenerateProposedSitePath,
+		showOpenFolderDialog: mockShowOpenFolderDialog,
 		showNotification: jest.fn(),
 		getAllCustomDomains: jest.fn().mockResolvedValue( [] ),
 		connectWpcomSites: mockConnectWpcomSites,
 		getConnectedWpcomSites: jest.fn().mockResolvedValue( [] ),
+		comparePaths: mockComparePaths,
 	} ),
 } ) );
 
@@ -64,6 +65,13 @@ describe( 'useAddSite', () => {
 			} )
 		);
 
+		mockGenerateProposedSitePath.mockResolvedValue( {
+			path: '/default/path',
+			name: 'Default Site',
+			isEmpty: true,
+			isWordPress: false,
+		} );
+
 		( useSiteDetails as jest.Mock ).mockReturnValue( {
 			createSite: mockCreateSite,
 			updateSite: mockUpdateSite,
@@ -126,39 +134,19 @@ describe( 'useAddSite', () => {
 		nock.cleanAll();
 	} );
 
-	it( 'should initialize with default WordPress version', () => {
+	it( 'should provide default PHP version', () => {
 		const { result } = renderHookWithProvider( () => useAddSite() );
 
-		expect( result.current.wpVersion ).toBe( getWordPressProvider().DEFAULT_WORDPRESS_VERSION );
+		expect( result.current.defaultPhpVersion ).toBe( '8.3' );
 	} );
 
-	it( 'should initialize with default PHP version', () => {
+	it( 'should provide default WordPress version', () => {
 		const { result } = renderHookWithProvider( () => useAddSite() );
 
-		expect( result.current.phpVersion ).toBe( '8.3' );
-	} );
-
-	it( 'should update WordPress version when setWpVersion is called', () => {
-		const { result } = renderHookWithProvider( () => useAddSite() );
-
-		act( () => {
-			result.current.setWpVersion( '6.1.7' );
-		} );
-
-		expect( result.current.wpVersion ).toBe( '6.1.7' );
-	} );
-
-	it( 'should update PHP version when setPhpVersion is called', () => {
-		const { result } = renderHookWithProvider( () => useAddSite() );
-
-		act( () => {
-			result.current.setPhpVersion( '8.2' );
-		} );
-
-		expect( result.current.phpVersion ).toBe( '8.2' );
+		expect( result.current.defaultWpVersion ).toBe( 'latest' );
 	} );
 
-	it( 'should pass WordPress version to createSite when handleAddSiteClick is called', async () => {
+	it( 'should create site with provided form values', async () => {
 		mockCreateSite.mockImplementation(
 			( path, name, wpVersion, customDomain, enableHttps, blueprint, phpVersion, callback ) => {
 				callback( {
@@ -174,27 +162,54 @@ describe( 'useAddSite', () => {
 
 		const { result } = renderHookWithProvider( () => useAddSite() );
 
-		act( () => {
-			result.current.setWpVersion( '6.1.7' );
-			result.current.setSitePath( '/test/path' );
-		} );
+		const formValues: CreateSiteFormValues = {
+			siteName: 'My Test Site',
+			sitePath: '/test/path',
+			phpVersion: '8.2',
+			wpVersion: '6.1.7',
+			useCustomDomain: false,
+			customDomain: null,
+			enableHttps: false,
+		};
 
 		await act( async () => {
-			await result.current.handleAddSiteClick();
+			await result.current.handleCreateSite( formValues );
 		} );
 
 		expect( mockCreateSite ).toHaveBeenCalledWith(
 			'/test/path',
-			'',
+			'My Test Site',
 			'6.1.7',
 			undefined,
 			false,
 			undefined, // blueprint parameter
-			'8.3',
+			'8.2',
 			expect.any( Function )
 		);
 	} );
 
+	it( 'should generate proposed path for site name', async () => {
+		mockGenerateProposedSitePath.mockResolvedValue( {
+			path: '/studio/my-site',
+			isEmpty: true,
+			isWordPress: false,
+		} );
+
+		const { result } = renderHookWithProvider( () => useAddSite() );
+
+		let pathResult;
+		await act( async () => {
+			pathResult = await result.current.generateProposedPath( 'My Site' );
+		} );
+
+		expect( mockGenerateProposedSitePath ).toHaveBeenCalledWith( 'My Site' );
+		expect( pathResult ).toEqual( {
+			path: '/studio/my-site',
+			isEmpty: true,
+			isWordPress: false,
+		} );
+	} );
+
 	it( 'should connect and start pulling when a remote site is selected', async () => {
 		const remoteSite: SyncSite = {
 			id: 123,
@@ -228,11 +243,20 @@ describe( 'useAddSite', () => {
 
 		act( () => {
 			result.current.setSelectedRemoteSite( remoteSite );
-			result.current.setSitePath( createdSite.path );
 		} );
 
+		const formValues: CreateSiteFormValues = {
+			siteName: createdSite.name,
+			sitePath: createdSite.path,
+			phpVersion: '8.3',
+			wpVersion: 'latest',
+			useCustomDomain: false,
+			customDomain: null,
+			enableHttps: false,
+		};
+
 		await act( async () => {
-			await result.current.handleAddSiteClick();
+			await result.current.handleCreateSite( formValues );
 		} );
 
 		expect( mockConnectWpcomSites ).toHaveBeenCalledWith( [
diff --git a/src/hooks/use-add-site.ts b/src/hooks/use-add-site.ts
index 53afe155e..20bec38bd 100644
--- a/src/hooks/use-add-site.ts
+++ b/src/hooks/use-add-site.ts
@@ -2,7 +2,7 @@ import * as Sentry from '@sentry/electron/renderer';
 import { useI18n } from '@wordpress/react-i18n';
 import { useCallback, useMemo, useState } from 'react';
 import { BlueprintValidationWarning } from 'common/lib/blueprint-validation';
-import { generateCustomDomainFromSiteName, getDomainNameValidationError } from 'common/lib/domains';
+import { generateCustomDomainFromSiteName } from 'common/lib/domains';
 import { useSyncSites } from 'src/hooks/sync-sites';
 import { useContentTabs } from 'src/hooks/use-content-tabs';
 import { useImportExport } from 'src/hooks/use-import-export';
@@ -20,6 +20,30 @@ import type { SyncSite } from 'src/modules/sync/types';
 import type { Blueprint } from 'src/stores/wpcom-api';
 import type { SyncOption } from 'src/types';
 
+/**
+ * Form values passed when creating a site
+ */
+export interface CreateSiteFormValues {
+	siteName: string;
+	sitePath: string;
+	phpVersion: AllowedPHPVersion;
+	wpVersion: string;
+	useCustomDomain: boolean;
+	customDomain: string | null;
+	enableHttps: boolean;
+}
+
+/**
+ * Result from path selection or site name change validation
+ */
+export interface PathValidationResult {
+	path: string;
+	name?: string;
+	isEmpty: boolean;
+	isWordPress: boolean;
+	error?: string;
+}
+
 interface UseAddSiteOptions {
 	openModal?: () => void;
 }
@@ -34,21 +58,9 @@ export function useAddSite( options: UseAddSiteOptions = {} ) {
 	const { setSelectedTab } = useContentTabs();
 	const defaultPhpVersion = useRootSelector( selectDefaultPhpVersion );
 	const defaultWordPressVersion = useRootSelector( selectDefaultWordPressVersion );
-	const [ error, setError ] = useState( '' );
-	const [ siteName, setSiteName ] = useState< string | null >( null );
-	const [ sitePath, setSitePath ] = useState( '' );
-	const [ proposedSitePath, setProposedSitePath ] = useState( '' );
-	const [ doesPathContainWordPress, setDoesPathContainWordPress ] = useState( false );
+
+	// Only keep state that's NOT part of the form
 	const [ fileForImport, setFileForImport ] = useState< File | null >( null );
-	const [ phpVersion, setPhpVersion ] = useState< AllowedPHPVersion >(
-		defaultPhpVersion as AllowedPHPVersion
-	);
-	const [ wpVersion, setWpVersion ] = useState( defaultWordPressVersion );
-	const [ useCustomDomain, setUseCustomDomain ] = useState( false );
-	const [ customDomain, setCustomDomain ] = useState< string | null >( null );
-	const [ customDomainError, setCustomDomainError ] = useState( '' );
-	const [ existingDomainNames, setExistingDomainNames ] = useState< string[] >( [] );
-	const [ enableHttps, setEnableHttps ] = useState( false );
 	const [ selectedBlueprint, setSelectedBlueprint ] = useState< Blueprint | undefined >();
 	const [ selectedRemoteSite, setSelectedRemoteSite ] = useState< SyncSite | undefined >();
 	const [ blueprintPreferredVersions, setBlueprintPreferredVersions ] = useState<
@@ -58,6 +70,7 @@ export function useAddSite( options: UseAddSiteOptions = {} ) {
 		BlueprintValidationWarning[] | undefined
 	>();
 	const [ isDeeplinkFlow, setIsDeeplinkFlow ] = useState( false );
+	const [ existingDomainNames, setExistingDomainNames ] = useState< string[] >( [] );
 
 	const isAnySiteProcessing = sites.some(
 		( site ) => site.isAddingSite || importState[ site.id ]?.isNewSite
@@ -70,32 +83,31 @@ export function useAddSite( options: UseAddSiteOptions = {} ) {
 		setBlueprintDeeplinkWarnings( undefined );
 	}, [] );
 
+	// For blueprint deeplinks - we need temporary state for PHP/WP versions
+	const [ deeplinkPhpVersion, setDeeplinkPhpVersion ] = useState< AllowedPHPVersion >(
+		defaultPhpVersion as AllowedPHPVersion
+	);
+	const [ deeplinkWpVersion, setDeeplinkWpVersion ] = useState( defaultWordPressVersion );
+
 	useBlueprintDeeplink( {
 		isAnySiteProcessing,
 		openModal,
 		setSelectedBlueprint,
-		setPhpVersion,
-		setWpVersion,
+		setPhpVersion: setDeeplinkPhpVersion,
+		setWpVersion: setDeeplinkWpVersion,
 		setBlueprintPreferredVersions,
 		setBlueprintDeeplinkWarnings,
 		navigateToBlueprintDeeplink: () => setIsDeeplinkFlow( true ),
 	} );
 
 	const resetForm = useCallback( () => {
-		setSitePath( '' );
-		setError( '' );
-		setDoesPathContainWordPress( false );
-		setWpVersion( defaultWordPressVersion );
-		setPhpVersion( defaultPhpVersion );
-		setUseCustomDomain( false );
-		setCustomDomain( null );
-		setCustomDomainError( '' );
-		setEnableHttps( false );
 		setFileForImport( null );
 		setSelectedBlueprint( undefined );
 		setBlueprintPreferredVersions( undefined );
 		setBlueprintDeeplinkWarnings( undefined );
 		setSelectedRemoteSite( undefined );
+		setDeeplinkPhpVersion( defaultPhpVersion as AllowedPHPVersion );
+		setDeeplinkWpVersion( defaultWordPressVersion );
 		clearDeeplinkState();
 	}, [ clearDeeplinkState, defaultPhpVersion, defaultWordPressVersion ] );
 
@@ -110,8 +122,11 @@ export function useAddSite( options: UseAddSiteOptions = {} ) {
 			} );
 	}, [] );
 
-	const siteWithPathAlreadyExists = useCallback(
-		async ( path: string ) => {
+	/**
+	 * Check if a path is already associated with an existing site
+	 */
+	const checkPathExists = useCallback(
+		async ( path: string ): Promise< boolean > => {
 			const results = await Promise.all(
 				sites.map( ( site ) => getIpcApi().comparePaths( site.path, path ) )
 			);
@@ -120,232 +135,227 @@ export function useAddSite( options: UseAddSiteOptions = {} ) {
 		[ sites ]
 	);
 
-	const handleCustomDomainChange = useCallback(
-		( value: string | null ) => {
-			setCustomDomain( value );
-			setCustomDomainError(
-				getDomainNameValidationError( useCustomDomain, value, existingDomainNames )
+	/**
+	 * Open folder picker and validate the selected path
+	 * Returns the result for the form to use
+	 */
+	const selectPath = useCallback(
+		async ( currentPath: string ): Promise< PathValidationResult | null > => {
+			const response = await getIpcApi().showOpenFolderDialog(
+				__( 'Choose folder for site' ),
+				currentPath
 			);
-		},
-		[ useCustomDomain, setCustomDomain, setCustomDomainError, existingDomainNames ]
-	);
 
-	const handlePathSelectorClick = useCallback( async () => {
-		const response = await getIpcApi().showOpenFolderDialog(
-			__( 'Choose folder for site' ),
-			sitePath
-		);
-		if ( response?.path ) {
+			if ( ! response?.path ) {
+				return null;
+			}
+
 			const { path, name, isEmpty, isWordPress } = response;
-			setDoesPathContainWordPress( false );
-			setError( '' );
-			const pathResetToDefaultSitePath =
-				path === proposedSitePath.substring( 0, proposedSitePath.lastIndexOf( '/' ) );
-
-			setSitePath( pathResetToDefaultSitePath ? '' : path );
-			if ( await siteWithPathAlreadyExists( path ) ) {
-				setError(
-					__(
+
+			if ( await checkPathExists( path ) ) {
+				return {
+					path,
+					name: name ?? undefined,
+					isEmpty,
+					isWordPress,
+					error: __(
 						'The directory is already associated with another Studio site. Please choose a different custom local path.'
-					)
-				);
-				return;
+					),
+				};
 			}
-			if ( ! isEmpty && ! isWordPress && ! pathResetToDefaultSitePath ) {
-				setError(
-					__(
+
+			if ( ! isEmpty && ! isWordPress ) {
+				return {
+					path,
+					name: name ?? undefined,
+					isEmpty,
+					isWordPress,
+					error: __(
 						'This directory is not empty. Please select an empty directory or an existing WordPress folder.'
-					)
-				);
-				return;
+					),
+				};
 			}
-			setDoesPathContainWordPress( ! isEmpty && isWordPress );
-			if ( ! siteName ) {
-				setSiteName( name ?? null );
+
+			return {
+				path,
+				name: name ?? undefined,
+				isEmpty,
+				isWordPress,
+			};
+		},
+		[ __, checkPathExists ]
+	);
+
+	/**
+	 * Generate a proposed path for a site name and validate it
+	 */
+	const generateProposedPath = useCallback(
+		async ( siteName: string ): Promise< PathValidationResult > => {
+			const { path, isEmpty, isWordPress } = await getIpcApi().generateProposedSitePath( siteName );
+
+			if ( await checkPathExists( path ) ) {
+				return {
+					path,
+					isEmpty,
+					isWordPress,
+					error: __(
+						'The directory is already associated with another Studio site. Please choose a different site name or a custom local path.'
+					),
+				};
 			}
-		}
-	}, [ __, siteWithPathAlreadyExists, siteName, proposedSitePath, sitePath ] );
-
-	const handleAddSiteClick = useCallback( async () => {
-		try {
-			const path = sitePath ? sitePath : proposedSitePath;
-			let usedCustomDomain = useCustomDomain && customDomain ? customDomain : undefined;
-			if ( useCustomDomain && ! customDomain ) {
-				usedCustomDomain = generateCustomDomainFromSiteName( siteName ?? '' );
+
+			if ( ! isEmpty && ! isWordPress ) {
+				return {
+					path,
+					isEmpty,
+					isWordPress,
+					error: __(
+						'This directory is not empty. Please select an empty directory or an existing WordPress folder.'
+					),
+				};
 			}
-			await createSite(
-				path,
-				siteName ?? '',
-				wpVersion,
-				usedCustomDomain,
-				useCustomDomain ? enableHttps : false,
-				selectedBlueprint,
-				phpVersion,
-				async ( newSite ) => {
-					if ( fileForImport ) {
-						await importFile( fileForImport, newSite, {
-							showImportNotification: false,
-							isNewSite: true,
-						} );
-						clearImportState( newSite.id );
-
-						getIpcApi().showNotification( {
-							title: newSite.name,
-							body: __( 'Your new site was imported' ),
-						} );
-					} else {
-						if ( selectedRemoteSite ) {
-							await connectSite( { site: selectedRemoteSite, localSiteId: newSite.id } );
-							const pullOptions: SyncOption[] = [ 'all' ];
-							pullSite( selectedRemoteSite, newSite, {
-								optionsToSync: pullOptions,
+
+			return { path, isEmpty, isWordPress };
+		},
+		[ __, checkPathExists ]
+	);
+
+	/**
+	 * Create a new site with the given form values
+	 */
+	const handleCreateSite = useCallback(
+		async ( formValues: CreateSiteFormValues ) => {
+			try {
+				let usedCustomDomain =
+					formValues.useCustomDomain && formValues.customDomain
+						? formValues.customDomain
+						: undefined;
+				if ( formValues.useCustomDomain && ! formValues.customDomain ) {
+					usedCustomDomain = generateCustomDomainFromSiteName( formValues.siteName );
+				}
+
+				await createSite(
+					formValues.sitePath,
+					formValues.siteName,
+					formValues.wpVersion,
+					usedCustomDomain,
+					formValues.useCustomDomain ? formValues.enableHttps : false,
+					selectedBlueprint,
+					formValues.phpVersion,
+					async ( newSite ) => {
+						if ( fileForImport ) {
+							await importFile( fileForImport, newSite, {
+								showImportNotification: false,
+								isNewSite: true,
 							} );
-							setSelectedTab( 'sync' );
-						} else {
-							await startServer( newSite.id );
+							clearImportState( newSite.id );
 
 							getIpcApi().showNotification( {
 								title: newSite.name,
-								body: __( 'Your new site was created' ),
+								body: __( 'Your new site was imported' ),
 							} );
+						} else {
+							if ( selectedRemoteSite ) {
+								await connectSite( { site: selectedRemoteSite, localSiteId: newSite.id } );
+								const pullOptions: SyncOption[] = [ 'all' ];
+								pullSite( selectedRemoteSite, newSite, {
+									optionsToSync: pullOptions,
+								} );
+								setSelectedTab( 'sync' );
+							} else {
+								await startServer( newSite.id );
+
+								getIpcApi().showNotification( {
+									title: newSite.name,
+									body: __( 'Your new site was created' ),
+								} );
+							}
 						}
 					}
-				}
-			);
-		} catch ( e ) {
-			Sentry.captureException( e );
-		}
-	}, [
-		__,
-		clearImportState,
-		createSite,
-		fileForImport,
-		importFile,
-		proposedSitePath,
-		siteName,
-		sitePath,
-		startServer,
-		wpVersion,
-		phpVersion,
-		customDomain,
-		useCustomDomain,
-		enableHttps,
-		selectedBlueprint,
-		selectedRemoteSite,
-		pullSite,
-		connectSite,
-		setSelectedTab,
-	] );
-
-	const handleSiteNameChange = useCallback(
-		async ( name: string ) => {
-			setSiteName( name );
-			if ( sitePath ) {
-				return;
-			}
-			setError( '' );
-			const {
-				path: proposedPath,
-				isEmpty,
-				isWordPress,
-			} = await getIpcApi().generateProposedSitePath( name );
-			setProposedSitePath( proposedPath );
-
-			if ( await siteWithPathAlreadyExists( proposedPath ) ) {
-				setError(
-					__(
-						'The directory is already associated with another Studio site. Please choose a different site name or a custom local path.'
-					)
 				);
-				return;
+			} catch ( e ) {
+				Sentry.captureException( e );
 			}
-			if ( ! isEmpty && ! isWordPress ) {
-				setError(
-					__(
-						'This directory is not empty. Please select an empty directory or an existing WordPress folder.'
-					)
-				);
-				return;
-			}
-			setDoesPathContainWordPress( ! isEmpty && isWordPress );
 		},
-		[ __, sitePath, siteWithPathAlreadyExists ]
+		[
+			__,
+			clearImportState,
+			createSite,
+			fileForImport,
+			importFile,
+			startServer,
+			selectedBlueprint,
+			selectedRemoteSite,
+			pullSite,
+			connectSite,
+			setSelectedTab,
+		]
 	);
 
-	return useMemo( () => {
-		return {
-			resetForm,
-			handleAddSiteClick,
-			handlePathSelectorClick,
-			handleSiteNameChange,
-			error,
-			sitePath: sitePath ? sitePath : proposedSitePath,
-			siteName,
-			doesPathContainWordPress,
-			setSiteName,
-			proposedSitePath,
-			setProposedSitePath,
-			setSitePath,
-			setError,
-			setDoesPathContainWordPress,
+	return useMemo(
+		() => ( {
+			// Site creation
+			handleCreateSite,
+
+			// Path helpers (for form to use)
+			selectPath,
+			generateProposedPath,
+
+			// Default values (for form initialization)
+			defaultPhpVersion: defaultPhpVersion as AllowedPHPVersion,
+			defaultWpVersion: defaultWordPressVersion,
+
+			// Blueprint deeplink values (set by deeplink handler)
+			deeplinkPhpVersion,
+			deeplinkWpVersion,
+
+			// Import file
 			fileForImport,
 			setFileForImport,
-			phpVersion,
-			setPhpVersion,
-			wpVersion,
-			setWpVersion,
-			useCustomDomain,
-			setUseCustomDomain,
-			customDomain,
-			setCustomDomain: handleCustomDomainChange,
-			customDomainError,
-			setCustomDomainError,
-			enableHttps,
-			setEnableHttps,
-			loadAllCustomDomains,
+
+			// Blueprint selection
 			selectedBlueprint,
 			setSelectedBlueprint,
-			selectedRemoteSite,
-			setSelectedRemoteSite,
 			blueprintPreferredVersions,
 			setBlueprintPreferredVersions,
 			blueprintDeeplinkWarnings,
-			setBlueprintDeeplinkWarnings,
+
+			// Remote site selection
+			selectedRemoteSite,
+			setSelectedRemoteSite,
+
+			// Custom domain helpers
+			existingDomainNames,
+			loadAllCustomDomains,
+
+			// Flow state
 			isDeeplinkFlow,
 			setIsDeeplinkFlow,
 			isAnySiteProcessing,
+
+			// Reset
+			resetForm,
 			clearDeeplinkState,
-		};
-	}, [
-		resetForm,
-		doesPathContainWordPress,
-		error,
-		handleAddSiteClick,
-		handlePathSelectorClick,
-		handleSiteNameChange,
-		siteName,
-		sitePath,
-		proposedSitePath,
-		fileForImport,
-		phpVersion,
-		wpVersion,
-		useCustomDomain,
-		setUseCustomDomain,
-		customDomain,
-		handleCustomDomainChange,
-		customDomainError,
-		setCustomDomainError,
-		enableHttps,
-		setEnableHttps,
-		loadAllCustomDomains,
-		selectedBlueprint,
-		setSelectedBlueprint,
-		selectedRemoteSite,
-		setSelectedRemoteSite,
-		blueprintPreferredVersions,
-		blueprintDeeplinkWarnings,
-		isDeeplinkFlow,
-		isAnySiteProcessing,
-		clearDeeplinkState,
-	] );
+		} ),
+		[
+			handleCreateSite,
+			selectPath,
+			generateProposedPath,
+			defaultPhpVersion,
+			defaultWordPressVersion,
+			deeplinkPhpVersion,
+			deeplinkWpVersion,
+			fileForImport,
+			selectedBlueprint,
+			blueprintPreferredVersions,
+			blueprintDeeplinkWarnings,
+			selectedRemoteSite,
+			existingDomainNames,
+			loadAllCustomDomains,
+			isDeeplinkFlow,
+			isAnySiteProcessing,
+			resetForm,
+			clearDeeplinkState,
+		]
+	);
 }
diff --git a/src/modules/add-site/components/create-site-form.tsx b/src/modules/add-site/components/create-site-form.tsx
index 51d9b0824..1a7b50d3b 100644
--- a/src/modules/add-site/components/create-site-form.tsx
+++ b/src/modules/add-site/components/create-site-form.tsx
@@ -3,8 +3,8 @@ import { createInterpolateElement } from '@wordpress/element';
 import { __, sprintf, _n } from '@wordpress/i18n';
 import { tip, cautionFilled, chevronRight, chevronDown, chevronLeft } from '@wordpress/icons';
 import { useI18n } from '@wordpress/react-i18n';
-import { FormEvent, useState, useEffect } from 'react';
-import { generateCustomDomainFromSiteName } from 'common/lib/domains';
+import { FormEvent, useState, useEffect, useCallback, useMemo, RefObject } from 'react';
+import { generateCustomDomainFromSiteName, getDomainNameValidationError } from 'common/lib/domains';
 import Button from 'src/components/button';
 import FolderIcon from 'src/components/folder-icon';
 import TextControlComponent from 'src/components/text-control';
@@ -20,6 +20,46 @@ import {
 	selectAllowedPhpVersions,
 } from 'src/stores/provider-constants-slice';
 
+export interface CreateSiteFormValues {
+	siteName: string;
+	sitePath: string;
+	phpVersion: AllowedPHPVersion;
+	wpVersion: string;
+	useCustomDomain: boolean;
+	customDomain: string | null;
+	enableHttps: boolean;
+}
+
+export interface PathValidationResult {
+	path: string;
+	name?: string;
+	isEmpty: boolean;
+	isWordPress: boolean;
+	error?: string;
+}
+
+export interface CreateSiteFormProps {
+	/** Default values for form initialization (only used once on mount) */
+	defaultValues?: {
+		siteName?: string;
+		sitePath?: string;
+		phpVersion?: AllowedPHPVersion;
+		wpVersion?: string;
+	};
+	/** Callback to select a path via folder picker. Returns validation result. */
+	onSelectPath?: ( currentPath: string ) => Promise< PathValidationResult | null >;
+	/** Callback when site name changes to generate proposed path. Returns validation result. */
+	onSiteNameChange?: ( name: string ) => Promise< PathValidationResult >;
+	/** Existing domain names for validation */
+	existingDomainNames?: string[];
+	/** Blueprint preferred versions for warning display */
+	blueprintPreferredVersions?: { php?: string; wp?: string };
+	/** Called when form is submitted with all form values */
+	onSubmit: ( values: CreateSiteFormValues ) => void;
+	/** Optional ref to the form element for programmatic submission */
+	formRef?: RefObject< HTMLFormElement >;
+}
+
 interface FormPathInputComponentProps {
 	value: string;
 	onClick: () => void;
@@ -34,30 +74,6 @@ interface SiteFormErrorProps {
 	className?: string;
 }
 
-interface SiteFormProps {
-	siteName: string;
-	setSiteName: ( name: string ) => void;
-	sitePath?: string;
-	onSelectPath?: () => void;
-	error: string;
-	doesPathContainWordPress?: boolean;
-	onSubmit: ( event: FormEvent ) => void;
-	useCustomDomain?: boolean;
-	setUseCustomDomain?: ( use: boolean ) => void;
-	customDomain?: string | null;
-	setCustomDomain?: ( domain: string ) => void;
-	customDomainError?: string;
-	phpVersion: AllowedPHPVersion;
-	setPhpVersion: ( version: AllowedPHPVersion ) => void;
-	useHttps?: boolean;
-	setUseHttps?: ( use: boolean ) => void;
-	enableHttps?: boolean;
-	setEnableHttps?: ( use: boolean ) => void;
-	wpVersion: string;
-	setWpVersion: ( version: string ) => void;
-	blueprintPreferredVersions?: { php?: string; wp?: string };
-}
-
 const SiteFormError = ( { error, tipMessage = '', className = '' }: SiteFormErrorProps ) => {
 	return (
 		( error || tipMessage ) && (
@@ -82,6 +98,7 @@ const SiteFormError = ( { error, tipMessage = '', className = '' }: SiteFormErro
 		)
 	);
 };
+
 function FormPathInputComponent( {
 	value,
 	onClick,
@@ -94,14 +111,6 @@ function FormPathInputComponent( {
 		<div className="flex flex-col gap-2">
 			<button
 				aria-invalid={ !! error }
-				/**
-				 * The below `aria-describedby` presumes the error message always
-				 * relates to the local path input, which is true currently as it is the
-				 * only data validation in place. If we ever introduce additional data
-				 * validation we need to expand the robustness of this
-				 * `aria-describedby` attribute so that it only targets relevant error
-				 * messages.
-				 */
 				aria-describedby={ error ? 'site-path-error' : undefined }
 				type="button"
 				aria-label={ `${ value }, ${ __( 'Select different local path' ) }` }
@@ -139,50 +148,153 @@ function FormPathInputComponent( {
 }
 
 export const CreateSiteForm = ( {
-	siteName,
-	setSiteName,
-	phpVersion,
-	setPhpVersion,
-	wpVersion,
-	setWpVersion,
-	sitePath = '',
+	defaultValues = {},
 	onSelectPath,
-	error,
-	onSubmit,
-	doesPathContainWordPress = false,
-	useCustomDomain,
-	setUseCustomDomain,
-	customDomain = null,
-	setCustomDomain,
-	customDomainError,
-	enableHttps,
-	setEnableHttps,
+	onSiteNameChange,
+	existingDomainNames = [],
 	blueprintPreferredVersions,
-}: SiteFormProps ) => {
+	onSubmit,
+	formRef,
+}: CreateSiteFormProps ) => {
 	const { __, isRTL } = useI18n();
 	const locale = useI18nLocale();
 	const { data: isCertificateTrusted } = useCheckCertificateTrustQuery();
 	const defaultWordPressVersion = useRootSelector( selectDefaultWordPressVersion );
 	const allowedPhpVersions = useRootSelector( selectAllowedPhpVersions );
 
+	const [ siteName, setSiteName ] = useState( defaultValues.siteName ?? '' );
+	const [ sitePath, setSitePath ] = useState( defaultValues.sitePath ?? '' );
+	const [ phpVersion, setPhpVersion ] = useState< AllowedPHPVersion >(
+		defaultValues.phpVersion ?? ( allowedPhpVersions[ 0 ] as AllowedPHPVersion ) ?? '8.2'
+	);
+	const [ wpVersion, setWpVersion ] = useState(
+		defaultValues.wpVersion ?? defaultWordPressVersion
+	);
+	const [ useCustomDomain, setUseCustomDomain ] = useState( false );
+	const [ customDomain, setCustomDomain ] = useState< string | null >( null );
+	const [ enableHttps, setEnableHttps ] = useState( false );
+
+	const [ pathError, setPathError ] = useState( '' );
+	const [ doesPathContainWordPress, setDoesPathContainWordPress ] = useState( false );
+	const [ customDomainError, setCustomDomainError ] = useState( '' );
+	// Track if user has manually selected a path via folder picker
+	const [ hasCustomPath, setHasCustomPath ] = useState( false );
+
+	const [ isAdvancedSettingsVisible, setAdvancedSettingsVisible ] = useState( false );
+
+	// Sync form state with defaultValues when they change
+	// This handles cases where defaultValues are updated after initial mount
+	// (e.g., blueprint preferred versions loading after form mount)
+	useEffect( () => {
+		if ( defaultValues.siteName !== undefined ) {
+			setSiteName( defaultValues.siteName );
+		}
+	}, [ defaultValues.siteName ] );
+
+	useEffect( () => {
+		if ( defaultValues.sitePath !== undefined ) {
+			setSitePath( defaultValues.sitePath );
+		}
+	}, [ defaultValues.sitePath ] );
+
+	useEffect( () => {
+		if ( defaultValues.phpVersion !== undefined ) {
+			setPhpVersion( defaultValues.phpVersion );
+		}
+	}, [ defaultValues.phpVersion ] );
+
+	useEffect( () => {
+		if ( defaultValues.wpVersion !== undefined ) {
+			setWpVersion( defaultValues.wpVersion );
+		}
+	}, [ defaultValues.wpVersion ] );
+
 	// If the custom domain is enabled and the root certificate is trusted, enable HTTPS
 	useEffect( () => {
-		if ( useCustomDomain && isCertificateTrusted && setEnableHttps ) {
+		if ( useCustomDomain && isCertificateTrusted ) {
 			setEnableHttps( true );
 		}
-	}, [ useCustomDomain, isCertificateTrusted, setEnableHttps ] );
+	}, [ useCustomDomain, isCertificateTrusted ] );
 
-	const shouldShowCustomDomainError = useCustomDomain && customDomainError;
-	const errorCount = [ error, shouldShowCustomDomainError ].filter( Boolean ).length;
+	const handleSiteNameChange = useCallback(
+		async ( name: string ) => {
+			setSiteName( name );
 
-	const [ isAdvancedSettingsVisible, setAdvancedSettingsVisible ] = useState( false );
+			// Only generate path if user hasn't manually selected a custom path
+			if ( onSiteNameChange && ! hasCustomPath ) {
+				const result = await onSiteNameChange( name );
+				if ( result.error ) {
+					setPathError( result.error );
+				} else {
+					setPathError( '' );
+				}
+				setDoesPathContainWordPress( ! result.isEmpty && result.isWordPress );
+				setSitePath( result.path );
+			}
+		},
+		[ onSiteNameChange, hasCustomPath ]
+	);
+
+	const handleSelectPath = useCallback( async () => {
+		if ( ! onSelectPath ) return;
+
+		const result = await onSelectPath( sitePath );
+		if ( ! result ) return;
+
+		// Mark that user has manually selected a path
+		setHasCustomPath( true );
+		setSitePath( result.path );
+		if ( result.error ) {
+			setPathError( result.error );
+		} else {
+			setPathError( '' );
+		}
+		setDoesPathContainWordPress( ! result.isEmpty && result.isWordPress );
+
+		if ( result.name && ! siteName ) {
+			setSiteName( result.name );
+		}
+	}, [ onSelectPath, sitePath, siteName ] );
+
+	const handleCustomDomainChange = useCallback(
+		( value: string ) => {
+			setCustomDomain( value );
+			setCustomDomainError(
+				getDomainNameValidationError( useCustomDomain, value, existingDomainNames )
+			);
+		},
+		[ useCustomDomain, existingDomainNames ]
+	);
+
+	const formValues = useMemo< CreateSiteFormValues >(
+		() => ( {
+			siteName,
+			sitePath,
+			phpVersion,
+			wpVersion,
+			useCustomDomain,
+			customDomain,
+			enableHttps,
+		} ),
+		[ siteName, sitePath, phpVersion, wpVersion, useCustomDomain, customDomain, enableHttps ]
+	);
+
+	const handleFormSubmit = useCallback(
+		( event: FormEvent ) => {
+			event.preventDefault();
+			onSubmit( formValues );
+		},
+		[ onSubmit, formValues ]
+	);
+
+	const shouldShowCustomDomainError = useCustomDomain && customDomainError;
+	const errorCount = [ pathError, shouldShowCustomDomainError ].filter( Boolean ).length;
 
 	const handleAdvancedSettingsClick = () => {
 		setAdvancedSettingsVisible( ! isAdvancedSettingsVisible );
 	};
 
 	let chevronIcon;
-
 	if ( isAdvancedSettingsVisible ) {
 		chevronIcon = chevronDown;
 	} else if ( isRTL() ) {
@@ -190,6 +302,7 @@ export const CreateSiteForm = ( {
 	} else {
 		chevronIcon = chevronRight;
 	}
+
 	const generatedDomainName = generateCustomDomainFromSiteName( siteName );
 
 	// Check if current versions differ from blueprint recommendations
@@ -198,24 +311,27 @@ export const CreateSiteForm = ( {
 		( ( blueprintPreferredVersions.php && blueprintPreferredVersions.php !== phpVersion ) ||
 			( blueprintPreferredVersions.wp && blueprintPreferredVersions.wp !== wpVersion ) );
 
+	const showAdvancedSettings = onSelectPath !== undefined;
+
 	return (
-		<form onSubmit={ onSubmit }>
+		<form ref={ formRef } onSubmit={ handleFormSubmit }>
 			<div className="flex flex-col">
 				<label className="flex flex-col gap-1.5 leading-4 mb-6">
 					<span className="font-semibold">{ __( 'Site name' ) }</span>
 					<TextControlComponent
-						onChange={ setSiteName }
+						onChange={ handleSiteNameChange }
 						value={ siteName }
 						onKeyDown={ ( event ) => {
 							if ( event.key === 'Enter' ) {
 								event.preventDefault();
-								onSubmit( event as FormEvent );
+								handleFormSubmit( event as FormEvent );
 							}
 						} }
 						data-testid="site-name-input"
-					></TextControlComponent>
+					/>
 				</label>
-				{ onSelectPath && (
+
+				{ showAdvancedSettings && (
 					<>
 						<div className="flex flex-row items-center mb-1">
 							<Button
@@ -223,8 +339,10 @@ export const CreateSiteForm = ( {
 								onClick={ handleAdvancedSettingsClick }
 								data-testid="advanced-settings-button"
 							>
-								<Icon size={ 24 } icon={ chevronIcon } className={ error && 'text-red-500' } />
-								<div className={ cx( 'text-[13px] leading-[16px] ml-2', error && 'text-red-500' ) }>
+								<Icon size={ 24 } icon={ chevronIcon } className={ pathError && 'text-red-500' } />
+								<div
+									className={ cx( 'text-[13px] leading-[16px] ml-2', pathError && 'text-red-500' ) }
+								>
 									{ __( 'Advanced settings' ) }
 								</div>
 							</Button>
@@ -269,9 +387,9 @@ export const CreateSiteForm = ( {
 								</span>
 								<FormPathInputComponent
 									doesPathContainWordPress={ doesPathContainWordPress }
-									error={ error }
+									error={ pathError }
 									value={ sitePath }
-									onClick={ onSelectPath }
+									onClick={ handleSelectPath }
 									id="local-path"
 								/>
 								<div className="grid grid-cols-2 gap-4 mt-4">
@@ -286,7 +404,7 @@ export const CreateSiteForm = ( {
 												label: version,
 												value: version,
 											} ) ) }
-											onChange={ setPhpVersion as ( value: string ) => void }
+											onChange={ ( value: string ) => setPhpVersion( value as AllowedPHPVersion ) }
 											__next40pxDefaultSize
 											__nextHasNoMarginBottom
 										/>
@@ -337,67 +455,67 @@ export const CreateSiteForm = ( {
 									</Notice>
 								) }
 
-								{ setUseCustomDomain && setCustomDomain && (
-									<div className="flex items-center gap-2 mt-4">
-										<input
-											type="checkbox"
-											id="use-custom-domain"
-											checked={ useCustomDomain }
-											onChange={ ( e ) => setUseCustomDomain( e.target.checked ) }
-										/>
-										<label htmlFor="use-custom-domain">{ __( 'Use custom domain' ) }</label>
-									</div>
-								) }
+								{ existingDomainNames.length >= 0 && (
+									<>
+										<div className="flex items-center gap-2 mt-4">
+											<input
+												type="checkbox"
+												id="use-custom-domain"
+												checked={ useCustomDomain }
+												onChange={ ( e ) => setUseCustomDomain( e.target.checked ) }
+											/>
+											<label htmlFor="use-custom-domain">{ __( 'Use custom domain' ) }</label>
+										</div>
 
-								{ setUseCustomDomain && setCustomDomain && (
-									<div className="text-a8c-gray-50 text-xs mt-2">
-										{ __( 'Your system password will be required to set up the domain.' ) }
-									</div>
+										<div className="text-a8c-gray-50 text-xs mt-2">
+											{ __( 'Your system password will be required to set up the domain.' ) }
+										</div>
+									</>
 								) }
 
-								{ useCustomDomain && setCustomDomain && (
-									<div className="flex flex-col gap-2 mt-4">
-										<label htmlFor="custom-domain" className="font-semibold">
-											{ __( 'Domain name' ) }
-										</label>
-										<TextControlComponent
-											id="custom-domain"
-											value={ customDomain !== null ? customDomain : generatedDomainName }
-											onChange={ setCustomDomain }
-										/>
-										{ customDomainError && <SiteFormError error={ customDomainError } /> }
-									</div>
-								) }
+								{ useCustomDomain && (
+									<>
+										<div className="flex flex-col gap-2 mt-4">
+											<label htmlFor="custom-domain" className="font-semibold">
+												{ __( 'Domain name' ) }
+											</label>
+											<TextControlComponent
+												id="custom-domain"
+												value={ customDomain !== null ? customDomain : generatedDomainName }
+												onChange={ handleCustomDomainChange }
+											/>
+											{ customDomainError && <SiteFormError error={ customDomainError } /> }
+										</div>
 
-								{ useCustomDomain && setEnableHttps && (
-									<div className="flex items-center gap-2 mt-4">
-										<input
-											type="checkbox"
-											id="enable-https"
-											checked={ enableHttps }
-											onChange={ ( e ) => setEnableHttps( e.target.checked ) }
-										/>
-										<label htmlFor="enable-https">{ __( 'Enable HTTPS' ) }</label>
-									</div>
-								) }
+										<div className="flex items-center gap-2 mt-4">
+											<input
+												type="checkbox"
+												id="enable-https"
+												checked={ enableHttps }
+												onChange={ ( e ) => setEnableHttps( e.target.checked ) }
+											/>
+											<label htmlFor="enable-https">{ __( 'Enable HTTPS' ) }</label>
+										</div>
 
-								{ ! isCertificateTrusted && useCustomDomain && setEnableHttps && (
-									<div className="text-a8c-gray-50 text-xs mt-2">
-										{ __(
-											'You need to manually add the Studio root certificate authority to your keychain and trust it to enable HTTPS.'
-										) }{ ' ' }
-										<Button
-											variant="link"
-											onClick={ () => {
-												getIpcApi().openURL(
-													'https://developer.wordpress.com/docs/developer-tools/studio/ssl-in-studio/'
-												);
-											} }
-										>
-											{ __( 'Learn how' ) }
-											<span aria-label={ __( '(opens in a web browser)' ) }>&#8599;</span>
-										</Button>
-									</div>
+										{ ! isCertificateTrusted && (
+											<div className="text-a8c-gray-50 text-xs mt-2">
+												{ __(
+													'You need to manually add the Studio root certificate authority to your keychain and trust it to enable HTTPS.'
+												) }{ ' ' }
+												<Button
+													variant="link"
+													onClick={ () => {
+														getIpcApi().openURL(
+															'https://developer.wordpress.com/docs/developer-tools/studio/ssl-in-studio/'
+														);
+													} }
+												>
+													{ __( 'Learn how' ) }
+													<span aria-label={ __( '(opens in a web browser)' ) }>&#8599;</span>
+												</Button>
+											</div>
+										) }
+									</>
 								) }
 							</div>
 						</div>
diff --git a/src/modules/add-site/components/create-site.tsx b/src/modules/add-site/components/create-site.tsx
index 0f57a01b6..0f65a5f5a 100644
--- a/src/modules/add-site/components/create-site.tsx
+++ b/src/modules/add-site/components/create-site.tsx
@@ -3,51 +3,37 @@ import {
 	__experimentalHeading as Heading,
 } from '@wordpress/components';
 import { useI18n } from '@wordpress/react-i18n';
-import { FormEvent } from 'react';
-import { CreateSiteForm } from 'src/modules/add-site/components/create-site-form';
+import { RefObject } from 'react';
+import { AllowedPHPVersion } from 'src/lib/wordpress-provider/constants';
+import {
+	CreateSiteForm,
+	CreateSiteFormValues,
+	PathValidationResult,
+} from 'src/modules/add-site/components/create-site-form';
 
-interface CreateSiteProps {
-	siteName: string | null;
-	handleSiteNameChange: ( name: string ) => Promise< void >;
-	phpVersion: string;
-	setPhpVersion: ( version: string ) => void;
-	wpVersion: string;
-	setWpVersion: ( version: string ) => void;
-	sitePath: string;
-	handlePathSelectorClick: () => void;
-	error: string;
-	handleSubmit: ( event: FormEvent ) => void;
-	doesPathContainWordPress: boolean;
-	useCustomDomain: boolean;
-	setUseCustomDomain: ( use: boolean ) => void;
-	customDomain: string | null;
-	setCustomDomain: ( domain: string | null ) => void;
-	customDomainError: string;
-	enableHttps: boolean;
-	setEnableHttps: ( enable: boolean ) => void;
+export interface CreateSiteProps {
+	defaultValues?: {
+		siteName?: string;
+		sitePath?: string;
+		phpVersion?: AllowedPHPVersion;
+		wpVersion?: string;
+	};
+	onSelectPath: ( currentPath: string ) => Promise< PathValidationResult | null >;
+	onSiteNameChange: ( name: string ) => Promise< PathValidationResult >;
+	existingDomainNames?: string[];
 	blueprintPreferredVersions?: { php?: string; wp?: string };
+	onSubmit: ( values: CreateSiteFormValues ) => void;
+	formRef?: RefObject< HTMLFormElement >;
 }
 
 export default function CreateSite( {
-	siteName,
-	handleSiteNameChange,
-	phpVersion,
-	setPhpVersion,
-	wpVersion,
-	setWpVersion,
-	sitePath,
-	handlePathSelectorClick,
-	error,
-	handleSubmit,
-	doesPathContainWordPress,
-	useCustomDomain,
-	setUseCustomDomain,
-	customDomain,
-	setCustomDomain,
-	customDomainError,
-	enableHttps,
-	setEnableHttps,
+	defaultValues,
+	onSelectPath,
+	onSiteNameChange,
+	existingDomainNames = [],
 	blueprintPreferredVersions,
+	onSubmit,
+	formRef,
 }: CreateSiteProps ) {
 	const { __ } = useI18n();
 
@@ -58,25 +44,13 @@ export default function CreateSite( {
 			</Heading>
 
 			<CreateSiteForm
-				siteName={ siteName || '' }
-				setSiteName={ ( name ) => void handleSiteNameChange( name ) }
-				phpVersion={ phpVersion }
-				setPhpVersion={ setPhpVersion }
-				wpVersion={ wpVersion }
-				setWpVersion={ setWpVersion }
-				sitePath={ sitePath }
-				onSelectPath={ handlePathSelectorClick }
-				error={ error }
-				onSubmit={ handleSubmit }
-				doesPathContainWordPress={ doesPathContainWordPress }
-				useCustomDomain={ useCustomDomain }
-				setUseCustomDomain={ setUseCustomDomain }
-				customDomain={ customDomain }
-				setCustomDomain={ setCustomDomain }
-				customDomainError={ customDomainError }
-				enableHttps={ enableHttps }
-				setEnableHttps={ setEnableHttps }
+				defaultValues={ defaultValues }
+				onSelectPath={ onSelectPath }
+				onSiteNameChange={ onSiteNameChange }
+				existingDomainNames={ existingDomainNames }
 				blueprintPreferredVersions={ blueprintPreferredVersions }
+				onSubmit={ onSubmit }
+				formRef={ formRef }
 			/>
 		</VStack>
 	);
diff --git a/src/modules/add-site/components/index.ts b/src/modules/add-site/components/index.ts
new file mode 100644
index 000000000..283bc4a6c
--- /dev/null
+++ b/src/modules/add-site/components/index.ts
@@ -0,0 +1,8 @@
+export { CreateSiteForm } from './create-site-form';
+export type {
+	CreateSiteFormValues,
+	CreateSiteFormProps,
+	PathValidationResult,
+} from './create-site-form';
+export { default as CreateSite } from './create-site';
+export type { CreateSiteProps } from './create-site';
diff --git a/src/modules/add-site/components/stepper.tsx b/src/modules/add-site/components/stepper.tsx
index cd1260ee7..39bd50b33 100644
--- a/src/modules/add-site/components/stepper.tsx
+++ b/src/modules/add-site/components/stepper.tsx
@@ -99,6 +99,7 @@ export default function Stepper( {
 				{ actionButton?.isVisible && onSubmit && (
 					<Button
 						variant="primary"
+						type="button"
 						onClick={ onSubmit }
 						disabled={ ! canSubmit }
 						data-testid="stepper-action-button"
diff --git a/src/modules/add-site/index.tsx b/src/modules/add-site/index.tsx
index 9d13b582b..6538fb14f 100644
--- a/src/modules/add-site/index.tsx
+++ b/src/modules/add-site/index.tsx
@@ -2,15 +2,15 @@ import { speak } from '@wordpress/a11y';
 import { Navigator, useNavigator } from '@wordpress/components';
 import { sprintf } from '@wordpress/i18n';
 import { useI18n } from '@wordpress/react-i18n';
-import { FormEvent, useCallback, useEffect, useMemo, useState } from 'react';
-import { BlueprintValidationWarning } from 'common/lib/blueprint-validation';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import Button from 'src/components/button';
 import { FullscreenModal } from 'src/components/fullscreen-modal';
-import { useAddSite } from 'src/hooks/use-add-site';
+import { useAddSite, CreateSiteFormValues } from 'src/hooks/use-add-site';
 import { useIpcListener } from 'src/hooks/use-ipc-listener';
 import { useSiteDetails } from 'src/hooks/use-site-details';
 import { generateSiteName } from 'src/lib/generate-site-name';
 import { getIpcApi } from 'src/lib/get-ipc-api';
+import { AllowedPHPVersion } from 'src/lib/wordpress-provider/constants';
 import { SyncSite } from 'src/modules/sync/types';
 import { useRootSelector } from 'src/stores';
 import { formatRtkError } from 'src/stores/format-rtk-error';
@@ -31,32 +31,36 @@ type BlueprintsData = ReturnType< typeof useGetBlueprints >[ 'data' ];
 interface NavigationContentProps {
 	blueprintsData: BlueprintsData;
 	isLoadingBlueprints: boolean;
-	siteName: string | null;
-	handleSiteNameChange: ( name: string ) => Promise< void >;
-	phpVersion: string;
-	setPhpVersion: ( version: string ) => void;
-	wpVersion: string;
-	setWpVersion: ( version: string ) => void;
-	sitePath: string;
-	handlePathSelectorClick: () => void;
-	error: string;
-	handleSubmit: ( event: FormEvent ) => void;
-	doesPathContainWordPress: boolean;
-	useCustomDomain: boolean;
-	setUseCustomDomain: ( use: boolean ) => void;
-	customDomain: string | null;
-	setCustomDomain: ( domain: string | null ) => void;
-	customDomainError: string;
-	enableHttps: boolean;
-	setEnableHttps: ( enable: boolean ) => void;
+	blueprintsErrorMessage?: string;
+	defaultValues: {
+		siteName: string;
+		sitePath: string;
+		phpVersion: AllowedPHPVersion;
+		wpVersion: string;
+	};
+	onSelectPath: ( currentPath: string ) => Promise< {
+		path: string;
+		name?: string;
+		isEmpty: boolean;
+		isWordPress: boolean;
+		error?: string;
+	} | null >;
+	onSiteNameChange: ( name: string ) => Promise< {
+		path: string;
+		isEmpty: boolean;
+		isWordPress: boolean;
+		error?: string;
+	} >;
+	existingDomainNames: string[];
+	onFormSubmit: ( values: CreateSiteFormValues ) => void;
+	canSubmit: boolean;
 	fileForImport: File | null;
 	setFileForImport: ( file: File | null ) => void;
 	setSelectedBlueprint: ( blueprint?: Blueprint ) => void;
 	selectedBlueprint?: Blueprint;
-	blueprintsErrorMessage?: string | undefined;
 	blueprintPreferredVersions?: { php?: string; wp?: string };
 	setBlueprintPreferredVersions?: ( versions: { php?: string; wp?: string } | undefined ) => void;
-	blueprintDeeplinkWarnings?: BlueprintValidationWarning[];
+	blueprintDeeplinkWarnings?: import('common/lib/blueprint-validation').BlueprintValidationWarning[];
 	selectedRemoteSite?: SyncSite;
 	setSelectedRemoteSite: ( site?: SyncSite ) => void;
 	isDeeplinkFlow: boolean;
@@ -70,6 +74,16 @@ function NavigationContent( props: NavigationContentProps ) {
 		blueprintsData,
 		isLoadingBlueprints,
 		blueprintsErrorMessage,
+		defaultValues,
+		onSelectPath,
+		onSiteNameChange,
+		existingDomainNames,
+		onFormSubmit,
+		canSubmit,
+		fileForImport,
+		setFileForImport,
+		selectedBlueprint,
+		setSelectedBlueprint,
 		blueprintPreferredVersions,
 		setBlueprintPreferredVersions,
 		blueprintDeeplinkWarnings,
@@ -77,11 +91,8 @@ function NavigationContent( props: NavigationContentProps ) {
 		setSelectedRemoteSite,
 		isDeeplinkFlow,
 		setIsDeeplinkFlow,
-		...createSiteProps
 	} = props;
 
-	const { selectedBlueprint, setSelectedBlueprint, setPhpVersion, setWpVersion } = createSiteProps;
-
 	useEffect( () => {
 		if ( isDeeplinkFlow && selectedBlueprint ) {
 			goTo( '/blueprint/deeplink' );
@@ -112,43 +123,33 @@ function NavigationContent( props: NavigationContentProps ) {
 
 	const handleBackupFileSelect = useCallback(
 		( file?: File ) => {
-			createSiteProps.setFileForImport( file || null );
+			setFileForImport( file || null );
 		},
-		[ createSiteProps ]
+		[ setFileForImport ]
 	);
 
 	const handleBackupContinue = useCallback( () => {
-		if ( createSiteProps.fileForImport ) {
+		if ( fileForImport ) {
 			goTo( '/backup/create' );
 		}
-	}, [ createSiteProps, goTo ] );
+	}, [ fileForImport, goTo ] );
 
 	const findAvailableSiteName = useFindAvailableSiteName();
+	const [ remoteSiteName, setRemoteSiteName ] = useState( '' );
+
 	const handlePullRemoteContinue = useCallback( async () => {
 		if ( selectedRemoteSite ) {
 			const availableName = await findAvailableSiteName( selectedRemoteSite.name );
-			await createSiteProps.handleSiteNameChange( availableName );
+			setRemoteSiteName( availableName );
 			goTo( '/pullRemote/create' );
 		}
-	}, [ createSiteProps, findAvailableSiteName, goTo, selectedRemoteSite ] );
+	}, [ findAvailableSiteName, goTo, selectedRemoteSite ] );
 
 	const blueprints = useMemo(
 		() => blueprintsData?.blueprints.slice().reverse() || [],
 		[ blueprintsData ]
 	);
 
-	const isOnCreatePath =
-		location.path === '/create' ||
-		location.path === '/blueprint/select/create' ||
-		location.path === '/blueprint/deeplink/create' ||
-		location.path === '/backup/create' ||
-		location.path === '/pullRemote/create';
-	const canSubmit =
-		isOnCreatePath &&
-		createSiteProps.siteName?.trim() &&
-		! createSiteProps.error &&
-		( ! createSiteProps.useCustomDomain || ! createSiteProps.customDomainError );
-
 	const handleBlueprintDeeplinkContinue = useCallback( () => {
 		goTo( '/blueprint/deeplink/create' );
 	}, [ goTo ] );
@@ -161,6 +162,7 @@ function NavigationContent( props: NavigationContentProps ) {
 		} else if ( location.path === '/backup/create' ) {
 			goTo( '/backup' );
 		} else if ( location.path === '/pullRemote/create' ) {
+			setRemoteSiteName( '' );
 			goTo( '/pullRemote' );
 		} else if (
 			location.path === '/backup' ||
@@ -170,14 +172,15 @@ function NavigationContent( props: NavigationContentProps ) {
 			location.path === '/pullRemote'
 		) {
 			if ( location.path === '/backup' ) {
-				createSiteProps.setFileForImport( null );
+				setFileForImport( null );
 			}
 			if ( location.path === '/blueprint/select' || location.path === '/blueprint/deeplink' ) {
-				createSiteProps.setSelectedBlueprint();
+				setSelectedBlueprint();
 				setBlueprintPreferredVersions?.( undefined );
 			}
 			if ( location.path === '/pullRemote' ) {
 				setSelectedRemoteSite( undefined );
+				setRemoteSiteName( '' );
 			}
 			goTo( '/' );
 		} else {
@@ -186,53 +189,67 @@ function NavigationContent( props: NavigationContentProps ) {
 	}, [
 		location.path,
 		goTo,
-		createSiteProps,
+		setFileForImport,
+		setSelectedBlueprint,
 		setBlueprintPreferredVersions,
 		setSelectedRemoteSite,
 	] );
 
-	const applyBlueprintVersions = useCallback(
-		( blueprint?: Blueprint ) => {
-			if ( blueprint?.blueprint?.preferredVersions ) {
-				const preferredVersions = blueprint.blueprint.preferredVersions as {
-					php?: string;
-					wp?: string;
-				};
-				setBlueprintPreferredVersions?.( preferredVersions );
-
-				// Apply the preferred versions to the form
-				if ( preferredVersions.php && preferredVersions.php !== 'latest' ) {
-					setPhpVersion( preferredVersions.php );
-				}
-				if ( preferredVersions.wp && preferredVersions.wp !== 'latest' ) {
-					setWpVersion( preferredVersions.wp );
-				}
-			} else {
-				setBlueprintPreferredVersions?.( undefined );
-			}
-		},
-		[ setBlueprintPreferredVersions, setPhpVersion, setWpVersion ]
-	);
-
 	const handleBlueprintChange = useCallback(
 		( blueprintId: string ) => {
 			const blueprint = blueprintsData?.blueprints.find(
 				( b: Blueprint ) => b.slug === blueprintId
 			);
 			setSelectedBlueprint( blueprint );
-			applyBlueprintVersions( blueprint );
+			if ( blueprint?.blueprint?.preferredVersions ) {
+				setBlueprintPreferredVersions?.(
+					blueprint.blueprint.preferredVersions as { php?: string; wp?: string }
+				);
+			} else {
+				setBlueprintPreferredVersions?.( undefined );
+			}
 		},
-		[ blueprintsData?.blueprints, setSelectedBlueprint, applyBlueprintVersions ]
+		[ blueprintsData?.blueprints, setSelectedBlueprint, setBlueprintPreferredVersions ]
 	);
 
 	const handleFileBlueprintSelect = useCallback(
 		( blueprint: Blueprint ) => {
 			setSelectedBlueprint( blueprint );
-			applyBlueprintVersions( blueprint );
+			if ( blueprint?.blueprint?.preferredVersions ) {
+				setBlueprintPreferredVersions?.(
+					blueprint.blueprint.preferredVersions as { php?: string; wp?: string }
+				);
+			} else {
+				setBlueprintPreferredVersions?.( undefined );
+			}
 		},
-		[ setSelectedBlueprint, applyBlueprintVersions ]
+		[ setSelectedBlueprint, setBlueprintPreferredVersions ]
 	);
 
+	// Build default values with blueprint preferred versions applied
+	const getDefaultValuesWithBlueprint = useCallback( () => {
+		const values = { ...defaultValues };
+		if ( blueprintPreferredVersions?.php && blueprintPreferredVersions.php !== 'latest' ) {
+			values.phpVersion = blueprintPreferredVersions.php as AllowedPHPVersion;
+		}
+		if ( blueprintPreferredVersions?.wp && blueprintPreferredVersions.wp !== 'latest' ) {
+			values.wpVersion = blueprintPreferredVersions.wp;
+		}
+		return values;
+	}, [ defaultValues, blueprintPreferredVersions ] );
+
+	// Ref for programmatic form submission
+	const formRef = useRef< HTMLFormElement >( null );
+
+	// Common props for CreateSite
+	const createSiteProps = {
+		onSelectPath,
+		onSiteNameChange,
+		existingDomainNames,
+		onSubmit: onFormSubmit,
+		formRef,
+	};
+
 	return (
 		<>
 			<Navigator.Screen className="flex-1" path="/">
@@ -251,11 +268,12 @@ function NavigationContent( props: NavigationContentProps ) {
 			<Navigator.Screen className="flex-1" path="/blueprint/select/create">
 				<CreateSite
 					{ ...createSiteProps }
+					defaultValues={ getDefaultValuesWithBlueprint() }
 					blueprintPreferredVersions={ blueprintPreferredVersions }
 				/>
 			</Navigator.Screen>
 			<Navigator.Screen className="flex-1" path="/create">
-				<CreateSite { ...createSiteProps } />
+				<CreateSite { ...createSiteProps } defaultValues={ defaultValues } />
 			</Navigator.Screen>
 			<Navigator.Screen className="flex-1" path="/blueprint/deeplink">
 				<BlueprintDeeplink
@@ -266,28 +284,27 @@ function NavigationContent( props: NavigationContentProps ) {
 			<Navigator.Screen className="flex-1" path="/blueprint/deeplink/create">
 				<CreateSite
 					{ ...createSiteProps }
+					defaultValues={ getDefaultValuesWithBlueprint() }
 					blueprintPreferredVersions={ blueprintPreferredVersions }
 				/>
 			</Navigator.Screen>
 			<Navigator.Screen className="flex-1" path="/backup">
-				<ImportBackup
-					onFileSelect={ handleBackupFileSelect }
-					selectedFile={ createSiteProps.fileForImport }
-				/>
+				<ImportBackup onFileSelect={ handleBackupFileSelect } selectedFile={ fileForImport } />
 			</Navigator.Screen>
 			<Navigator.Screen className="flex-1" path="/backup/create">
-				<CreateSite { ...createSiteProps } />
+				<CreateSite { ...createSiteProps } defaultValues={ defaultValues } />
 			</Navigator.Screen>
 			<Navigator.Screen className="flex-1 flex justify-center" path="/pullRemote">
 				<PullRemoteSite
 					selectedRemoteSite={ selectedRemoteSite }
-					setSelectedRemoteSite={ async ( remoteSite?: SyncSite ) => {
-						setSelectedRemoteSite( remoteSite );
-					} }
+					setSelectedRemoteSite={ setSelectedRemoteSite }
 				/>
 			</Navigator.Screen>
 			<Navigator.Screen className="flex-1" path="/pullRemote/create">
-				<CreateSite { ...createSiteProps } />
+				<CreateSite
+					{ ...createSiteProps }
+					defaultValues={ { ...defaultValues, siteName: remoteSiteName } }
+				/>
 			</Navigator.Screen>
 			<Stepper
 				currentPath={ location.path }
@@ -296,12 +313,14 @@ function NavigationContent( props: NavigationContentProps ) {
 				onBlueprintDeeplinkContinue={ handleBlueprintDeeplinkContinue }
 				onBackupContinue={ handleBackupContinue }
 				onPullRemoteContinue={ handlePullRemoteContinue }
-				onCreateSubmit={ createSiteProps.handleSubmit }
+				onCreateSubmit={ () => {
+					formRef.current?.requestSubmit();
+				} }
 				canSubmitBlueprint={ !! selectedBlueprint }
 				canSubmitBlueprintDeeplink={ !! selectedBlueprint }
-				canSubmitBackup={ !! createSiteProps.fileForImport }
+				canSubmitBackup={ !! fileForImport }
 				canSubmitPullRemote={ !! selectedRemoteSite }
-				canSubmitCreate={ !! canSubmit }
+				canSubmitCreate={ canSubmit }
 			/>
 		</>
 	);
@@ -321,7 +340,9 @@ export function AddSiteModalContent( {
 	addSiteProps,
 }: AddSiteModalContentProps ) {
 	const { __ } = useI18n();
-	const [ nameSuggested, setNameSuggested ] = useState( false );
+	const [ formInitialized, setFormInitialized ] = useState( false );
+	const [ defaultSiteName, setDefaultSiteName ] = useState( '' );
+	const [ defaultSitePath, setDefaultSitePath ] = useState( '' );
 
 	const {
 		data: blueprintsData,
@@ -332,20 +353,24 @@ export function AddSiteModalContent( {
 	const { sites, loadingSites } = useSiteDetails();
 
 	const {
-		handleAddSiteClick,
-		siteName,
-		setSiteName,
-		setWpVersion,
-		setProposedSitePath,
-		setDoesPathContainWordPress,
-		loadAllCustomDomains,
+		handleCreateSite,
+		selectPath,
+		generateProposedPath,
+		defaultPhpVersion,
+		defaultWpVersion,
+		deeplinkPhpVersion,
+		deeplinkWpVersion,
+		fileForImport,
+		setFileForImport,
 		selectedBlueprint,
 		setSelectedBlueprint,
-		selectedRemoteSite,
-		setSelectedRemoteSite,
 		blueprintPreferredVersions,
 		setBlueprintPreferredVersions,
 		blueprintDeeplinkWarnings,
+		selectedRemoteSite,
+		setSelectedRemoteSite,
+		existingDomainNames,
+		loadAllCustomDomains,
 		isDeeplinkFlow,
 		setIsDeeplinkFlow,
 	} = addSiteProps;
@@ -358,64 +383,88 @@ export function AddSiteModalContent( {
 
 	const initialNavigatorPath = selectedBlueprint ? '/blueprint/deeplink' : '/';
 
-	const siteAddedMessage = sprintf(
-		// translators: %s is the site name.
-		__( '%s site added.' ),
-		siteName || ''
-	);
+	// Initialize form with generated site name and path
+	useEffect( () => {
+		const initializeForm = async () => {
+			if ( ! isOpen || formInitialized || loadingSites ) return;
 
-	const initializeForm = useCallback( async () => {
-		const generatedSiteName = await generateSiteName( sites );
-		const { path, name, isWordPress } =
-			await getIpcApi().generateProposedSitePath( generatedSiteName );
-		if ( latestStableVersion ) {
-			setWpVersion( latestStableVersion.value );
-		}
-		setNameSuggested( true );
-		setSiteName( name );
-		setProposedSitePath( path );
-		setDoesPathContainWordPress( isWordPress );
-		loadAllCustomDomains();
-	}, [
-		sites,
-		setSiteName,
-		setProposedSitePath,
-		setDoesPathContainWordPress,
-		setWpVersion,
-		latestStableVersion,
-		loadAllCustomDomains,
-	] );
+			const generatedSiteName = await generateSiteName( sites );
+			const { path } = await getIpcApi().generateProposedSitePath( generatedSiteName );
+
+			setDefaultSiteName( generatedSiteName );
+			setDefaultSitePath( path );
+			setFormInitialized( true );
+			loadAllCustomDomains();
+		};
 
+		void initializeForm();
+	}, [ isOpen, formInitialized, loadingSites, sites, loadAllCustomDomains ] );
+
+	// Reset form initialized state when modal closes
 	useEffect( () => {
-		if ( isOpen && ! nameSuggested && ! loadingSites ) {
-			void initializeForm();
+		if ( ! isOpen ) {
+			setFormInitialized( false );
 		}
-	}, [ isOpen, nameSuggested, loadingSites, initializeForm ] );
+	}, [ isOpen ] );
+
+	const defaultValues = useMemo(
+		() => ( {
+			siteName: defaultSiteName,
+			sitePath: defaultSitePath,
+			phpVersion: isDeeplinkFlow ? deeplinkPhpVersion : defaultPhpVersion,
+			wpVersion: isDeeplinkFlow
+				? deeplinkWpVersion
+				: latestStableVersion?.value ?? defaultWpVersion,
+		} ),
+		[
+			defaultSiteName,
+			defaultSitePath,
+			defaultPhpVersion,
+			defaultWpVersion,
+			deeplinkPhpVersion,
+			deeplinkWpVersion,
+			isDeeplinkFlow,
+			latestStableVersion,
+		]
+	);
+
+	const handleFormSubmit = useCallback(
+		async ( values: CreateSiteFormValues ) => {
+			const siteAddedMessage = sprintf(
+				// translators: %s is the site name.
+				__( '%s site added.' ),
+				values.siteName
+			);
 
-	const handleSubmit = useCallback(
-		async ( event: FormEvent ) => {
-			event.preventDefault();
 			onSubmit?.();
-			await handleAddSiteClick();
+			await handleCreateSite( values );
 			speak( siteAddedMessage );
-			setNameSuggested( false );
 		},
-		[ handleAddSiteClick, siteAddedMessage, onSubmit ]
+		[ __, handleCreateSite, onSubmit ]
 	);
 
+	// canSubmit is true if the form is initialized (we have default values)
+	const canSubmit = formInitialized && defaultSiteName.trim().length > 0;
+
 	return (
 		<Navigator
 			className={ className ?? 'w-full h-full app-no-drag-region' }
 			initialPath={ initialNavigatorPath }
 		>
 			<NavigationContent
-				{ ...addSiteProps }
-				selectedBlueprint={ selectedBlueprint }
-				setSelectedBlueprint={ setSelectedBlueprint }
 				blueprintsData={ blueprintsData }
 				blueprintsErrorMessage={ formatRtkError( blueprintsError ) }
 				isLoadingBlueprints={ isLoadingBlueprints }
-				handleSubmit={ handleSubmit }
+				defaultValues={ defaultValues }
+				onSelectPath={ selectPath }
+				onSiteNameChange={ generateProposedPath }
+				existingDomainNames={ existingDomainNames }
+				onFormSubmit={ handleFormSubmit }
+				canSubmit={ canSubmit }
+				fileForImport={ fileForImport }
+				setFileForImport={ setFileForImport }
+				selectedBlueprint={ selectedBlueprint }
+				setSelectedBlueprint={ setSelectedBlueprint }
 				blueprintPreferredVersions={ blueprintPreferredVersions }
 				setBlueprintPreferredVersions={ setBlueprintPreferredVersions }
 				blueprintDeeplinkWarnings={ blueprintDeeplinkWarnings }