diff --git a/frontend/src/hooks/useChangeDetectionWorkflow.ts b/frontend/src/hooks/useChangeDetectionWorkflow.ts
index 7d1749eb..f2f9e456 100644
--- a/frontend/src/hooks/useChangeDetectionWorkflow.ts
+++ b/frontend/src/hooks/useChangeDetectionWorkflow.ts
@@ -38,7 +38,7 @@ export function useChangeDetectionWorkflow({
     const targetDatasetId =
       changeTargetDatasetId || availableVectorDatasets.find((dataset) => dataset.id !== sourceDatasetId)?.id
     if (!sourceDatasetId || !targetDatasetId) {
-      setChangeDetectionError('Select two vector datasets')
+      setChangeDetectionError('Kies twee vectorbronnen')
       return
     }
     if (sourceDatasetId === targetDatasetId) {
diff --git a/frontend/src/hooks/useDatasetWorkflow.ts b/frontend/src/hooks/useDatasetWorkflow.ts
index 838a395e..ea9c4abc 100644
--- a/frontend/src/hooks/useDatasetWorkflow.ts
+++ b/frontend/src/hooks/useDatasetWorkflow.ts
@@ -230,15 +230,15 @@ export function useDatasetWorkflow({
   const uploadDataset = async (event: FormEvent) => {
     event.preventDefault()
     if (!selectedProjectId || !datasetForm.file) {
-      setErrorMessage('Select project and upload a file')
+      setErrorMessage('Kies een werkruimte en voeg een bestand toe')
       return
     }
     if (!datasetForm.datasetRole) {
-      setErrorMessage('Select dataset role')
+      setErrorMessage('Kies de rol van deze bron')
       return
     }
     if (datasetForm.datasetRole === 'reference' && datasetForm.datasetType !== 'vector' && datasetForm.datasetType !== 'geojson') {
-      setErrorMessage('Reference role requires vector dataset upload')
+      setErrorMessage('Een referentierol vraagt om een vectorbestand')
       return
     }
     if (datasetForm.sourceMetadataJson) {
@@ -280,7 +280,7 @@ export function useDatasetWorkflow({
       setDatasetForm((previous) => ({ ...previous, file: null }))
       await loadProjectData(selectedProjectId)
     } catch (error) {
-      setErrorMessage(error instanceof Error ? error.message : 'Failed to upload dataset')
+      setErrorMessage(error instanceof Error ? error.message : 'De bron kon niet worden ingeladen')
     }
   }
 
@@ -300,7 +300,7 @@ export function useDatasetWorkflow({
       return
     }
     if (!selectedClipAreaId) {
-      setDatasetDetailError('Select an area for clipping')
+      setDatasetDetailError('Kies eerst een gebied om op bij te snijden')
       return
     }
     setDatasetDetailError(null)
@@ -337,7 +337,7 @@ export function useDatasetWorkflow({
     }
     const targetId = selectedIntersectTargetId || availableVectorTargets[0]?.id
     if (!targetId) {
-      setDatasetDetailError('Select an intersect target dataset')
+      setDatasetDetailError('Kies eerst een bron om mee te doorsnijden')
       return
     }
     setDatasetDetailError(null)
@@ -421,7 +421,7 @@ export function useDatasetWorkflow({
       return
     }
     if (!selectedClipAreaId) {
-      setDatasetDetailError('Select an area for raster clip')
+      setDatasetDetailError('Kies eerst een gebied om het raster op bij te snijden')
       return
     }
     try {
diff --git a/frontend/src/hooks/useDetectionWorkflow.ts b/frontend/src/hooks/useDetectionWorkflow.ts
index 0680af87..7b6bd5c2 100644
--- a/frontend/src/hooks/useDetectionWorkflow.ts
+++ b/frontend/src/hooks/useDetectionWorkflow.ts
@@ -146,7 +146,7 @@ export function useDetectionWorkflow({
         setSelectedDetectionModelId(configuredModel?.model_id ?? response.models[0].model_id)
       }
     } catch (error) {
-      setDetectionModelError(formatError(error, 'Failed to load detection models'))
+      setDetectionModelError(formatError(error, 'De detectiemodellen konden niet worden geladen'))
     }
     try {
       const assetResponse = await detectionApi.listModelAssets()
@@ -160,11 +160,11 @@ export function useDetectionWorkflow({
         setYoloPreflight(preflight)
         setYoloPreflightError(null)
       } catch (error) {
-        setYoloPreflightError(formatError(error, 'Failed to load YOLO preflight status'))
+        setYoloPreflightError(formatError(error, 'De modelcontrole kon niet worden opgehaald'))
       }
     } catch (error) {
       setModelAssets([])
-      setModelAssetError(formatError(error, 'Failed to load local model assets'))
+      setModelAssetError(formatError(error, 'De lokale modelbestanden konden niet worden geladen'))
     } finally {
       setLoadingDetectionModels(false)
     }
@@ -180,7 +180,7 @@ export function useDetectionWorkflow({
       })
       setYoloPreflight(response)
     } catch (error) {
-      setYoloPreflightError(formatError(error, 'Failed to load YOLO preflight status'))
+      setYoloPreflightError(formatError(error, 'De modelcontrole kon niet worden opgehaald'))
     } finally {
       setLoadingYoloPreflight(false)
     }
@@ -198,7 +198,7 @@ export function useDetectionWorkflow({
         setSelectedDetectionRunId(response.items[0].id)
       }
     } catch (error) {
-      setDetectionRunError(formatError(error, 'Failed to load detection runs'))
+      setDetectionRunError(formatError(error, 'De detectieruns konden niet worden geladen'))
     }
   }
 
@@ -229,7 +229,7 @@ export function useDetectionWorkflow({
       setDetectionTruncated(Boolean(detectionsResponse.truncated))
       setDetectionGeoJson(geoJsonResponse)
     } catch (error) {
-      setDetectionRunError(formatError(error, 'Failed to load detection results'))
+      setDetectionRunError(formatError(error, 'De detectieresultaten konden niet worden geladen'))
     } finally {
       setLoadingDetectionResults(false)
     }
@@ -262,12 +262,12 @@ export function useDetectionWorkflow({
 
   const runDetection = async () => {
     if (!selectedProjectId) {
-      setDetectionRunError('Select a project first')
+      setDetectionRunError('Kies eerst een werkruimte')
       return
     }
     const datasetId = selectedDetectionDatasetId
     if (!datasetId) {
-      setDetectionRunError('Select a raster dataset')
+      setDetectionRunError('Kies eerst een rasterbron')
       return
     }
     setDetectionRunError(null)
@@ -414,11 +414,11 @@ export function useDetectionWorkflow({
     iouThresholdOverride?: number,
   ): Promise<DetectionQaResult | null> => {
     if (!analysisRunId) {
-      setDetectionQaError('Select a detection run')
+      setDetectionQaError('Kies eerst een detectierun')
       return null
     }
     if (!referenceDatasetId) {
-      setDetectionQaError('Select a reference dataset')
+      setDetectionQaError('Kies eerst een referentiebron')
       return null
     }
     setSelectedDetectionRunId(analysisRunId)
@@ -449,21 +449,21 @@ export function useDetectionWorkflow({
 
   const runDetectionCalibration = async () => {
     if (!selectedProjectId) {
-      setDetectionCalibrationError('Select a project before calibration')
+      setDetectionCalibrationError('Kies eerst een werkruimte om te kalibreren')
       return
     }
     const datasetId = selectedDetectionDatasetId
     if (!datasetId) {
-      setDetectionCalibrationError('Select a raster dataset before calibration')
+      setDetectionCalibrationError('Kies eerst een rasterbron om te kalibreren')
       return
     }
     if (!detectionReferenceDatasetId) {
-      setDetectionCalibrationError('Select a reference dataset before calibration')
+      setDetectionCalibrationError('Kies eerst een referentiebron om te kalibreren')
       return
     }
     const selectedModel = detectionModels.find((model) => model.model_id === selectedDetectionModelId)
     if (!selectedModel?.configured || selectedDetectionModelId === 'manual-fixture-detector') {
-      setDetectionCalibrationError('Select a configured non-fixture detection model before calibration')
+      setDetectionCalibrationError('Kies eerst een geconfigureerd detectiemodel; testgegevens kunnen niet gekalibreerd worden')
       return
     }
     if (selectedDetectionModelId === 'yolo-configured' && !detectionTileManifestPath.trim()) {
@@ -471,7 +471,7 @@ export function useDetectionWorkflow({
       return
     }
     if (selectedDetectionModelId === 'yolo-configured' && modelAssets.length > 0 && !selectedModelAssetId) {
-      setDetectionCalibrationError('Select a local model asset before calibration')
+      setDetectionCalibrationError('Kies eerst een lokaal modelbestand om te kalibreren')
       return
     }
     const thresholds = parseCalibrationThresholds(calibrationThresholdText)
diff --git a/frontend/src/hooks/useExportWorkflow.ts b/frontend/src/hooks/useExportWorkflow.ts
index 42ebfa7e..7bf26b5c 100644
--- a/frontend/src/hooks/useExportWorkflow.ts
+++ b/frontend/src/hooks/useExportWorkflow.ts
@@ -45,7 +45,7 @@ export function useExportWorkflow({
       const response = await exportsApi.listProjectExports(projectId)
       setExports(response.items)
     } catch (error) {
-      setExportError(formatError(error, 'Failed to load exports'))
+      setExportError(formatError(error, 'De downloads konden niet worden geladen'))
     } finally {
       setLoadingExports(false)
     }
@@ -53,7 +53,7 @@ export function useExportWorkflow({
 
   const exportSelectedDatasetGeoJson = async () => {
     if (!selectedDataset || !isVectorDatasetType(selectedDataset.dataset_type)) {
-      setExportError('Select a vector dataset before exporting GeoJSON.')
+      setExportError('Kies eerst een vectorbron om als GeoJSON te bewaren.')
       return
     }
     setExporting(true)
@@ -67,7 +67,7 @@ export function useExportWorkflow({
       setLatestExport(response)
       await loadExports(selectedDataset.project_id)
     } catch (error) {
-      setExportError(formatError(error, 'Failed to export selected dataset'))
+      setExportError(formatError(error, 'De gekozen bron kon niet worden geëxporteerd'))
     } finally {
       setExporting(false)
     }
@@ -75,7 +75,7 @@ export function useExportWorkflow({
 
   const exportSelectedDetectionRunGeoJson = async () => {
     if (!selectedDetectionRunId || !selectedProjectId) {
-      setExportError('Select a detection run before exporting GeoJSON.')
+      setExportError('Kies eerst een detectierun om als GeoJSON te bewaren.')
       return
     }
     setExporting(true)
@@ -89,7 +89,7 @@ export function useExportWorkflow({
       setLatestExport(response)
       await loadExports(selectedProjectId)
     } catch (error) {
-      setExportError(formatError(error, 'Failed to export detection run'))
+      setExportError(formatError(error, 'De detectierun kon niet worden geëxporteerd'))
     } finally {
       setExporting(false)
     }
@@ -97,7 +97,7 @@ export function useExportWorkflow({
 
   const exportSelectedSegmentationRunGeoJson = async () => {
     if (!selectedSegmentationRunId || !selectedProjectId) {
-      setExportError('Select a segmentation run before exporting GeoJSON.')
+      setExportError('Kies eerst een segmentatierun om als GeoJSON te bewaren.')
       return
     }
     setExporting(true)
@@ -110,7 +110,7 @@ export function useExportWorkflow({
       setLatestExport(response)
       await loadExports(selectedProjectId)
     } catch (error) {
-      setExportError(formatError(error, 'Failed to export segmentation run'))
+      setExportError(formatError(error, 'De segmentatierun kon niet worden geëxporteerd'))
     } finally {
       setExporting(false)
     }
@@ -118,7 +118,7 @@ export function useExportWorkflow({
 
   const exportMapSelectionGeoJson = async (bbox: VectorSelectionBBox, areaId?: string) => {
     if (!selectedDataset || !isVectorDatasetType(selectedDataset.dataset_type)) {
-      setSelectionExportError('Select a vector dataset before saving an area export.')
+      setSelectionExportError('Kies eerst een vectorbron om het gebied mee te bewaren.')
       return null
     }
     setSelectionExporting(true)
@@ -137,7 +137,7 @@ export function useExportWorkflow({
       await loadExports(selectedDataset.project_id)
       return response
     } catch (error) {
-      setSelectionExportError(formatError(error, 'Failed to save area export'))
+      setSelectionExportError(formatError(error, 'De gebiedsdownload kon niet worden bewaard'))
       return null
     } finally {
       setSelectionExporting(false)
@@ -146,7 +146,7 @@ export function useExportWorkflow({
 
   const exportProjectMetadata = async () => {
     if (!selectedProjectId) {
-      setExportError('Select a project before exporting metadata.')
+      setExportError('Kies eerst een werkruimte om de projectgegevens te bewaren.')
       return
     }
     setExporting(true)
@@ -156,7 +156,7 @@ export function useExportWorkflow({
       setLatestExport(response)
       await loadExports(selectedProjectId)
     } catch (error) {
-      setExportError(formatError(error, 'Failed to export project metadata'))
+      setExportError(formatError(error, 'De projectgegevens konden niet worden geëxporteerd'))
     } finally {
       setExporting(false)
     }
@@ -164,7 +164,7 @@ export function useExportWorkflow({
 
   const exportProjectReport = async () => {
     if (!selectedProjectId) {
-      setExportError('Select a project before exporting a report.')
+      setExportError('Kies eerst een werkruimte om een rapport te maken.')
       return
     }
     setExporting(true)
@@ -174,7 +174,7 @@ export function useExportWorkflow({
       setLatestExport(response)
       await loadExports(selectedProjectId)
     } catch (error) {
-      setExportError(formatError(error, 'Failed to export project report'))
+      setExportError(formatError(error, 'Het projectrapport kon niet worden gemaakt'))
     } finally {
       setExporting(false)
     }
@@ -204,7 +204,7 @@ export function useExportWorkflow({
       const response = await exportsApi.getContent(selectedProjectId, exportId)
       setExportPreview(response.content)
     } catch (error) {
-      setExportError(formatError(error, 'Failed to load export content'))
+      setExportError(formatError(error, 'De inhoud van de download kon niet worden geladen'))
     }
   }
 
diff --git a/frontend/src/hooks/useMapSelectionDataset.ts b/frontend/src/hooks/useMapSelectionDataset.ts
index 16f01cd3..7e3d5e23 100644
--- a/frontend/src/hooks/useMapSelectionDataset.ts
+++ b/frontend/src/hooks/useMapSelectionDataset.ts
@@ -26,7 +26,7 @@ export function useMapSelectionDataset({
 
   const deriveMapSelectionDataset = async (bbox: VectorSelectionBBox, areaId?: string) => {
     if (!selectedProjectId || !selectedDataset || !isVectorDatasetType(selectedDataset.dataset_type)) {
-      setSelectionDatasetError('Select a vector dataset before saving the area as a dataset.')
+      setSelectionDatasetError('Kies eerst een vectorbron om het gebied als bron te bewaren.')
       return null
     }
     setSelectionDatasetSaving(true)
@@ -44,7 +44,7 @@ export function useMapSelectionDataset({
       setMapLayerVisible(true)
       return derived
     } catch (error) {
-      setSelectionDatasetError(formatError(error, 'Failed to save area as dataset'))
+      setSelectionDatasetError(formatError(error, 'Het gebied kon niet als bron worden bewaard'))
       return null
     } finally {
       setSelectionDatasetSaving(false)
diff --git a/frontend/src/hooks/useMapSelectionQa.ts b/frontend/src/hooks/useMapSelectionQa.ts
index 8c6bf5fb..cc27af19 100644
--- a/frontend/src/hooks/useMapSelectionQa.ts
+++ b/frontend/src/hooks/useMapSelectionQa.ts
@@ -24,7 +24,7 @@ export function useMapSelectionQa({
 
   const runMapSelectionQa = async (candidateDataset = latestSelectionDataset) => {
     if (!selectedProjectId) {
-      setMapSelectionQaError('Select a project before running QA/QC.')
+      setMapSelectionQaError('Kies eerst een werkruimte om een kwaliteitscontrole te draaien.')
       return null
     }
     if (!candidateDataset) {
@@ -32,7 +32,7 @@ export function useMapSelectionQa({
       return null
     }
     if (!selectedMapQaReferenceDatasetId) {
-      setMapSelectionQaError('Select a reference dataset for QA/QC.')
+      setMapSelectionQaError('Kies eerst een referentiebron voor de kwaliteitscontrole.')
       return null
     }
     if (candidateDataset.id === selectedMapQaReferenceDatasetId) {
diff --git a/frontend/src/hooks/useProviderCapabilities.ts b/frontend/src/hooks/useProviderCapabilities.ts
index 2d5213e6..7f3dc6af 100644
--- a/frontend/src/hooks/useProviderCapabilities.ts
+++ b/frontend/src/hooks/useProviderCapabilities.ts
@@ -16,7 +16,7 @@ export function useProviderCapabilities() {
       const providerResponse = await externalApi.listProviders()
       setProviderCapabilities(providerResponse.providers)
     } catch (error) {
-      setCapabilitiesError(error instanceof Error ? error.message : 'Failed to load external capabilities')
+      setCapabilitiesError(error instanceof Error ? error.message : 'De bronkoppelingen konden niet worden geladen')
     } finally {
       setLoadingCapabilities(false)
     }
diff --git a/frontend/src/hooks/useQualityWorkflow.ts b/frontend/src/hooks/useQualityWorkflow.ts
index 51707c93..7f5f2407 100644
--- a/frontend/src/hooks/useQualityWorkflow.ts
+++ b/frontend/src/hooks/useQualityWorkflow.ts
@@ -33,13 +33,13 @@ export function useQualityWorkflow({ selectedProjectId, loadProjectData }: Quali
       setQualityChecks(response.items)
       return response.items
     } catch (error) {
-      setQualityChecksError(formatError(error, 'Failed to load QA/QC results'))
+      setQualityChecksError(formatError(error, 'De kwaliteitscontroles konden niet worden geladen'))
     }
   }
 
   const loadQualityEvidenceGeoJson = async (qualityCheckId: string, projectId = selectedProjectId): Promise<QualityEvidenceGeoJsonResponse | null> => {
     if (!projectId) {
-      setQualityEvidenceError('Select a project first')
+      setQualityEvidenceError('Kies eerst een werkruimte')
       return null
     }
     setQualityEvidenceLoading(true)
@@ -49,7 +49,7 @@ export function useQualityWorkflow({ selectedProjectId, loadProjectData }: Quali
       setQualityEvidenceGeoJson(response)
       return response
     } catch (error) {
-      setQualityEvidenceError(formatError(error, 'Failed to load QA/QC evidence overlay'))
+      setQualityEvidenceError(formatError(error, 'De bewijslaag van de kwaliteitscontrole kon niet worden geladen'))
       return null
     } finally {
       setQualityEvidenceLoading(false)
@@ -63,15 +63,15 @@ export function useQualityWorkflow({ selectedProjectId, loadProjectData }: Quali
 
   const runQaComparison = async () => {
     if (!selectedProjectId) {
-      setQaError('Select a project first')
+      setQaError('Kies eerst een werkruimte')
       return
     }
     if (!qaCandidateDatasetId) {
-      setQaError('Select candidate dataset')
+      setQaError('Kies eerst een kandidaatbron')
       return
     }
     if (!qaReferenceDatasetId) {
-      setQaError('Select reference dataset')
+      setQaError('Kies eerst een referentiebron')
       return
     }
     if (qaCandidateDatasetId === qaReferenceDatasetId) {
diff --git a/frontend/src/hooks/useSegmentationWorkflow.ts b/frontend/src/hooks/useSegmentationWorkflow.ts
index 45514168..830f04a9 100644
--- a/frontend/src/hooks/useSegmentationWorkflow.ts
+++ b/frontend/src/hooks/useSegmentationWorkflow.ts
@@ -72,7 +72,7 @@ export function useSegmentationWorkflow({
         )
       }
     } catch (error) {
-      setSegmentationModelError(formatError(error, 'Failed to load segmentation models'))
+      setSegmentationModelError(formatError(error, 'De segmentatiemodellen konden niet worden geladen'))
     } finally {
       setLoadingSegmentationModels(false)
     }
@@ -90,7 +90,7 @@ export function useSegmentationWorkflow({
         setSelectedSegmentationRunId(response.items[0].id)
       }
     } catch (error) {
-      setSegmentationRunError(formatError(error, 'Failed to load segmentation runs'))
+      setSegmentationRunError(formatError(error, 'De segmentatieruns konden niet worden geladen'))
     }
   }
 
@@ -115,7 +115,7 @@ export function useSegmentationWorkflow({
       setSegmentationItems(segmentationsResponse.items)
       setSegmentationGeoJson(geoJsonResponse)
     } catch (error) {
-      setSegmentationRunError(formatError(error, 'Failed to load segmentation results'))
+      setSegmentationRunError(formatError(error, 'De segmentatieresultaten konden niet worden geladen'))
     } finally {
       setLoadingSegmentationResults(false)
     }
@@ -123,16 +123,16 @@ export function useSegmentationWorkflow({
 
   const runSegmentation = async () => {
     if (!selectedProjectId) {
-      setSegmentationRunError('Select a project first')
+      setSegmentationRunError('Kies eerst een werkruimte')
       return
     }
     const datasetId = selectedSegmentationDatasetId || rasterDatasets[0]?.id
     if (!datasetId) {
-      setSegmentationRunError('Select a raster dataset')
+      setSegmentationRunError('Kies eerst een rasterbron')
       return
     }
     if (!selectedSegmentationModel?.configured) {
-      setSegmentationRunError('Selected segmentation model is not configured')
+      setSegmentationRunError('Het gekozen segmentatiemodel is niet geconfigureerd')
       return
     }
     setSegmentationRunError(null)
@@ -165,11 +165,11 @@ export function useSegmentationWorkflow({
 
   const runSegmentationQa = async () => {
     if (!selectedSegmentationRunId) {
-      setSegmentationQaError('Select a segmentation run')
+      setSegmentationQaError('Kies eerst een segmentatierun')
       return
     }
     if (!segmentationReferenceDatasetId) {
-      setSegmentationQaError('Select a reference dataset')
+      setSegmentationQaError('Kies eerst een referentiebron')
       return
     }
     setSegmentationQaError(null)