diff --git a/backend/src/main/java/fr/nessar/lmnporganizer/rental/adapter/in/web/common/RentalApiExceptionHandler.java b/backend/src/main/java/fr/nessar/lmnporganizer/rental/adapter/in/web/common/RentalApiExceptionHandler.java
index aef6e1a..af58262 100644
--- a/backend/src/main/java/fr/nessar/lmnporganizer/rental/adapter/in/web/common/RentalApiExceptionHandler.java
+++ b/backend/src/main/java/fr/nessar/lmnporganizer/rental/adapter/in/web/common/RentalApiExceptionHandler.java
@@ -13,6 +13,9 @@ import fr.nessar.lmnporganizer.rental.domain.lease.LeaseFinalizationConflict;
 import fr.nessar.lmnporganizer.rental.domain.lease.LeaseRuleViolation;
 import fr.nessar.lmnporganizer.rental.domain.rent.RentRevisionConflict;
 import fr.nessar.lmnporganizer.rental.domain.rent.RentRuleViolation;
+import java.util.Locale;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.dao.OptimisticLockingFailureException;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
@@ -23,20 +26,23 @@ import org.springframework.web.multipart.MaxUploadSizeExceededException;
 
 @RestControllerAdvice(basePackages = "fr.nessar.lmnporganizer.rental.adapter.in.web")
 public class RentalApiExceptionHandler {
+private static final Logger LOGGER = LoggerFactory.getLogger(RentalApiExceptionHandler.class);
+
 @ExceptionHandler(ResourceNotFound.class)
 ResponseEntity<ApiError> notFound(ResourceNotFound exception) {
 	return error(HttpStatus.NOT_FOUND, exception.getMessage());
 }
 
-@ExceptionHandler({
-	LeaseRuleViolation.class,
-	RentRuleViolation.class,
-	IllegalArgumentException.class
-})
+@ExceptionHandler({LeaseRuleViolation.class, RentRuleViolation.class})
 ResponseEntity<ApiError> invalid(RuntimeException exception) {
 	return error(HttpStatus.BAD_REQUEST, exception.getMessage());
 }
 
+@ExceptionHandler(IllegalArgumentException.class)
+ResponseEntity<ApiError> invalidArgument() {
+	return error(HttpStatus.BAD_REQUEST, "La requête est invalide.");
+}
+
 @ExceptionHandler({
 	ReferencedResource.class,
 	EmailAlreadyUsed.class,
@@ -77,13 +83,24 @@ ResponseEntity<CodedApiError> irlUnavailable(IrlIndexUnavailable exception) {
 }
 
 @ExceptionHandler(MethodArgumentNotValidException.class)
-ResponseEntity<ApiError> invalidRequest(MethodArgumentNotValidException exception) {
-	String message =
-		exception.getBindingResult().getFieldErrors().stream()
-			.findFirst()
-			.map(error -> error.getDefaultMessage())
-			.orElse("La requête est invalide.");
-	return error(HttpStatus.BAD_REQUEST, message);
+ResponseEntity<ValidationApiError> invalidRequest(MethodArgumentNotValidException exception) {
+	return ResponseEntity.badRequest()
+		.body(
+			new ValidationApiError(
+				"validation_failed",
+				exception.getBindingResult().getFieldErrors().stream()
+					.map(error -> new FieldValidationError(error.getField(), code(error.getCode())))
+					.toList()));
+}
+
+@ExceptionHandler(Exception.class)
+ResponseEntity<ApiError> unexpected(Exception exception) {
+	LOGGER.error("Unhandled rental API exception", exception);
+	return error(HttpStatus.INTERNAL_SERVER_ERROR, "Une erreur inattendue est survenue.");
+}
+
+private static String code(String constraint) {
+	return constraint.replaceAll("(?<=[a-z])(?=[A-Z])", "_").toLowerCase(Locale.ROOT);
 }
 
 private static ResponseEntity<ApiError> error(HttpStatus status, String message) {
@@ -93,4 +110,8 @@ private static ResponseEntity<ApiError> error(HttpStatus status, String message)
 record ApiError(String message) {}
 
 record CodedApiError(String code, String message) {}
+
+record ValidationApiError(String code, java.util.List<FieldValidationError> errors) {}
+
+record FieldValidationError(String field, String code) {}
 }
diff --git a/backend/src/test/java/fr/nessar/lmnporganizer/rental/adapter/in/web/RentalWebAdaptersTest.java b/backend/src/test/java/fr/nessar/lmnporganizer/rental/adapter/in/web/RentalWebAdaptersTest.java
index c550e6d..f1f6dde 100644
--- a/backend/src/test/java/fr/nessar/lmnporganizer/rental/adapter/in/web/RentalWebAdaptersTest.java
+++ b/backend/src/test/java/fr/nessar/lmnporganizer/rental/adapter/in/web/RentalWebAdaptersTest.java
@@ -1,9 +1,11 @@
 package fr.nessar.lmnporganizer.rental.adapter.in.web;
 
+import static org.hamcrest.Matchers.containsInAnyOrder;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.reset;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
@@ -792,6 +794,75 @@ void rentPaymentCommandsDelegateScopedRecordingAllocationRefundAndReversal() thr
 		.reverse(LANDLORD_ID, PAYMENT_ID, 7, "Erreur bancaire", ZoneId.of("Europe/Paris"));
 }
 
+@Test
+void apartmentRequestsExposeEveryCoreValidationFailureWithStableFieldsAndCodes()
+	throws Exception {
+	mockMvc
+		.perform(
+			post("/api/apartments")
+				.with(asLandlord())
+				.with(csrf())
+				.contentType(MediaType.APPLICATION_JSON)
+				.content(
+					"{\"name\":\"  \",\"address\":\" \",\"purchasePrice\":0,\"privateAreas\":[]}"))
+		.andExpect(status().isBadRequest())
+		.andExpect(jsonPath("$.code").value("validation_failed"))
+		.andExpect(
+			jsonPath("$.errors[*].field", containsInAnyOrder("name", "address", "purchasePrice")))
+		.andExpect(
+			jsonPath("$.errors[*].code", containsInAnyOrder("not_blank", "not_blank", "positive")));
+}
+
+@Test
+void apartmentRequestsAcceptSubEuroPricesAndReturnTrimmedCoreFields() throws Exception {
+	when(apartments.create(eq(LANDLORD_ID), any()))
+		.thenAnswer(
+			invocation -> {
+			ApartmentCatalogService.Details details = invocation.getArgument(1);
+			return new Apartment(
+				APARTMENT_ID,
+				LANDLORD_ID,
+				details.name(),
+				details.address(),
+				details.purchasePrice(),
+				details.description(),
+				details.legalProfile(),
+				details.privateAreas());
+			});
+
+	mockMvc
+		.perform(
+			post("/api/apartments")
+				.with(asLandlord())
+				.with(csrf())
+				.contentType(MediaType.APPLICATION_JSON)
+				.content(
+					"{\"name\":\"  Studio  centre  \",\"address\":\"  1  rue du Test  \",\"purchasePrice\":0.50,\"privateAreas\":[]}"))
+		.andExpect(status().isCreated())
+		.andExpect(jsonPath("$.name").value("Studio  centre"))
+		.andExpect(jsonPath("$.address").value("1  rue du Test"))
+		.andExpect(jsonPath("$.purchasePrice").value(0.50));
+}
+
+@Test
+void internalExceptionMessagesAreNeverReturned() throws Exception {
+	when(apartments.get(LANDLORD_ID, APARTMENT_ID))
+		.thenThrow(new IllegalArgumentException("internal"));
+
+	mockMvc
+		.perform(get("/api/apartments/apartment-1").with(asLandlord()))
+		.andExpect(status().isBadRequest())
+		.andExpect(jsonPath("$.message").value("La requête est invalide."));
+
+	reset(apartments);
+	when(apartments.get(LANDLORD_ID, APARTMENT_ID)).thenThrow(new RuntimeException("internal"));
+
+	mockMvc
+		.perform(get("/api/apartments/apartment-1").with(asLandlord()))
+		.andExpect(status().isInternalServerError())
+		.andExpect(jsonPath("$.message").value("Une erreur inattendue est survenue."));
+}
+
 @Test
 void rentalExceptionsMapNotFoundValidationAndConflictStatuses() throws Exception {
 	when(apartments.get(LANDLORD_ID, new ApartmentId("missing")))
@@ -854,9 +925,9 @@ void rentalExceptionsMapNotFoundValidationAndConflictStatuses() throws Exception
 					"""
 																{"operationId":"missing-version","rentDueId":"due-1",
 																"receivedAt":"2026-02-02","timeZone":"Europe/Paris","amount":1000}
-																"""))
+					"""))
 		.andExpect(status().isBadRequest())
-		.andExpect(jsonPath("$.message").isNotEmpty());
+		.andExpect(jsonPath("$.code").value("validation_failed"));
 	mockMvc
 		.perform(
 			post("/api/rent-payments")
@@ -867,9 +938,9 @@ void rentalExceptionsMapNotFoundValidationAndConflictStatuses() throws Exception
 					"""
 																{"operationId":"invalid-zone","rentDueId":"due-1","rentDueVersion":2,
 																"receivedAt":"2026-02-02","timeZone":"Not/AZone","amount":1000}
-																"""))
+					"""))
 		.andExpect(status().isBadRequest())
-		.andExpect(jsonPath("$.message").value("Le fuseau horaire est invalide."));
+		.andExpect(jsonPath("$.message").value("La requête est invalide."));
 	mockMvc
 		.perform(
 			post("/api/rent-payments/payment-1/reversal")
@@ -881,7 +952,7 @@ void rentalExceptionsMapNotFoundValidationAndConflictStatuses() throws Exception
 						+ "a".repeat(501)
 						+ "\",\"timeZone\":\"Europe/Paris\"}"))
 		.andExpect(status().isBadRequest())
-		.andExpect(jsonPath("$.message").isNotEmpty());
+		.andExpect(jsonPath("$.code").value("validation_failed"));
 }
 
 private static RequestPostProcessor asLandlord() {
diff --git a/frontend/src/app/components/apartment-form/apartment-form.css b/frontend/src/app/components/apartment-form/apartment-form.css
index f5fa0b0..da3b2bb 100644
--- a/frontend/src/app/components/apartment-form/apartment-form.css
+++ b/frontend/src/app/components/apartment-form/apartment-form.css
@@ -22,6 +22,14 @@
 	font-size: 0.8rem;
 	line-height: 1.6;
 }
+.core-field mat-form-field {
+	width: 100%;
+}
+.field-error {
+	margin: -14px 0 0;
+	color: var(--danger);
+	font-size: 0.75rem;
+}
 @media (min-width: 1180px) {
 	.form-page {
 		max-width: 980px;
diff --git a/frontend/src/app/components/apartment-form/apartment-form.html b/frontend/src/app/components/apartment-form/apartment-form.html
index c3b5372..f7ae95c 100644
--- a/frontend/src/app/components/apartment-form/apartment-form.html
+++ b/frontend/src/app/components/apartment-form/apartment-form.html
@@ -37,33 +37,55 @@
 					<p>Les informations utilisées dans votre portefeuille.</p>
 				</div>
 				<div class="form-grid">
-					<mat-form-field appearance="outline"
-						><mat-label>Nom de l'appartement</mat-label
-						><input
-							matInput
-							type="text"
-							id="name"
-							[formField]="apartmentForm.name"
-							placeholder="T2 Paris 15"
-					/></mat-form-field>
-					<mat-form-field appearance="outline"
-						><mat-label>Prix d'acquisition</mat-label
-						><input
-							matInput
-							type="number"
-							id="purchasePrice"
-							[formField]="apartmentForm.purchasePrice"
-						/><span matTextSuffix>€</span></mat-form-field
-					>
-					<mat-form-field appearance="outline" class="full-field"
-						><mat-label>Adresse complète</mat-label
-						><input
-							matInput
-							type="text"
-							id="address"
-							[formField]="apartmentForm.address"
-							placeholder="45 rue des Entrepreneurs, 75015 Paris"
-					/></mat-form-field>
+					<div class="core-field">
+						<mat-form-field appearance="outline"
+							><mat-label>Nom de l'appartement</mat-label
+							><input
+								matInput
+								type="text"
+								id="name"
+								[formField]="apartmentForm.name"
+								(input)="fieldChanged.emit('name')"
+								placeholder="T2 Paris 15"
+							/>
+						</mat-form-field>
+						@if (nameError()) {
+							<p class="field-error" role="alert">{{ nameError() }}</p>
+						}
+					</div>
+					<div class="core-field">
+						<mat-form-field appearance="outline"
+							><mat-label>Prix d'acquisition</mat-label
+							><input
+								matInput
+								type="number"
+								id="purchasePrice"
+								[formField]="apartmentForm.purchasePrice"
+								(input)="fieldChanged.emit('purchasePrice')"
+								step="any"
+							/>
+							<span matTextSuffix>€</span></mat-form-field
+						>
+						@if (purchasePriceError()) {
+							<p class="field-error" role="alert">{{ purchasePriceError() }}</p>
+						}
+					</div>
+					<div class="core-field full-field">
+						<mat-form-field appearance="outline"
+							><mat-label>Adresse complète</mat-label
+							><input
+								matInput
+								type="text"
+								id="address"
+								[formField]="apartmentForm.address"
+								(input)="fieldChanged.emit('address')"
+								placeholder="45 rue des Entrepreneurs, 75015 Paris"
+							/>
+						</mat-form-field>
+						@if (addressError()) {
+							<p class="field-error" role="alert">{{ addressError() }}</p>
+						}
+					</div>
 					<mat-form-field appearance="outline" class="full-field"
 						><mat-label>Description ou notes</mat-label
 						><textarea
diff --git a/frontend/src/app/components/apartment-form/apartment-form.spec.ts b/frontend/src/app/components/apartment-form/apartment-form.spec.ts
index d8e4d91..33fc1e5 100644
--- a/frontend/src/app/components/apartment-form/apartment-form.spec.ts
+++ b/frontend/src/app/components/apartment-form/apartment-form.spec.ts
@@ -50,7 +50,7 @@ describe('ApartmentForm', () => {
 
 		form.save();
 
-		expect(form.error()).toContain('Veuillez remplir tous les champs obligatoires');
+		expect(form.error()).toContain('Le nom de l’appartement est obligatoire.');
 		expect(saved).not.toHaveBeenCalled();
 	});
 
@@ -70,10 +70,70 @@ describe('ApartmentForm', () => {
 
 		form.save();
 
-		expect(form.error()).toContain('Veuillez remplir tous les champs obligatoires');
+		expect(form.nameError()).toBe('Le nom de l’appartement est obligatoire.');
+		expect(form.addressError()).toBe('L’adresse complète est obligatoire.');
 		expect(saved).not.toHaveBeenCalled();
 	});
 
+	it('accepts every strictly positive purchase price, including a sub-euro value', () => {
+		const fixture = TestBed.createComponent(ApartmentForm);
+		const form = fixture.componentInstance;
+		const saved = vi.fn();
+		form.saved.subscribe(saved);
+		form.apartmentModel.set({
+			name: 'T2',
+			address: '1 rue de Paris',
+			purchasePrice: 0.5,
+			description: '',
+			privateAreas: [],
+			legalProfile: emptyApartmentLegalProfile(),
+		});
+
+		form.save();
+
+		expect(saved).toHaveBeenCalledWith(expect.objectContaining({ purchasePrice: 0.5 }));
+	});
+
+	it('shows backend core errors beside their controls and clears one when it is edited', async () => {
+		const fixture = TestBed.createComponent(ApartmentForm);
+		const form = fixture.componentInstance;
+		const changed = vi.fn();
+		form.fieldChanged.subscribe(changed);
+		fixture.componentRef.setInput('saveFieldErrors', [
+			{ field: 'name', code: 'not_blank' },
+			{ field: 'address', code: 'not_blank' },
+		]);
+		fixture.detectChanges();
+		await fixture.whenStable();
+
+		expect(form.nameError()).toBe('Le nom de l’appartement est obligatoire.');
+		fixture.detectChanges();
+		expect(fixture.nativeElement.querySelectorAll('.field-error')[0].textContent).toContain(
+			'Le nom de l’appartement est obligatoire.',
+		);
+		expect(fixture.nativeElement.querySelectorAll('.field-error')[1].textContent).toContain(
+			'L’adresse complète est obligatoire.',
+		);
+
+		fixture.nativeElement.querySelector('input#name').dispatchEvent(new Event('input'));
+
+		expect(changed).toHaveBeenCalledWith('name');
+	});
+
+	it('keeps unknown server validation codes in the generic save alert', async () => {
+		const fixture = TestBed.createComponent(ApartmentForm);
+		fixture.componentRef.setInput('saveError', 'Veuillez corriger les champs signalés.');
+		fixture.componentRef.setInput('saveFieldErrors', [{ field: 'name', code: 'unknown' }]);
+		fixture.detectChanges();
+		await fixture.whenStable();
+		fixture.detectChanges();
+
+		expect(fixture.nativeElement.querySelector('.field-error')).toBeNull();
+		expect(fixture.nativeElement.querySelector('.alert-error').textContent).toContain(
+			'Veuillez corriger les champs signalés.',
+		);
+	});
+
 	it('emits a trimmed apartment draft when valid', () => {
 		const fixture = TestBed.createComponent(ApartmentForm);
 		const form = fixture.componentInstance;
diff --git a/frontend/src/app/components/apartment-form/apartment-form.ts b/frontend/src/app/components/apartment-form/apartment-form.ts
index 87e0d64..14c9903 100644
--- a/frontend/src/app/components/apartment-form/apartment-form.ts
+++ b/frontend/src/app/components/apartment-form/apartment-form.ts
@@ -13,9 +13,17 @@ import {
 } from '../../services/apartment.service';
 import { ApartmentLegalProfileForm } from '../apartment-legal-profile-form/apartment-legal-profile-form';
 import { PrivateAreaEditor } from '../private-area-editor/private-area-editor';
+import { FieldValidationError } from '../../services/http-error-message';
 
-const requiredFieldsError =
-	'Veuillez remplir tous les champs obligatoires (Nom, Adresse, Prix > 0).';
+const nameRequiredError = 'Le nom de l’appartement est obligatoire.';
+const addressRequiredError = 'L’adresse complète est obligatoire.';
+const purchasePriceError = 'Le prix d’acquisition doit être strictement positif.';
+type CoreField = 'name' | 'address' | 'purchasePrice';
+const serverErrorCodes: Record<CoreField, ReadonlySet<string>> = {
+	name: new Set(['not_blank']),
+	address: new Set(['not_blank']),
+	purchasePrice: new Set(['positive']),
+};
 
 @Component({
 	selector: 'app-apartment-form',
@@ -37,8 +45,10 @@ export class ApartmentForm {
 	readonly apartment = input<Apartment | null>(null);
 	readonly saving = input(false);
 	readonly saveError = input('');
+	readonly saveFieldErrors = input<FieldValidationError[]>([]);
 	readonly closed = output<void>();
 	readonly saved = output<Apartment>();
+	readonly fieldChanged = output<string>();
 
 	readonly apartmentModel = signal<Apartment>({
 		name: '',
@@ -50,10 +60,10 @@ export class ApartmentForm {
 	});
 
 	readonly apartmentForm = form(this.apartmentModel, (f) => {
-		required(f.name, { message: requiredFieldsError });
-		required(f.address, { message: requiredFieldsError });
-		required(f.purchasePrice, { message: requiredFieldsError });
-		min(f.purchasePrice, 1, { message: requiredFieldsError });
+		required(f.name, { message: nameRequiredError });
+		required(f.address, { message: addressRequiredError });
+		required(f.purchasePrice, { message: purchasePriceError });
+		min(f.purchasePrice, Number.MIN_VALUE, { message: purchasePriceError });
 		min(f.legalProfile.habitableSurface, 0, {
 			message: 'La surface habitable doit être positive ou nulle.',
 		});
@@ -87,7 +97,7 @@ export class ApartmentForm {
 			!this.apartmentModel().address.trim()
 		) {
 			const firstError = this.apartmentForm().errorSummary()[0];
-			this.error.set(firstError?.message ?? requiredFieldsError);
+			this.error.set(firstError?.message ?? this.coreFieldError() ?? nameRequiredError);
 			return;
 		}
 
@@ -106,6 +116,48 @@ export class ApartmentForm {
 		this.apartmentModel.update((apartment) => ({ ...apartment, privateAreas }));
 	}
 
+	nameError(): string {
+		return this.fieldError('name', nameRequiredError, this.apartmentForm.name().touched());
+	}
+
+	addressError(): string {
+		return this.fieldError(
+			'address',
+			addressRequiredError,
+			this.apartmentForm.address().touched(),
+		);
+	}
+
+	purchasePriceError(): string {
+		return this.fieldError(
+			'purchasePrice',
+			purchasePriceError,
+			this.apartmentForm.purchasePrice().touched(),
+		);
+	}
+
+	private coreFieldError(): string | null {
+		return this.nameError() || this.addressError() || this.purchasePriceError() || null;
+	}
+
+	private fieldError(path: CoreField, clientMessage: string, touched: boolean): string {
+		if (
+			touched &&
+			((path === 'name' && !this.apartmentModel().name.trim()) ||
+				(path === 'address' && !this.apartmentModel().address.trim()) ||
+				(path === 'purchasePrice' && this.apartmentModel().purchasePrice <= 0))
+		) {
+			return clientMessage;
+		}
+		return this.hasKnownServerError(path) ? clientMessage : '';
+	}
+
+	private hasKnownServerError(field: CoreField): boolean {
+		return this.saveFieldErrors().some(
+			(error) => error.field === field && serverErrorCodes[field].has(error.code),
+		);
+	}
+
 	private resetForm(apartment: Apartment | null): void {
 		this.apartmentModel.set({
 			id: apartment?.id,
diff --git a/frontend/src/app/components/apartments-page/apartments-page.html b/frontend/src/app/components/apartments-page/apartments-page.html
index abf7d4e..52edd42 100644
--- a/frontend/src/app/components/apartments-page/apartments-page.html
+++ b/frontend/src/app/components/apartments-page/apartments-page.html
@@ -15,6 +15,8 @@
 			[apartment]="editingApartment()"
 			[saving]="workspace.apartmentSaving(editingApartment()?.id)"
 			[saveError]="workspace.apartmentSaveError(editingApartment()?.id)"
+			[saveFieldErrors]="workspace.apartmentSaveFieldErrors(editingApartment()?.id)"
+			(fieldChanged)="workspace.clearApartmentSaveFieldError($event, editingApartment()?.id)"
 			(closed)="closeForm()"
 			(saved)="saveApartment($event)"
 		/>
diff --git a/frontend/src/app/components/apartments-page/apartments-page.spec.ts b/frontend/src/app/components/apartments-page/apartments-page.spec.ts
index 71050e4..4a271fb 100644
--- a/frontend/src/app/components/apartments-page/apartments-page.spec.ts
+++ b/frontend/src/app/components/apartments-page/apartments-page.spec.ts
@@ -14,7 +14,9 @@ describe('ApartmentsPage', () => {
 		apartmentLoadState: signal({ loaded: false, loading: true, error: '' }),
 		apartmentSaving: vi.fn(() => false),
 		apartmentSaveError: vi.fn(() => ''),
+		apartmentSaveFieldErrors: vi.fn(() => []),
 		clearApartmentSaveError: vi.fn(),
+		clearApartmentSaveFieldError: vi.fn(),
 		deletingApartmentIds: signal<ReadonlySet<string>>(new Set()),
 		apartmentDeleteErrors: signal<Record<string, string>>({}),
 		loadApartments: () => undefined,
diff --git a/frontend/src/app/services/http-error-message.spec.ts b/frontend/src/app/services/http-error-message.spec.ts
new file mode 100644
index 0000000..2388e3e
--- /dev/null
+++ b/frontend/src/app/services/http-error-message.spec.ts
@@ -0,0 +1,46 @@
+import { saveFailure } from './http-error-message';
+
+describe('saveFailure', () => {
+	const fallback = 'Impossible d’enregistrer cet appartement.';
+
+	it('keeps only the structured validation contract', () => {
+		expect(
+			saveFailure(
+				{
+					status: 400,
+					error: {
+						code: 'validation_failed',
+						errors: [{ field: 'name', code: 'not_blank' }],
+					},
+				},
+				fallback,
+			),
+		).toEqual({
+			message: 'Veuillez corriger les champs signalés.',
+			fieldErrors: [{ field: 'name', code: 'not_blank' }],
+		});
+	});
+
+	it('uses a safe fallback for unknown, network, and unexpected failures', () => {
+		expect(
+			saveFailure({ status: 500, error: { message: 'internal detail' } }, fallback),
+		).toEqual({
+			message: fallback,
+			fieldErrors: [],
+		});
+		expect(saveFailure({ status: 0 }, fallback)).toEqual({
+			message: fallback,
+			fieldErrors: [],
+		});
+		expect(saveFailure({}, fallback)).toEqual({ message: fallback, fieldErrors: [] });
+	});
+
+	it('keeps a safe conflict message', () => {
+		expect(
+			saveFailure(
+				{ status: 409, error: { message: 'Cet appartement est référencé.' } },
+				fallback,
+			),
+		).toEqual({ message: 'Cet appartement est référencé.', fieldErrors: [] });
+	});
+});
diff --git a/frontend/src/app/services/http-error-message.ts b/frontend/src/app/services/http-error-message.ts
index d599495..71f8679 100644
--- a/frontend/src/app/services/http-error-message.ts
+++ b/frontend/src/app/services/http-error-message.ts
@@ -1,3 +1,13 @@
+export interface FieldValidationError {
+	field: string;
+	code: string;
+}
+
+export interface SaveFailure {
+	message: string;
+	fieldErrors: FieldValidationError[];
+}
+
 export function httpErrorMessage(error: unknown, fallback: string): string {
 	return typeof error === 'object' &&
 		error !== null &&
@@ -9,3 +19,49 @@ export function httpErrorMessage(error: unknown, fallback: string): string {
 		? error.error.message
 		: fallback;
 }
+
+export function saveFailure(error: unknown, fallback: string): SaveFailure {
+	const validationErrors = validationErrorsFrom(error);
+	if (validationErrors) {
+		return {
+			message: 'Veuillez corriger les champs signalés.',
+			fieldErrors: validationErrors,
+		};
+	}
+
+	return {
+		message: isConflict(error) ? httpErrorMessage(error, fallback) : fallback,
+		fieldErrors: [],
+	};
+}
+
+function validationErrorsFrom(error: unknown): FieldValidationError[] | null {
+	if (
+		typeof error !== 'object' ||
+		error === null ||
+		!('error' in error) ||
+		typeof error.error !== 'object' ||
+		error.error === null ||
+		!('code' in error.error) ||
+		error.error.code !== 'validation_failed' ||
+		!('errors' in error.error) ||
+		!Array.isArray(error.error.errors)
+	) {
+		return null;
+	}
+
+	const fieldErrors = error.error.errors.filter(
+		(fieldError): fieldError is FieldValidationError =>
+			typeof fieldError === 'object' &&
+			fieldError !== null &&
+			'field' in fieldError &&
+			typeof fieldError.field === 'string' &&
+			'code' in fieldError &&
+			typeof fieldError.code === 'string',
+	);
+	return fieldErrors.length === error.error.errors.length ? fieldErrors : null;
+}
+
+function isConflict(error: unknown): error is { status: number } {
+	return typeof error === 'object' && error !== null && 'status' in error && error.status === 409;
+}
diff --git a/frontend/src/app/services/workspace-resource.ts b/frontend/src/app/services/workspace-resource.ts
index 4a6426c..a228d51 100644
--- a/frontend/src/app/services/workspace-resource.ts
+++ b/frontend/src/app/services/workspace-resource.ts
@@ -1,6 +1,6 @@
 import { signal } from '@angular/core';
 import { finalize, Observable } from 'rxjs';
-import { httpErrorMessage } from './http-error-message';
+import { FieldValidationError, httpErrorMessage, saveFailure } from './http-error-message';
 import { withoutRecordKey, withoutSetValue } from './immutable-state';
 
 export interface LoadState {
@@ -20,6 +20,7 @@ export class WorkspaceResource<T extends { id?: string }> {
 	readonly loadState = signal<LoadState>({ loaded: false, loading: false, error: '' });
 	readonly savingKeys = signal<ReadonlySet<string>>(new Set());
 	readonly saveErrors = signal<Record<string, string>>({});
+	readonly saveFieldErrors = signal<Record<string, FieldValidationError[]>>({});
 	readonly deletingIds = signal<ReadonlySet<string>>(new Set());
 	readonly deleteErrors = signal<Record<string, string>>({});
 	private revision = 0;
@@ -47,6 +48,7 @@ export class WorkspaceResource<T extends { id?: string }> {
 		if (this.savingKeys().has(key)) return;
 		this.savingKeys.update((keys) => new Set(keys).add(key));
 		this.saveErrors.update((errors) => withoutRecordKey(errors, key));
+		this.saveFieldErrors.update((errors) => withoutRecordKey(errors, key));
 		request
 			.pipe(finalize(() => this.savingKeys.update((keys) => withoutSetValue(keys, key))))
 			.subscribe({
@@ -55,8 +57,14 @@ export class WorkspaceResource<T extends { id?: string }> {
 					onSuccess?.();
 					this.load();
 				},
-				error: () =>
-					this.saveErrors.update((errors) => ({ ...errors, [key]: this.messages.save })),
+				error: (error) => {
+					const failure = saveFailure(error, this.messages.save);
+					this.saveErrors.update((errors) => ({ ...errors, [key]: failure.message }));
+					this.saveFieldErrors.update((errors) => ({
+						...errors,
+						[key]: failure.fieldErrors,
+					}));
+				},
 			});
 	}
 
@@ -95,6 +103,17 @@ export class WorkspaceResource<T extends { id?: string }> {
 
 	clearSaveError(key: string): void {
 		this.saveErrors.update((errors) => withoutRecordKey(errors, key));
+		this.saveFieldErrors.update((errors) => withoutRecordKey(errors, key));
+	}
+
+	clearSaveFieldError(key: string, field: string): void {
+		const fieldErrors = this.saveFieldErrors()[key];
+		if (!fieldErrors?.some((error) => error.field === field)) return;
+		const remaining = fieldErrors.filter((error) => error.field !== field);
+		this.saveFieldErrors.update((errors) =>
+			remaining.length ? { ...errors, [key]: remaining } : withoutRecordKey(errors, key),
+		);
+		if (!remaining.length) this.saveErrors.update((errors) => withoutRecordKey(errors, key));
 	}
 
 	private handleLoadError(revision: number): void {
diff --git a/frontend/src/app/services/workspace.service.spec.ts b/frontend/src/app/services/workspace.service.spec.ts
index f9ee36f..53159a7 100644
--- a/frontend/src/app/services/workspace.service.spec.ts
+++ b/frontend/src/app/services/workspace.service.spec.ts
@@ -298,6 +298,36 @@ describe('WorkspaceService', () => {
 		expect(service.apartmentSaving(secondApartment.id)).toBe(true);
 	});
 
+	it('preserves validation fields and clears only the corrected apartment field', () => {
+		apartments.updateApartment.mockReturnValueOnce(
+			throwError(() => ({
+				status: 400,
+				error: {
+					code: 'validation_failed',
+					errors: [
+						{ field: 'name', code: 'not_blank' },
+						{ field: 'address', code: 'not_blank' },
+					],
+				},
+			})),
+		);
+		const service = TestBed.inject(WorkspaceService);
+
+		service.saveApartment(apartment, apartment.id);
+
+		expect(service.apartmentSaveFieldErrors(apartment.id)).toEqual([
+			{ field: 'name', code: 'not_blank' },
+			{ field: 'address', code: 'not_blank' },
+		]);
+		service.clearApartmentSaveFieldError('name', apartment.id);
+		expect(service.apartmentSaveFieldErrors(apartment.id)).toEqual([
+			{ field: 'address', code: 'not_blank' },
+		]);
+		expect(service.apartmentSaveError(apartment.id)).toBe(
+			'Veuillez corriger les champs signalés.',
+		);
+	});
+
 	it('removes a confirmed deletion locally before reconciliation finishes', () => {
 		const deleteResponse = new Subject<void>();
 		const refreshResponse = new Subject<(typeof apartment)[]>();
diff --git a/frontend/src/app/services/workspace.service.ts b/frontend/src/app/services/workspace.service.ts
index fbd467d..627d52d 100644
--- a/frontend/src/app/services/workspace.service.ts
+++ b/frontend/src/app/services/workspace.service.ts
@@ -12,6 +12,7 @@ import { RentPayment, RentPaymentService } from './rent-payment.service';
 import { Tenant, TenantAttachment, TenantService } from './tenant.service';
 import { TenantAttachmentTransferService } from './tenant-attachment-transfer.service';
 import { WorkspaceResource } from './workspace-resource';
+import { FieldValidationError } from './http-error-message';
 
 const newResourceKey = 'new';
 
@@ -108,10 +109,18 @@ export class WorkspaceService {
 		return this.apartmentResource.saveErrors()[this.resourceKey(id)] ?? '';
 	}
 
+	apartmentSaveFieldErrors(id?: string): FieldValidationError[] {
+		return this.apartmentResource.saveFieldErrors()[this.resourceKey(id)] ?? [];
+	}
+
 	clearApartmentSaveError(id?: string): void {
 		this.apartmentResource.clearSaveError(this.resourceKey(id));
 	}
 
+	clearApartmentSaveFieldError(field: string, id?: string): void {
+		this.apartmentResource.clearSaveFieldError(this.resourceKey(id), field);
+	}
+
 	deleteApartment(id: string): void {
 		this.requestConfirmation(
 			{