diff --git a/docs/http-api.rst b/docs/http-api.rst
index 215558f3..49023dd6 100644
--- a/docs/http-api.rst
+++ b/docs/http-api.rst
@@ -211,10 +211,14 @@ buttons for ``exclusive``/``threshold``, a single checkbox for ``boolean``
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 What this instance accepts for a new point: the fields of its location model (all of them
-except the server-assigned ``uuid``), the allowed values per category, the reportable
-issue types, and the photo limits. This is how a client learns what to put in
-``/api/suggest-new-point``'s ``location`` payload rather than assuming — it is the same
-schema the built-in suggest form is generated from.
+except the server-assigned ``uuid``), the reportable issue types, and the photo limits.
+This is how a client learns what to put in ``/api/suggest-new-point``'s ``location``
+payload rather than assuming — it is the same schema the built-in suggest form is
+generated from.
+
+A field's own allowed values are part of its schema, reported as ``enum_items``. For the
+same values with translated labels, ready to render a filter panel, use
+``/api/categories-full`` above.
 
 ``GET /api/languages``
 ~~~~~~~~~~~~~~~~~~~~~~
diff --git a/frontend/.eslintrc.json b/frontend/.eslintrc.json
index 26e4203e..b9d45efa 100644
--- a/frontend/.eslintrc.json
+++ b/frontend/.eslintrc.json
@@ -4,7 +4,8 @@
         "plugin:react/recommended",
         "plugin:prettier/recommended",
         "airbnb",
-        "prettier"],
+        "prettier",
+        "plugin:react-hooks/recommended"],
     "plugins": ["react", "prettier", "eslint-plugin-react", "eslint-plugin-react-hooks"],
     "parser": "@babel/eslint-parser",
     "parserOptions": {
diff --git a/frontend/src/components/Categories/CategoriesContext.jsx b/frontend/src/components/Categories/CategoriesContext.jsx
deleted file mode 100644
index 624bbce4..00000000
--- a/frontend/src/components/Categories/CategoriesContext.jsx
+++ /dev/null
@@ -1,97 +0,0 @@
-import React, { useState, useContext, createContext, useMemo, useEffect, useCallback } from 'react';
-import PropTypes from 'prop-types';
-import httpService from '../../services/http/httpService';
-
-/**
- * React Context for managing categories state across the application.
- * Provides categories data and setter function to all child components.
- */
-const CategoriesContext = createContext();
-CategoriesContext.displayName = 'CategoriesContext';
-
-/**
- * Provider component that wraps the application to provide categories context.
- * Fetches the category definitions once and shares them, alongside the currently
- * selected filter values, with every child component.
- *
- * @param {Object} props - Component props
- * @param {React.ReactNode} props.children - Child components that will have access to categories context
- * @returns {React.ReactElement} Context provider with categories state
- */
-export const CategoriesProvider = ({ children }) => {
-    const [categories, setCategories] = useState({});
-    const [isInitialized, setIsInitialized] = useState(false);
-    const [categoriesData, setCategoriesData] = useState([]);
-    const [isLoading, setIsLoading] = useState(true);
-    const [hasError, setHasError] = useState(false);
-
-    const fetchCategories = useCallback(async () => {
-        setIsLoading(true);
-        setHasError(false);
-        try {
-            const { categories: fetchedCategories, defaultChecked } =
-                await httpService.getCategoriesData();
-            setCategoriesData(fetchedCategories);
-            if (Object.keys(defaultChecked).length > 0) {
-                setCategories(defaultChecked);
-            }
-            setIsInitialized(true);
-        } catch (error) {
-            console.error('Failed to load categories:', error);
-            // Establish an explicit fallback (no filters) instead of silently
-            // signaling initialization with unknown/missing category data.
-            setCategoriesData([]);
-            setHasError(true);
-        } finally {
-            setIsLoading(false);
-        }
-    }, []);
-
-    useEffect(() => {
-        fetchCategories();
-    }, [fetchCategories]);
-
-    const value = useMemo(
-        () => ({
-            categories,
-            setCategories,
-            isInitialized,
-            setIsInitialized,
-            categoriesData,
-            isLoading,
-            hasError,
-            refetchCategories: fetchCategories,
-        }),
-        [categories, isInitialized, categoriesData, isLoading, hasError, fetchCategories],
-    );
-
-    return <CategoriesContext.Provider value={value}>{children}</CategoriesContext.Provider>;
-};
-
-CategoriesProvider.propTypes = {
-    children: PropTypes.node.isRequired,
-};
-
-/**
- * Custom hook to access categories context.
- * Must be used within a CategoriesProvider component.
- *
- * @throws {Error} If used outside of CategoriesProvider
- * @returns {Object} Object containing categories map and setCategories function
- * @returns {Object} return.categories - Currently selected filter values keyed by category
- * @returns {Function} return.setCategories - Function to update categories
- * @returns {boolean} return.isInitialized - True once initial filter state (including
- *   default-checked options) has been loaded, so consumers can wait before fetching
- * @returns {Function} return.setIsInitialized - Marks the initial filter state as loaded
- * @returns {Array} return.categoriesData - Category definitions fetched from the backend
- * @returns {boolean} return.isLoading - True while the category definitions are in flight
- * @returns {boolean} return.hasError - True if fetching the category definitions failed
- * @returns {Function} return.refetchCategories - Retries the category definitions fetch
- */
-export const useCategories = () => {
-    const context = useContext(CategoriesContext);
-    if (!context) {
-        throw new Error('useCategories must be used within a CategoriesProvider');
-    }
-    return context;
-};
diff --git a/frontend/src/components/FiltersForm/FiltersForm.jsx b/frontend/src/components/FiltersForm/FiltersForm.jsx
index 3b9ab257..9ef89f1e 100644
--- a/frontend/src/components/FiltersForm/FiltersForm.jsx
+++ b/frontend/src/components/FiltersForm/FiltersForm.jsx
@@ -2,7 +2,8 @@ import React from 'react';
 import styled, { keyframes } from 'styled-components';
 import { useTranslation } from 'react-i18next';
 import { Tooltip } from '@mui/material';
-import { useCategories } from '../Categories/CategoriesContext';
+import { useDeploymentData } from '../../context/DeploymentDataContext';
+import { useFilters } from '../../context/FiltersContext';
 import FiltersTooltip from './FiltersTooltip';
 
 const shimmer = keyframes`
@@ -241,20 +242,15 @@ const LoadingSkeleton = () => (
 
 const FiltersForm = () => {
     const { t } = useTranslation();
-    const {
-        categories: selectedFilters,
-        setCategories,
-        categoriesData,
-        isLoading,
-        hasError,
-        refetchCategories,
-    } = useCategories();
+    const { categoriesData, categoriesLoading, categoriesError, refetchCategories } =
+        useDeploymentData();
+    const { selectedFilters, setSelectedFilters } = useFilters();
 
     const handleCheckboxChange = event => {
         const { value, checked } = event.target;
         const { category } = event.target.dataset;
 
-        setCategories(prevSelectedFilters => {
+        setSelectedFilters(prevSelectedFilters => {
             const newSelectedFilters = { ...prevSelectedFilters };
 
             if (checked) {
@@ -275,14 +271,14 @@ const FiltersForm = () => {
         const { value } = event.target;
         const { category } = event.target.dataset;
 
-        setCategories(prevSelectedFilters => ({
+        setSelectedFilters(prevSelectedFilters => ({
             ...prevSelectedFilters,
             [category]: [value],
         }));
     };
 
     const handleClearFilters = () => {
-        setCategories({});
+        setSelectedFilters({});
     };
 
     const renderModeBadge = mode => {
@@ -423,7 +419,7 @@ const FiltersForm = () => {
         );
     }
 
-    if (isLoading) {
+    if (categoriesLoading) {
         return (
             <form>
                 <LoadingSkeleton />
@@ -431,7 +427,7 @@ const FiltersForm = () => {
         );
     }
 
-    if (hasError) {
+    if (categoriesError) {
         return (
             <form>
                 <ErrorMessage>{t('loadFiltersError')}</ErrorMessage>
diff --git a/frontend/src/components/Map/Map.jsx b/frontend/src/components/Map/Map.jsx
index ba009829..34b353e2 100644
--- a/frontend/src/components/Map/Map.jsx
+++ b/frontend/src/components/Map/Map.jsx
@@ -3,13 +3,16 @@ import React from 'react';
 import { createPortal } from 'react-dom';
 import FiltersForm from '../FiltersForm/FiltersForm';
 import MapComponent from './MapComponent';
-import { CategoriesProvider } from '../Categories/CategoriesContext';
+import { DeploymentDataProvider } from '../../context/DeploymentDataContext';
+import { FiltersProvider } from '../../context/FiltersContext';
 import AppToaster from '../common/AppToaster';
 
 /**
  * Wrapper component that renders the map and filters form into their respective DOM placeholders.
  * Uses React portals to render components into pre-existing DOM elements outside the React tree.
- * Wraps both components with CategoriesProvider for shared filter state management.
+ * Wraps both components with DeploymentDataProvider, which fetches this deployment's
+ * fixed data (category definitions and the new-point schema) once for every consumer,
+ * and with FiltersProvider, which owns the one thing that changes as the app runs.
  *
  * @returns {React.ReactElement|null} Portals for FiltersForm and MapComponent, or null if placeholders not found
  */
@@ -23,11 +26,13 @@ const MapWrap = () => {
     }
 
     return (
-        <CategoriesProvider>
-            <AppToaster />
-            {createPortal(<FiltersForm />, filtersPlaceholder)}
-            {createPortal(<MapComponent />, mapPlaceholder)}
-        </CategoriesProvider>
+        <DeploymentDataProvider>
+            <FiltersProvider>
+                <AppToaster />
+                {createPortal(<FiltersForm />, filtersPlaceholder)}
+                {createPortal(<MapComponent />, mapPlaceholder)}
+            </FiltersProvider>
+        </DeploymentDataProvider>
     );
 };
 
diff --git a/frontend/src/components/Map/components/AccessibilityTable.jsx b/frontend/src/components/Map/components/AccessibilityTable.jsx
index 3961669f..062e02e1 100644
--- a/frontend/src/components/Map/components/AccessibilityTable.jsx
+++ b/frontend/src/components/Map/components/AccessibilityTable.jsx
@@ -12,7 +12,7 @@ import { IconButton } from '@mui/material';
 import PropTypes from 'prop-types';
 import httpService from '../../../services/http/httpService';
 import FieldRenderer from '../../MarkerPopup/FieldRenderer';
-import { useCategories } from '../../Categories/CategoriesContext';
+import { useFilters } from '../../../context/FiltersContext';
 
 /**
  * Accessibility table component that displays location data in a tabular format.
@@ -28,7 +28,7 @@ import { useCategories } from '../../Categories/CategoriesContext';
  * @returns {React.ReactElement} Table container with location data and back button
  */
 const AccessibilityTable = ({ userPosition, setIsAccessibilityTableOpen }) => {
-    const { categories } = useCategories();
+    const { selectedFilters } = useFilters();
     const { t } = useTranslation();
 
     const [data, setData] = useState(null);
@@ -37,11 +37,11 @@ const AccessibilityTable = ({ userPosition, setIsAccessibilityTableOpen }) => {
 
     useEffect(() => {
         httpService
-            .getLocationsData(userPosition.lat, userPosition.lng, categories)
+            .getLocationsData(userPosition.lat, userPosition.lng, selectedFilters)
             .then(places => {
                 setData(places);
             });
-    }, [categories, userPosition]);
+    }, [selectedFilters, userPosition]);
 
     useEffect(() => {
         if (!data) {
diff --git a/frontend/src/components/Map/components/Markers.jsx b/frontend/src/components/Map/components/Markers.jsx
index 038df6e5..a3dd3216 100644
--- a/frontend/src/components/Map/components/Markers.jsx
+++ b/frontend/src/components/Map/components/Markers.jsx
@@ -4,7 +4,7 @@ import { useMap } from 'react-leaflet';
 import MarkerClusterGroup from 'react-leaflet-cluster';
 import httpService from '../../../services/http/httpService';
 import MarkerPopup from '../../MarkerPopup/MarkerPopup';
-import { useCategories } from '../../Categories/CategoriesContext';
+import { useFilters } from '../../../context/FiltersContext';
 import ClusterMarker from '../../MarkerPopup/ClusterMarker';
 
 /**
@@ -44,7 +44,7 @@ const getMarkers = locations => {
  * @returns {React.ReactElement|Array} MarkerClusterGroup containing location markers, or empty array while loading
  */
 const Markers = ({ onLoadingChange = null }) => {
-    const { categories, isInitialized } = useCategories();
+    const { selectedFilters, isInitialized } = useFilters();
     const [markers, setMarkers] = useState([]);
     const [areMarkersLoaded, setAreMarkersLoaded] = useState(false);
     const map = useMap();
@@ -59,7 +59,7 @@ const Markers = ({ onLoadingChange = null }) => {
         const fetchMarkers = async () => {
             let locations;
             try {
-                locations = await httpService.getLocations(categories);
+                locations = await httpService.getLocations(selectedFilters);
             } catch (error) {
                 console.error('Failed to load locations:', error);
                 setMarkers([]);
@@ -100,7 +100,7 @@ const Markers = ({ onLoadingChange = null }) => {
         return () => {
             setMarkers([]);
         };
-    }, [categories, isInitialized]);
+    }, [selectedFilters, isInitialized]);
 
     useEffect(() => {
         const mapContainer = map.getContainer();
diff --git a/frontend/src/components/Map/components/SuggestNewPointDialog.jsx b/frontend/src/components/Map/components/SuggestNewPointDialog.jsx
index 47a7e41f..54f1d5b6 100644
--- a/frontend/src/components/Map/components/SuggestNewPointDialog.jsx
+++ b/frontend/src/components/Map/components/SuggestNewPointDialog.jsx
@@ -27,7 +27,7 @@ import { useTranslation } from 'react-i18next';
 import imageCompression from 'browser-image-compression';
 import getCsrfToken from '../../../utils/csrf';
 import { useLocation } from '../context/LocationContext';
-import { useCategories } from '../../Categories/CategoriesContext';
+import { useDeploymentData } from '../../../context/DeploymentDataContext';
 import toast from '../../../utils/toast';
 
 // Map a category's options to a { key: translation } object.
@@ -52,10 +52,7 @@ const buildCategoryTranslations = categoriesData => {
 
     categoriesData.forEach(({ categoryKey, categoryName, options: categoryOptions }) => {
         fieldNames[categoryKey] = categoryName;
-
-        if (categoryOptions?.length) {
-            options[categoryKey] = mapCategoryOptions(categoryOptions);
-        }
+        options[categoryKey] = mapCategoryOptions(categoryOptions ?? []);
     });
 
     return { fieldNames, options };
@@ -107,17 +104,19 @@ const useScrollToTop = trigger => {
 };
 
 /**
- * Dialog form for suggesting a new map point. Fields are generated dynamically from
- * window.LOCATION_SCHEMA and include the user's position, an optional photo, and every
- * obligatory location attribute defined by the backend.
+ * The dialog and its schema-driven form, mounted by SuggestNewPointDialog only once
+ * the location schema has loaded.
  *
- * @param {{open: boolean, onClose: () => void}} props
+ * Its inputs are generated from the schema's obligatory_fields, so mounting earlier
+ * would seed a form with no fields and force a rebuild when the schema arrived.
+ *
+ * @param {{open: boolean, onClose: () => void, locationSchema: Object}} props
  * @returns {React.ReactElement} Dialog with the new point suggestion form
  */
-const SuggestNewPointDialog = ({ open, onClose }) => {
+const SuggestNewPointForm = ({ open, onClose, locationSchema }) => {
     const { t } = useTranslation();
     const { userPosition, requestLocationWithFeedback } = useLocation();
-    const { categoriesData } = useCategories();
+    const { categoriesData } = useDeploymentData();
     const [photo, setPhoto] = useState(null);
     const [photoURL, setPhotoURL] = useState(null);
     // Shown inline in the dialog: a toast here can end up behind it.
@@ -140,10 +139,6 @@ const SuggestNewPointDialog = ({ open, onClose }) => {
         }
     }, [open]);
 
-    const locationSchema = globalThis.LOCATION_SCHEMA || {
-        obligatory_fields: [],
-        categories: {},
-    };
     const {
         allowed_extensions: allowedPhotoExtensions = [],
         allowed_mime_types: allowedPhotoMimeTypes = [],
@@ -297,8 +292,11 @@ const SuggestNewPointDialog = ({ open, onClose }) => {
 
     // Render form field based on field type and whether it's a category
     const renderFormField = (fieldName, fieldType) => {
-        const isCategory = fieldName in locationSchema.categories;
-        const categoryOptions = isCategory ? locationSchema.categories[fieldName] : [];
+        // Values and labels both come from the category definitions, so an option can
+        // never render with a label this component has no entry for.
+        const optionLabels = categoryTranslations.options[fieldName];
+        const isCategory = Boolean(optionLabels);
+        const categoryOptions = isCategory ? Object.keys(optionLabels) : [];
         const fieldLabel = getFieldLabel(fieldName);
 
         if (fieldType === 'list' && isCategory) {
@@ -309,7 +307,7 @@ const SuggestNewPointDialog = ({ open, onClose }) => {
                     <Select
                         labelId={`${fieldName}-label`}
                         multiple
-                        value={formFields[fieldName] || []}
+                        value={formFields[fieldName]}
                         onChange={handleFieldChange(fieldName)}
                         input={<OutlinedInput label={fieldLabel} />}
                         renderValue={selected => getSelectedDisplay(fieldName, selected)}
@@ -332,7 +330,7 @@ const SuggestNewPointDialog = ({ open, onClose }) => {
                     <InputLabel id={`${fieldName}-label`}>{fieldLabel}</InputLabel>
                     <Select
                         labelId={`${fieldName}-label`}
-                        value={formFields[fieldName] || ''}
+                        value={formFields[fieldName]}
                         onChange={handleFieldChange(fieldName)}
                         data-testid={`${fieldName}-select`}
                     >
@@ -350,7 +348,7 @@ const SuggestNewPointDialog = ({ open, onClose }) => {
             <TextField
                 key={fieldName}
                 label={fieldLabel}
-                value={formFields[fieldName] || ''}
+                value={formFields[fieldName]}
                 onChange={handleFieldChange(fieldName)}
                 fullWidth
                 margin="dense"
@@ -437,6 +435,62 @@ const SuggestNewPointDialog = ({ open, onClose }) => {
     );
 };
 
+SuggestNewPointForm.propTypes = {
+    open: PropTypes.bool.isRequired,
+    onClose: PropTypes.func.isRequired,
+    // Only the parts this form reads; the schema itself carries more.
+    locationSchema: PropTypes.shape({
+        obligatory_fields: PropTypes.arrayOf(PropTypes.arrayOf(PropTypes.string)),
+        photo: PropTypes.shape({
+            allowed_extensions: PropTypes.arrayOf(PropTypes.string),
+            allowed_mime_types: PropTypes.arrayOf(PropTypes.string),
+            max_size_bytes: PropTypes.number,
+        }),
+    }).isRequired,
+};
+
+/**
+ * Dialog for suggesting a new map point.
+ *
+ * The form's fields are generated from the deployment's location schema, so there is
+ * nothing to render until that has arrived - holding the form back until then is what
+ * lets it build its fields once, instead of rebuilding them when the schema lands. If
+ * the schema could not be fetched at all, this says so instead of showing a form that
+ * has no fields to fill and could never be submitted.
+ *
+ * @param {{open: boolean, onClose: () => void}} props
+ * @returns {React.ReactElement|null} The form, a retry prompt, or null while it loads
+ */
+const SuggestNewPointDialog = ({ open, onClose }) => {
+    const { t } = useTranslation();
+    const { locationSchema, schemaError, refetchLocationSchema } = useDeploymentData();
+
+    // Without the schema there are no fields to fill, so offering the form anyway would
+    // only produce a submission the backend is bound to reject. Say so and offer a retry.
+    if (schemaError) {
+        return (
+            <Dialog open={open} onClose={onClose}>
+                <DialogTitle>{t('suggestNewPointDialogTitle')}</DialogTitle>
+                <DialogContent>
+                    <Alert severity="error">{t('loadSuggestFormError')}</Alert>
+                </DialogContent>
+                <DialogActions>
+                    <Button onClick={onClose}>{t('cancel')}</Button>
+                    <Button variant="contained" onClick={refetchLocationSchema}>
+                        {t('retry')}
+                    </Button>
+                </DialogActions>
+            </Dialog>
+        );
+    }
+
+    if (!locationSchema) {
+        return null;
+    }
+
+    return <SuggestNewPointForm open={open} onClose={onClose} locationSchema={locationSchema} />;
+};
+
 SuggestNewPointDialog.propTypes = {
     open: PropTypes.bool.isRequired,
     onClose: PropTypes.func.isRequired,
diff --git a/frontend/src/components/MarkerPopup/ClusterMarker.jsx b/frontend/src/components/MarkerPopup/ClusterMarker.jsx
index d247c69a..bc0b112f 100644
--- a/frontend/src/components/MarkerPopup/ClusterMarker.jsx
+++ b/frontend/src/components/MarkerPopup/ClusterMarker.jsx
@@ -32,6 +32,9 @@ const ClusterMarker = ({ cluster }) => {
                 iconSize: [30, 30],
                 iconAnchor: [15, 15],
             }),
+        // ClusterMarkerIcon renders cluster_count alone, so depending on the whole
+        // cluster would rebuild the icon on every new object identity for nothing.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
         [cluster.cluster_count],
     );
 
diff --git a/frontend/src/components/MarkerPopup/ReportProblemForm.jsx b/frontend/src/components/MarkerPopup/ReportProblemForm.jsx
index 9a2405b0..6c46004a 100644
--- a/frontend/src/components/MarkerPopup/ReportProblemForm.jsx
+++ b/frontend/src/components/MarkerPopup/ReportProblemForm.jsx
@@ -4,6 +4,7 @@ import styled from 'styled-components';
 import PropTypes from 'prop-types';
 import { useTranslation } from 'react-i18next';
 import getCsrfToken from '../../utils/csrf';
+import { useDeploymentData } from '../../context/DeploymentDataContext';
 
 /**
  * Styled form component with flexbox column layout.
@@ -100,6 +101,28 @@ const SubmitButton = styled.input`
 /**
  * Styled success message component.
  */
+const ErrorMessage = styled.div`
+    padding: 12px 15px;
+    background-color: #fdecea;
+    border: 1px solid #f5c6cb;
+    border-radius: 8px;
+    color: #b71c1c;
+    font-size: 13px;
+    margin: 10px 15px;
+    text-align: center;
+`;
+
+const RetryButton = styled.button`
+    margin-top: 8px;
+    font-size: 13px;
+    padding: 6px 12px;
+    border-radius: 6px;
+    border: 1px solid currentColor;
+    background: transparent;
+    color: inherit;
+    cursor: pointer;
+`;
+
 const SuccessMessage = styled.div`
     padding: 12px 15px;
     background-color: #e8f5e9;
@@ -123,14 +146,14 @@ const SuccessMessage = styled.div`
  */
 /**
  * Get issue type options from backend configuration or fall back to defaults.
- * Dynamic types come from LOCATION_SCHEMA.reported_issue_types (configured per deployment).
+ * Dynamic types come from the deployment's location schema (reported_issue_types).
  * Default types are kept for backward compatibility with backends that don't provide this field (until 2.0.0).
  *
  * @param {Function} t - Translation function
+ * @param {Array<{value: string, label: string}>} [dynamicTypes] - Types this deployment declares
  * @returns {Array<{value: string, label: string}>} Issue type options (without "other", which is always appended)
  */
-const getIssueTypeOptions = t => {
-    const dynamicTypes = globalThis.LOCATION_SCHEMA?.reported_issue_types;
+const getIssueTypeOptions = (t, dynamicTypes) => {
     if (dynamicTypes && dynamicTypes.length > 0) {
         return dynamicTypes.map(type => ({
             value: type.value,
@@ -147,12 +170,15 @@ const getIssueTypeOptions = t => {
 
 const ReportProblemForm = ({ placeId }) => {
     const { t } = useTranslation();
+    const { locationSchema, schemaError, refetchLocationSchema } = useDeploymentData();
     const [problem, setProblem] = useState('');
     const [problemType, setProblemType] = useState('');
     const [isSubmitted, setIsSubmitted] = useState(false);
     const [responseMessage, setResponseMessage] = useState('');
 
-    const issueTypeOptions = getIssueTypeOptions(t);
+    // Only reached once the schema is known, so a loaded schema declaring no issue
+    // types is the one case that falls back to the legacy defaults.
+    const issueTypeOptions = getIssueTypeOptions(t, locationSchema?.reported_issue_types);
 
     const handleSubmit = async event => {
         event.preventDefault();
@@ -180,6 +206,26 @@ const ReportProblemForm = ({ placeId }) => {
         return <SuccessMessage>{responseMessage}</SuccessMessage>;
     }
 
+    // This deployment's own issue types are the only ones it is guaranteed to accept, so
+    // the form is withheld until they are known: the legacy fallbacks are not a stand-in
+    // for them. A failed fetch has to say so, or the form would just never appear.
+    if (schemaError) {
+        return (
+            <ErrorMessage>
+                {t('loadReportFormError')}
+                <div>
+                    <RetryButton type="button" onClick={refetchLocationSchema}>
+                        {t('retry')}
+                    </RetryButton>
+                </div>
+            </ErrorMessage>
+        );
+    }
+
+    if (!locationSchema) {
+        return null;
+    }
+
     return (
         <Form onSubmit={handleSubmit}>
             <Label>
diff --git a/frontend/src/context/DeploymentDataContext.jsx b/frontend/src/context/DeploymentDataContext.jsx
new file mode 100644
index 00000000..201a810c
--- /dev/null
+++ b/frontend/src/context/DeploymentDataContext.jsx
@@ -0,0 +1,145 @@
+import React, { createContext, useCallback, useContext, useEffect, useMemo, useState } from 'react';
+import PropTypes from 'prop-types';
+import httpService from '../services/http/httpService';
+
+/**
+ * React Context for everything this deployment is configured with: the category
+ * definitions and the schema a new point has to satisfy.
+ *
+ * None of it changes while the app runs - the backend reads it from config and from a
+ * map_config document nothing in the app ever writes - so it is fetched once here and
+ * treated as constant afterwards. The one thing that does change, the user's own filter
+ * selections, lives in FiltersContext instead, so toggling a filter cannot re-render
+ * the consumers of this data.
+ */
+const DeploymentDataContext = createContext();
+DeploymentDataContext.displayName = 'DeploymentDataContext';
+
+// The shape the schema is merged onto, so every key is present whatever the instance
+// returns and no consumer has to guard each one. This is a floor for a schema that has
+// arrived - "not arrived yet" is null, and consumers wait for that rather than render
+// against an empty skeleton.
+/* eslint-disable camelcase -- these are the API's own field names */
+const EMPTY_SCHEMA = {
+    obligatory_fields: [],
+    fields: {},
+    reported_issue_types: [],
+    photo: {},
+};
+/* eslint-enable camelcase */
+
+/**
+ * Provider that fetches this deployment's fixed data once and shares it with every child.
+ *
+ * @param {Object} props - Component props
+ * @param {React.ReactNode} props.children - Components that need the deployment data
+ * @return {React.ReactElement} Context provider with the deployment data
+ */
+export const DeploymentDataProvider = ({ children }) => {
+    const [categoriesData, setCategoriesData] = useState([]);
+    const [defaultChecked, setDefaultChecked] = useState({});
+    const [categoriesLoading, setCategoriesLoading] = useState(true);
+    const [categoriesError, setCategoriesError] = useState(false);
+
+    // Held as null rather than an empty skeleton so consumers can tell "not here yet"
+    // from "here and empty", and wait rather than build a form out of nothing.
+    const [locationSchema, setLocationSchema] = useState(null);
+    const [schemaError, setSchemaError] = useState(false);
+
+    const fetchCategories = useCallback(async () => {
+        setCategoriesLoading(true);
+        setCategoriesError(false);
+        try {
+            const { categories, defaultChecked: fetchedDefaults } =
+                await httpService.getCategoriesData();
+            setCategoriesData(categories);
+            setDefaultChecked(fetchedDefaults);
+        } catch (error) {
+            console.error('Failed to load categories:', error);
+            // Establish an explicit fallback (no filters) instead of silently
+            // signaling initialization with unknown/missing category data.
+            setCategoriesData([]);
+            setCategoriesError(true);
+        } finally {
+            setCategoriesLoading(false);
+        }
+    }, []);
+
+    const fetchLocationSchema = useCallback(async () => {
+        setSchemaError(false);
+        try {
+            setLocationSchema({ ...EMPTY_SCHEMA, ...(await httpService.getLocationSchema()) });
+        } catch (error) {
+            console.error('Failed to load location schema:', error);
+            // Left null: a failed request must not read as a resolved schema, or the
+            // suggest form renders with no fields and can never be submitted. Consumers
+            // tell the two apart by schemaError - null alone only means "not yet".
+            setSchemaError(true);
+        }
+    }, []);
+
+    // Tracked separately so one failure does not deny consumers the other: the filters
+    // panel is still usable without the schema, and the forms without the categories.
+    useEffect(() => {
+        fetchCategories();
+    }, [fetchCategories]);
+
+    useEffect(() => {
+        fetchLocationSchema();
+    }, [fetchLocationSchema]);
+
+    const value = useMemo(
+        () => ({
+            categoriesData,
+            defaultChecked,
+            categoriesLoading,
+            categoriesError,
+            refetchCategories: fetchCategories,
+            locationSchema,
+            schemaError,
+            refetchLocationSchema: fetchLocationSchema,
+        }),
+        [
+            categoriesData,
+            defaultChecked,
+            categoriesLoading,
+            categoriesError,
+            fetchCategories,
+            locationSchema,
+            schemaError,
+            fetchLocationSchema,
+        ],
+    );
+
+    return (
+        <DeploymentDataContext.Provider value={value}>{children}</DeploymentDataContext.Provider>
+    );
+};
+
+DeploymentDataProvider.propTypes = {
+    children: PropTypes.node.isRequired,
+};
+
+/**
+ * Access this deployment's fixed configuration.
+ *
+ * Must be used within a DeploymentDataProvider.
+ *
+ * - categoriesData: category definitions fetched from the backend
+ * - defaultChecked: options pre-selected by the deployment, keyed by category
+ * - categoriesLoading / categoriesError: state of the category definitions fetch
+ * - refetchCategories: retries that fetch
+ * - locationSchema: schema for a new point, null until it arrives (and if it failed)
+ * - schemaError: true if fetching the location schema failed
+ * - refetchLocationSchema: retries that fetch
+ *
+ * @throws {Error} If used outside of DeploymentDataProvider
+ * @return {Object} The deployment data described above
+ */
+export const useDeploymentData = () => {
+    const context = useContext(DeploymentDataContext);
+    if (!context) {
+        throw new Error('useDeploymentData must be used within a DeploymentDataProvider');
+    }
+    return context;
+};
diff --git a/frontend/src/context/FiltersContext.jsx b/frontend/src/context/FiltersContext.jsx
new file mode 100644
index 00000000..47abb7dc
--- /dev/null
+++ b/frontend/src/context/FiltersContext.jsx
@@ -0,0 +1,71 @@
+import React, { createContext, useContext, useEffect, useMemo, useState } from 'react';
+import PropTypes from 'prop-types';
+import { useDeploymentData } from './DeploymentDataContext';
+
+/**
+ * React Context for the filter values the user currently has selected.
+ *
+ * This is the only map state that changes while the app runs, which is why it is kept
+ * apart from the deployment's fixed data in DeploymentDataContext: a filter toggle then
+ * re-renders the map and the filters panel, and nothing else.
+ */
+const FiltersContext = createContext();
+FiltersContext.displayName = 'FiltersContext';
+
+/**
+ * Provider that owns the selected filters and seeds them from the deployment's defaults.
+ *
+ * @param {Object} props - Component props
+ * @param {React.ReactNode} props.children - Components that read or set the filters
+ * @return {React.ReactElement} Context provider with the selected filter state
+ */
+export const FiltersProvider = ({ children }) => {
+    const { defaultChecked, categoriesLoading, categoriesError } = useDeploymentData();
+    const [selectedFilters, setSelectedFilters] = useState({});
+    const [isInitialized, setIsInitialized] = useState(false);
+
+    // The deployment's default-checked options are part of the initial filter state, so
+    // consumers must not fetch against an empty selection before those are known.
+    // Initialization stays false while they are in flight, and stays false for good if
+    // they could not be loaded at all - an unfiltered fetch is not a safe stand-in.
+    useEffect(() => {
+        if (categoriesLoading || categoriesError) {
+            return;
+        }
+        if (Object.keys(defaultChecked).length > 0) {
+            setSelectedFilters(defaultChecked);
+        }
+        setIsInitialized(true);
+    }, [defaultChecked, categoriesLoading, categoriesError]);
+
+    const value = useMemo(
+        () => ({ selectedFilters, setSelectedFilters, isInitialized }),
+        [selectedFilters, isInitialized],
+    );
+
+    return <FiltersContext.Provider value={value}>{children}</FiltersContext.Provider>;
+};
+
+FiltersProvider.propTypes = {
+    children: PropTypes.node.isRequired,
+};
+
+/**
+ * Access the currently selected filters.
+ *
+ * Must be used within a FiltersProvider.
+ *
+ * - selectedFilters: selected filter values keyed by category
+ * - setSelectedFilters: updates the selected filters
+ * - isInitialized: true once the initial selection is known
+ *
+ * @throws {Error} If used outside of FiltersProvider
+ * @return {Object} The filter state described above
+ */
+export const useFilters = () => {
+    const context = useContext(FiltersContext);
+    if (!context) {
+        throw new Error('useFilters must be used within a FiltersProvider');
+    }
+    return context;
+};
diff --git a/frontend/src/locales/en/map.json b/frontend/src/locales/en/map.json
index 26f745d1..f836798b 100644
--- a/frontend/src/locales/en/map.json
+++ b/frontend/src/locales/en/map.json
@@ -40,6 +40,8 @@
     "linkCopied": "Link copied to clipboard",
     "linkCopyFailed": "Failed to copy link",
     "loadFiltersError": "Failed to load filters.",
+    "loadSuggestFormError": "Failed to load the suggestion form.",
+    "loadReportFormError": "Failed to load the report form.",
     "retry": "Retry",
     "clearFilters": "Clear filters",
     "clearAllFiltersAriaLabel": "Clear all filters",
diff --git a/frontend/src/locales/pl/map.json b/frontend/src/locales/pl/map.json
index 84615adf..f6f8a2a4 100644
--- a/frontend/src/locales/pl/map.json
+++ b/frontend/src/locales/pl/map.json
@@ -40,6 +40,8 @@
     "linkCopied": "Link skopiowany do schowka",
     "linkCopyFailed": "Nie udało się skopiować linku",
     "loadFiltersError": "Nie udało się załadować filtrów.",
+    "loadSuggestFormError": "Nie udało się załadować formularza propozycji.",
+    "loadReportFormError": "Nie udało się załadować formularza zgłoszenia.",
     "retry": "Spróbuj ponownie",
     "clearFilters": "Wyczyść filtry",
     "clearAllFiltersAriaLabel": "Wyczyść wszystkie filtry",
diff --git a/frontend/src/locales/ua/map.json b/frontend/src/locales/ua/map.json
index 3b0a4341..b5f9356c 100644
--- a/frontend/src/locales/ua/map.json
+++ b/frontend/src/locales/ua/map.json
@@ -39,6 +39,8 @@
     "linkCopied": "Посилання скопійовано",
     "linkCopyFailed": "Не вдалося скопіювати посилання",
     "loadFiltersError": "Не вдалося завантажити фільтри.",
+    "loadSuggestFormError": "Не вдалося завантажити форму пропозиції.",
+    "loadReportFormError": "Не вдалося завантажити форму скарги.",
     "retry": "Спробувати ще раз",
     "clearFilters": "Очистити фільтри",
     "clearAllFiltersAriaLabel": "Очистити всі фільтри",
diff --git a/frontend/src/services/http/endpoints.js b/frontend/src/services/http/endpoints.js
index b8d0bef1..282b60fa 100644
--- a/frontend/src/services/http/endpoints.js
+++ b/frontend/src/services/http/endpoints.js
@@ -4,6 +4,12 @@
  */
 export const CATEGORIES_FULL = '/api/categories-full';
 
+/**
+ * API endpoint describing what this deployment accepts for a new point:
+ * the fields, their allowed values, reportable issue types and photo limits.
+ */
+export const LOCATION_SCHEMA = '/api/location-schema';
+
 /**
  * API endpoint for fetching a single location by ID.
  * Use with location UUID appended: /api/location/{uuid}
diff --git a/frontend/src/services/http/httpService.js b/frontend/src/services/http/httpService.js
index 6a12e810..01999f3c 100644
--- a/frontend/src/services/http/httpService.js
+++ b/frontend/src/services/http/httpService.js
@@ -1,5 +1,6 @@
 import {
     CATEGORIES_FULL,
+    LOCATION_SCHEMA,
     LOCATION,
     LOCATIONS,
     SEARCH_ADDRESS,
@@ -74,6 +75,24 @@ const httpService = {
      *   category data plus a map of category key to the option values that should be
      *   pre-checked by default.
      */
+    /**
+     * Fetches the schema this deployment accepts for a new point.
+     *
+     * The accepted fields are configured per deployment, so they are read from the
+     * running instance rather than assumed.
+     *
+     * @returns {Promise<Object>} Promise resolving to the location schema
+     */
+    getLocationSchema: async () => {
+        const response = await fetch(LOCATION_SCHEMA, {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+        return jsonOrThrow(response, 'location schema');
+    },
+
     getCategoriesData: async () => {
         const response = await fetch(CATEGORIES_FULL).then(res => res.json());
         const useCategoriesHelp = Boolean(globalThis.FEATURE_FLAGS?.CATEGORIES_HELP);
diff --git a/frontend/tests/CategoriesContext.test.jsx b/frontend/tests/CategoriesContext.test.jsx
deleted file mode 100644
index d8780fab..00000000
--- a/frontend/tests/CategoriesContext.test.jsx
+++ /dev/null
@@ -1,38 +0,0 @@
-import React from 'react';
-import { render, waitFor } from '@testing-library/react';
-import '@testing-library/jest-dom';
-import FiltersForm from '../src/components/FiltersForm/FiltersForm';
-import SuggestNewPointButton from '../src/components/Map/components/SuggestNewPointButton';
-import { CategoriesProvider } from '../src/components/Categories/CategoriesContext';
-import { LocationProvider } from '../src/components/Map/context/LocationContext';
-import httpService from '../src/services/http/httpService';
-
-jest.mock('axios');
-jest.mock('../src/services/http/httpService', () => ({
-    __esModule: true,
-    default: { getCategoriesData: jest.fn(), getLocations: jest.fn() },
-}));
-jest.mock('../src/utils/toast', () => ({
-    __esModule: true,
-    default: { success: jest.fn(), error: jest.fn() },
-}));
-jest.mock('browser-image-compression');
-
-// Both the filter panel and the suggestion dialog need the category definitions.
-// The provider owns the fetch so they share one request instead of making two.
-test('categories are fetched once for all consumers', async () => {
-    httpService.getCategoriesData.mockResolvedValue({ categories: [], defaultChecked: {} });
-    globalThis.LOCATION_SCHEMA = { obligatory_fields: [['name', 'str']], categories: {} };
-
-    render(
-        <CategoriesProvider>
-            <LocationProvider>
-                <FiltersForm />
-                <SuggestNewPointButton />
-            </LocationProvider>
-        </CategoriesProvider>,
-    );
-
-    await waitFor(() => expect(httpService.getCategoriesData).toHaveBeenCalled());
-    expect(httpService.getCategoriesData).toHaveBeenCalledTimes(1);
-});
diff --git a/frontend/tests/DeploymentDataContext.test.jsx b/frontend/tests/DeploymentDataContext.test.jsx
new file mode 100644
index 00000000..eac46196
--- /dev/null
+++ b/frontend/tests/DeploymentDataContext.test.jsx
@@ -0,0 +1,74 @@
+import React from 'react';
+import { render, waitFor } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import FiltersForm from '../src/components/FiltersForm/FiltersForm';
+import SuggestNewPointButton from '../src/components/Map/components/SuggestNewPointButton';
+import { LocationProvider } from '../src/components/Map/context/LocationContext';
+import AppProviders from './utils/providers';
+import { useDeploymentData } from '../src/context/DeploymentDataContext';
+import httpService from '../src/services/http/httpService';
+
+jest.mock('axios');
+jest.mock('../src/services/http/httpService', () => ({
+    __esModule: true,
+    default: {
+        getCategoriesData: jest.fn(),
+        getLocations: jest.fn(),
+        getLocationSchema: jest.fn(),
+    },
+}));
+jest.mock('../src/utils/toast', () => ({
+    __esModule: true,
+    default: { success: jest.fn(), error: jest.fn() },
+}));
+jest.mock('browser-image-compression');
+
+// Both the filter panel and the suggestion dialog need the category definitions.
+// The provider owns the fetch so they share one request instead of making two.
+test('categories are fetched once for all consumers', async () => {
+    httpService.getCategoriesData.mockResolvedValue({ categories: [], defaultChecked: {} });
+    httpService.getLocationSchema.mockResolvedValue({});
+
+    render(
+        <AppProviders>
+            <LocationProvider>
+                <FiltersForm />
+                <SuggestNewPointButton />
+            </LocationProvider>
+        </AppProviders>,
+    );
+
+    await waitFor(() => expect(httpService.getCategoriesData).toHaveBeenCalled());
+    expect(httpService.getCategoriesData).toHaveBeenCalledTimes(1);
+});
+
+// A probe is the only way to see what the provider hands consumers, rather than what
+// one particular consumer happens to render from it.
+const SchemaProbe = () => {
+    const { locationSchema, schemaError } = useDeploymentData();
+    return (
+        <div>
+            <span data-testid="schema">{locationSchema === null ? 'null' : 'resolved'}</span>
+            <span data-testid="error">{String(schemaError)}</span>
+        </div>
+    );
+};
+
+// A failed request must not be handed on as a schema: consumers would read an empty one
+// as a real answer and build a form with no fields from it.
+test('a failed schema request is not exposed as a resolved schema', async () => {
+    const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+    httpService.getCategoriesData.mockResolvedValue({ categories: [], defaultChecked: {} });
+    httpService.getLocationSchema.mockRejectedValue(new Error('schema unavailable'));
+
+    const { getByTestId } = render(
+        <AppProviders>
+            <SchemaProbe />
+        </AppProviders>,
+    );
+
+    await waitFor(() => expect(getByTestId('error')).toHaveTextContent('true'));
+    expect(getByTestId('schema')).toHaveTextContent('null');
+
+    consoleErrorSpy.mockRestore();
+});
diff --git a/frontend/tests/FiltersForm.test.jsx b/frontend/tests/FiltersForm.test.jsx
index 1a896c41..fa32d104 100644
--- a/frontend/tests/FiltersForm.test.jsx
+++ b/frontend/tests/FiltersForm.test.jsx
@@ -2,7 +2,7 @@ import React from 'react';
 import '@testing-library/jest-dom';
 import { fireEvent, render, waitFor, within } from '@testing-library/react';
 import FiltersForm from '../src/components/FiltersForm/FiltersForm';
-import { CategoriesProvider } from '../src/components/Categories/CategoriesContext';
+import AppProviders from './utils/providers';
 import httpService from '../src/services/http/httpService';
 
 jest.mock('../src/services/http/httpService');
@@ -32,9 +32,9 @@ describe('Creates good filter_form box', () => {
             json: jest.fn().mockResolvedValue(categories),
         });
         render(
-            <CategoriesProvider>
+            <AppProviders>
                 <FiltersForm />
-            </CategoriesProvider>,
+            </AppProviders>,
         );
         await waitFor(() => expect(document.querySelector('#filter-label-types')).not.toBeNull());
     });
@@ -99,9 +99,9 @@ describe('Pre-checks options configured as default-checked', () => {
             defaultChecked: { types: ['shoes'] },
         });
         render(
-            <CategoriesProvider>
+            <AppProviders>
                 <FiltersForm />
-            </CategoriesProvider>,
+            </AppProviders>,
         );
         await waitFor(() => expect(document.querySelector('#shoes')).not.toBeNull());
     });
@@ -143,9 +143,9 @@ describe('Renders exclusive (single-select) categories as radio buttons', () =>
             defaultChecked: {},
         });
         render(
-            <CategoriesProvider>
+            <AppProviders>
                 <FiltersForm />
-            </CategoriesProvider>,
+            </AppProviders>,
         );
         await waitFor(() => expect(document.querySelector('#free')).not.toBeNull());
     });
@@ -204,9 +204,9 @@ describe('Groups boolean categories into a shared "Others" section', () => {
             defaultChecked: {},
         });
         render(
-            <CategoriesProvider>
+            <AppProviders>
                 <FiltersForm />
-            </CategoriesProvider>,
+            </AppProviders>,
         );
         await waitFor(() => expect(document.querySelector('#is_free')).not.toBeNull());
     });
@@ -265,9 +265,9 @@ describe('Renders threshold categories as radio buttons too', () => {
             defaultChecked: {},
         });
         render(
-            <CategoriesProvider>
+            <AppProviders>
                 <FiltersForm />
-            </CategoriesProvider>,
+            </AppProviders>,
         );
         await waitFor(() => expect(document.getElementById('10')).not.toBeNull());
     });
@@ -311,9 +311,9 @@ describe('Distinguishes "and" categories with a visible hint, but keeps checkbox
             defaultChecked: {},
         });
         render(
-            <CategoriesProvider>
+            <AppProviders>
                 <FiltersForm />
-            </CategoriesProvider>,
+            </AppProviders>,
         );
         await waitFor(() => expect(document.querySelector('#lighting')).not.toBeNull());
     });
diff --git a/frontend/tests/Map/MapComponent.test.jsx b/frontend/tests/Map/MapComponent.test.jsx
index 2f307e68..02fa9ae5 100644
--- a/frontend/tests/Map/MapComponent.test.jsx
+++ b/frontend/tests/Map/MapComponent.test.jsx
@@ -3,7 +3,7 @@ import { render, waitFor, screen } from '@testing-library/react';
 import '@testing-library/jest-dom/extend-expect';
 import MapComponent from '../../src/components/Map/MapComponent';
 import FiltersForm from '../../src/components/FiltersForm/FiltersForm';
-import { CategoriesProvider } from '../../src/components/Categories/CategoriesContext';
+import AppProviders from '../utils/providers';
 import httpService from '../../src/services/http/httpService';
 
 jest.mock('../../src/services/http/httpService');
@@ -32,6 +32,8 @@ const locations = [
 
 httpService.getLocations.mockResolvedValue(locations);
 httpService.getCategoriesData.mockResolvedValue({ categories, defaultChecked: {} });
+// Fetched by the provider alongside the categories; no component here reads it.
+httpService.getLocationSchema.mockResolvedValue({});
 
 describe('MapComponent', () => {
     beforeAll(() => {
@@ -48,25 +50,28 @@ describe('MapComponent', () => {
 
     it('renders without crashing', async () => {
         render(
-            <CategoriesProvider>
+            <AppProviders>
                 <MapComponent />
-            </CategoriesProvider>,
+            </AppProviders>,
         );
 
         await waitFor(() => expect(screen.getAllByRole('presentation').length).toBeGreaterThan(0));
     });
 
-    it('does not fetch locations before filter state is initialized', () => {
+    it('does not fetch locations before filter state is initialized', async () => {
         httpService.getLocations.mockClear();
         // Never resolves, so the provider leaves the filter state uninitialized.
         httpService.getCategoriesData.mockReturnValueOnce(new Promise(() => {}));
 
         render(
-            <CategoriesProvider>
+            <AppProviders>
                 <MapComponent />
-            </CategoriesProvider>,
+            </AppProviders>,
         );
 
+        // Let the provider's other fetch settle first, so this asserts on the filter
+        // state rather than on merely having run before anything could happen.
+        await waitFor(() => expect(httpService.getLocationSchema).toHaveBeenCalled());
         expect(httpService.getLocations).not.toHaveBeenCalled();
     });
 });
@@ -84,10 +89,10 @@ describe('MapComponent with FiltersForm', () => {
         });
 
         render(
-            <CategoriesProvider>
+            <AppProviders>
                 <FiltersForm />
                 <MapComponent />
-            </CategoriesProvider>,
+            </AppProviders>,
         );
 
         await waitFor(() => expect(httpService.getLocations).toHaveBeenCalledTimes(1));
diff --git a/frontend/tests/Map/components/AccessibilityTable.test.jsx b/frontend/tests/Map/components/AccessibilityTable.test.jsx
index 25930438..8c81b0b5 100644
--- a/frontend/tests/Map/components/AccessibilityTable.test.jsx
+++ b/frontend/tests/Map/components/AccessibilityTable.test.jsx
@@ -4,7 +4,7 @@ import { render, screen, act, waitFor } from '@testing-library/react';
 import AccessibilityTable from '../../../src/components/Map/components/AccessibilityTable';
 import httpService from '../../../src/services/http/httpService';
 
-import { CategoriesProvider } from '../../../src/components/Categories/CategoriesContext';
+import AppProviders from '../../utils/providers';
 
 jest.mock('../../../src/services/http/httpService');
 
@@ -44,12 +44,12 @@ describe('Accessibility Table', () => {
         const lng = 17.0555;
         return act(() => {
             render(
-                <CategoriesProvider>
+                <AppProviders>
                     <AccessibilityTable
                         userPosition={{ lat, lng }}
                         setIsAccessibilityTableOpen={() => {}}
                     />
-                </CategoriesProvider>,
+                </AppProviders>,
             );
         });
     });
diff --git a/frontend/tests/Map/components/Markers.test.jsx b/frontend/tests/Map/components/Markers.test.jsx
index 44edffb8..a04fd2d0 100644
--- a/frontend/tests/Map/components/Markers.test.jsx
+++ b/frontend/tests/Map/components/Markers.test.jsx
@@ -3,7 +3,7 @@ import '@testing-library/jest-dom';
 import { render, waitFor } from '@testing-library/react';
 import { MapContainer } from 'react-leaflet';
 import Markers from '../../../src/components/Map/components/Markers';
-import { CategoriesProvider } from '../../../src/components/Categories/CategoriesContext';
+import AppProviders from '../../utils/providers';
 import httpService from '../../../src/services/http/httpService';
 
 jest.mock('../../../src/services/http/httpService', () => ({
@@ -11,20 +11,23 @@ jest.mock('../../../src/services/http/httpService', () => ({
     default: {
         getCategoriesData: jest.fn(),
         getLocations: jest.fn(),
+        getLocationSchema: jest.fn(),
     },
 }));
 
 const renderMarkers = onLoadingChange =>
     render(
-        <CategoriesProvider>
+        <AppProviders>
             <MapContainer center={[51.1, 17.03]} zoom={13} maxZoom={19} style={{ height: '100vh' }}>
                 <Markers onLoadingChange={onLoadingChange} />
             </MapContainer>
-        </CategoriesProvider>,
+        </AppProviders>,
     );
 
 beforeEach(() => {
     httpService.getCategoriesData.mockResolvedValue({ categories: [], defaultChecked: {} });
+    // The provider fetches this alongside the categories; Markers itself never reads it.
+    httpService.getLocationSchema.mockResolvedValue({});
     // Server-side clustering settles the loading state directly, rather than waiting on
     // a Leaflet cluster event, which keeps these assertions about Markers itself.
     globalThis.FEATURE_FLAGS = { USE_SERVER_SIDE_CLUSTERING: true };
diff --git a/frontend/tests/Map/components/SuggestNewPoint.test.jsx b/frontend/tests/Map/components/SuggestNewPoint.test.jsx
index 789aad1f..937c17b6 100644
--- a/frontend/tests/Map/components/SuggestNewPoint.test.jsx
+++ b/frontend/tests/Map/components/SuggestNewPoint.test.jsx
@@ -5,7 +5,7 @@ import axios from 'axios';
 import imageCompression from 'browser-image-compression';
 import SuggestNewPointButton from '../../../src/components/Map/components/SuggestNewPointButton';
 import { LocationProvider } from '../../../src/components/Map/context/LocationContext';
-import { CategoriesProvider } from '../../../src/components/Categories/CategoriesContext';
+import AppProviders from '../../utils/providers';
 import {
     mockGeolocationSuccess,
     mockGeolocationError,
@@ -24,9 +24,9 @@ import toast from '../../../src/utils/toast';
 
 const renderWithProvider = component =>
     render(
-        <CategoriesProvider>
+        <AppProviders>
             <LocationProvider>{component}</LocationProvider>
-        </CategoriesProvider>,
+        </AppProviders>,
     );
 
 jest.mock('axios');
@@ -34,6 +34,7 @@ jest.mock('../../../src/services/http/httpService', () => ({
     __esModule: true,
     default: {
         getCategoriesData: jest.fn(),
+        getLocationSchema: jest.fn(),
     },
 }));
 jest.mock('../../../src/utils/toast', () => ({
@@ -49,7 +50,7 @@ beforeEach(() => {
     metaTag.setAttribute('content', 'test-csrf-token');
     document.head.appendChild(metaTag);
 
-    globalThis.LOCATION_SCHEMA = FULL_SCHEMA;
+    httpService.getLocationSchema.mockResolvedValue(FULL_SCHEMA);
 
     // Mock categories data matching httpService.getCategoriesData()'s real
     // { categories: [{ categoryKey, categoryName, options }] } shape.
@@ -82,7 +83,6 @@ afterEach(() => {
     if (metaTag) {
         metaTag.remove();
     }
-    delete globalThis.LOCATION_SCHEMA;
     jest.clearAllMocks();
 });
 
@@ -447,7 +447,7 @@ describe('SuggestNewPointButton', () => {
 
         axios.post.mockRejectedValue(new Error('Network error'));
         mockGeolocationSuccess();
-        globalThis.LOCATION_SCHEMA = SIMPLE_SCHEMA;
+        httpService.getLocationSchema.mockResolvedValue(SIMPLE_SCHEMA);
 
         renderWithProvider(<SuggestNewPointButton />);
         await openDialog();
@@ -474,7 +474,7 @@ describe('SuggestNewPointButton', () => {
 
         axios.post.mockRejectedValue({ response: { data: { message: backendMessage } } });
         mockGeolocationSuccess();
-        globalThis.LOCATION_SCHEMA = SIMPLE_SCHEMA;
+        httpService.getLocationSchema.mockResolvedValue(SIMPLE_SCHEMA);
 
         renderWithProvider(<SuggestNewPointButton />);
         await openDialog();
@@ -499,7 +499,7 @@ describe('SuggestNewPointButton', () => {
                 }),
         );
         mockGeolocationSuccess();
-        globalThis.LOCATION_SCHEMA = SIMPLE_SCHEMA;
+        httpService.getLocationSchema.mockResolvedValue(SIMPLE_SCHEMA);
 
         renderWithProvider(<SuggestNewPointButton />);
         await openDialog();
@@ -526,7 +526,7 @@ describe('SuggestNewPointButton', () => {
     it('closes dialog and resets form on successful submission', async () => {
         axios.post.mockResolvedValue({ data: { message: 'Success' } });
         mockGeolocationSuccess();
-        globalThis.LOCATION_SCHEMA = SIMPLE_SCHEMA;
+        httpService.getLocationSchema.mockResolvedValue(SIMPLE_SCHEMA);
 
         renderWithProvider(<SuggestNewPointButton />);
         await openDialog();
@@ -542,4 +542,40 @@ describe('SuggestNewPointButton', () => {
             expect(axios.post).toHaveBeenCalledTimes(1);
         });
     });
+    it('builds category options from the category definitions', async () => {
+        mockGeolocationSuccess();
+
+        renderWithProvider(<SuggestNewPointButton />);
+        await openDialog();
+
+        fireEvent.mouseDown(screen.getByRole('combobox', { name: /accessible by/i }));
+
+        // The schema says accessible_by is obligatory but no longer carries its values:
+        // both the values and their labels come from the category definitions, which
+        // are now the only place either is reported.
+        const options = await screen.findAllByRole('option');
+        expect(options.map(option => option.textContent)).toEqual(['Bikes', 'Cars', 'Pedestrians']);
+    });
+    it('offers a retry instead of the form when the schema fails to load', async () => {
+        const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+        mockGeolocationSuccess();
+        httpService.getLocationSchema.mockRejectedValue(new Error('schema unavailable'));
+
+        renderWithProvider(<SuggestNewPointButton />);
+        await openDialog();
+
+        // With no schema there are no fields to fill, so a submitted form could only be
+        // rejected by the backend: the failure is stated instead of offering one.
+        expect(screen.getByText('Failed to load the suggestion form.')).toBeInTheDocument();
+        expect(screen.queryByRole('button', { name: /submit/i })).not.toBeInTheDocument();
+
+        httpService.getLocationSchema.mockResolvedValue(FULL_SCHEMA);
+        fireEvent.click(screen.getByRole('button', { name: /retry/i }));
+
+        await waitFor(() =>
+            expect(screen.getByRole('button', { name: /submit/i })).toBeInTheDocument(),
+        );
+
+        consoleErrorSpy.mockRestore();
+    });
 });
diff --git a/frontend/tests/MarkerPopup/ReportProblemForm.test.jsx b/frontend/tests/MarkerPopup/ReportProblemForm.test.jsx
index 72f44012..32eda6ec 100644
--- a/frontend/tests/MarkerPopup/ReportProblemForm.test.jsx
+++ b/frontend/tests/MarkerPopup/ReportProblemForm.test.jsx
@@ -5,6 +5,15 @@ import ReportProblemForm from '../../src/components/MarkerPopup/ReportProblemFor
 jest.mock('axios');
 const axios = require('axios');
 
+// The schema comes from a provider that fetches it; these tests exercise the form, so
+// the hook is stubbed to keep them synchronous and focused.
+jest.mock('../../src/context/DeploymentDataContext', () => ({
+    useDeploymentData: jest.fn(),
+}));
+const { useDeploymentData } = require('../../src/context/DeploymentDataContext');
+
+const mockSchema = (schema = {}) => useDeploymentData.mockReturnValue({ locationSchema: schema });
+
 axios.post.mockResolvedValue({ data: { success: true } });
 
 const PLACE_ID = 'test-id';
@@ -45,6 +54,7 @@ beforeEach(() => {
     metaTag.setAttribute('name', 'csrf-token');
     metaTag.setAttribute('content', CSRF_TOKEN);
     document.head.appendChild(metaTag);
+    mockSchema();
 });
 
 afterEach(() => {
@@ -52,7 +62,6 @@ afterEach(() => {
     if (metaTag) {
         metaTag.remove();
     }
-    delete globalThis.LOCATION_SCHEMA;
 });
 
 describe('ReportProblemForm', () => {
@@ -81,8 +90,8 @@ describe('ReportProblemForm', () => {
         expect(queryByText(/Submit/i)).toBeNull();
     });
 
-    it('renders dynamic issue types from LOCATION_SCHEMA', () => {
-        globalThis.LOCATION_SCHEMA = CUSTOM_ISSUE_TYPES;
+    it('renders dynamic issue types from the deployment schema', () => {
+        mockSchema(CUSTOM_ISSUE_TYPES);
         const { getByText, queryByText, select } = renderForm();
 
         const optionTexts = Array.from(select.querySelectorAll('option')).map(o => o.textContent);
@@ -97,7 +106,7 @@ describe('ReportProblemForm', () => {
     });
 
     it('submits dynamic issue type value as description', () => {
-        globalThis.LOCATION_SCHEMA = CUSTOM_ISSUE_TYPES;
+        mockSchema(CUSTOM_ISSUE_TYPES);
         const { getByText, select } = renderForm();
         fireEvent.change(select, { target: { value: 'under construction' } });
         fireEvent.click(getByText(/Submit/i));
@@ -105,8 +114,8 @@ describe('ReportProblemForm', () => {
         return expectReportSubmitted('under construction');
     });
 
-    it('falls back to default options when LOCATION_SCHEMA is undefined', () => {
-        delete globalThis.LOCATION_SCHEMA;
+    it('falls back to default options when the schema has not loaded', () => {
+        mockSchema({});
         const { getByText } = renderForm();
 
         expect(getByText('this point is not here')).toBeTruthy();
@@ -117,7 +126,7 @@ describe('ReportProblemForm', () => {
 
     it('falls back to default options when reported_issue_types is empty', () => {
         // eslint-disable-next-line camelcase -- matches backend API schema property name
-        globalThis.LOCATION_SCHEMA = { reported_issue_types: [] };
+        mockSchema({ reported_issue_types: [] });
         const { getByText } = renderForm();
 
         expect(getByText('this point is not here')).toBeTruthy();
@@ -125,3 +134,29 @@ describe('ReportProblemForm', () => {
         expect(getByText("it's broken")).toBeTruthy();
     });
 });
+
+// A schema that has not arrived is not the same as one declaring no issue types: the
+// legacy fallbacks are not a stand-in for values this deployment may not accept.
+test('renders nothing until the schema has loaded', () => {
+    useDeploymentData.mockReturnValue({ locationSchema: null });
+
+    const { container } = render(<ReportProblemForm placeId={PLACE_ID} />);
+
+    expect(container.innerHTML).toBe('');
+});
+
+// Withholding the form on a failed fetch would otherwise leave it never appearing at all.
+test('offers a retry when the schema could not be loaded', () => {
+    const refetchLocationSchema = jest.fn();
+    useDeploymentData.mockReturnValue({
+        locationSchema: null,
+        schemaError: true,
+        refetchLocationSchema,
+    });
+
+    const { getByText, getByRole } = render(<ReportProblemForm placeId={PLACE_ID} />);
+
+    expect(getByText(/failed to load the report form/i)).toBeTruthy();
+    fireEvent.click(getByRole('button', { name: /retry/i }));
+    expect(refetchLocationSchema).toHaveBeenCalledTimes(1);
+});
diff --git a/frontend/tests/utils/providers.jsx b/frontend/tests/utils/providers.jsx
new file mode 100644
index 00000000..558acbd7
--- /dev/null
+++ b/frontend/tests/utils/providers.jsx
@@ -0,0 +1,23 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { DeploymentDataProvider } from '../../src/context/DeploymentDataContext';
+import { FiltersProvider } from '../../src/context/FiltersContext';
+
+/**
+ * Wraps a component in the same provider nesting the app itself uses, so tests exercise
+ * the real arrangement instead of each re-declaring it and drifting from it.
+ *
+ * @param {{children: React.ReactNode}} props
+ * @return {React.ReactElement} The children inside the app's providers
+ */
+const AppProviders = ({ children }) => (
+    <DeploymentDataProvider>
+        <FiltersProvider>{children}</FiltersProvider>
+    </DeploymentDataProvider>
+);
+
+AppProviders.propTypes = {
+    children: PropTypes.node.isRequired,
+};
+
+export default AppProviders;
diff --git a/frontend/tests/utils/testConstants.js b/frontend/tests/utils/testConstants.js
index 83502235..af47c831 100644
--- a/frontend/tests/utils/testConstants.js
+++ b/frontend/tests/utils/testConstants.js
@@ -50,7 +50,6 @@ export const PHOTO_SCHEMA = {
  */
 export const SIMPLE_SCHEMA = {
     obligatory_fields: [['name', 'str']],
-    categories: {},
     photo: PHOTO_SCHEMA,
 };
 
@@ -63,9 +62,5 @@ export const FULL_SCHEMA = {
         ['accessible_by', 'list'],
         ['type_of_place', 'str'],
     ],
-    categories: {
-        accessible_by: ['bikes', 'cars', 'pedestrians'],
-        type_of_place: ['big bridge', 'small bridge'],
-    },
     photo: PHOTO_SCHEMA,
 };
diff --git a/goodmap/api/api_models.py b/goodmap/api/api_models.py
index fefb06a5..e59b7915 100644
--- a/goodmap/api/api_models.py
+++ b/goodmap/api/api_models.py
@@ -190,9 +190,6 @@ class LocationSchemaResponse(BaseModel):
     obligatory_fields: list[Any] = Field(
         ..., description="[name, type] pairs every point must carry"
     )
-    categories: dict[str, list[str]] = Field(
-        ..., description="Filterable fields and their allowed values"
-    )
     reported_issue_types: list[IssueType] = Field(
         ..., description="Accepted values for /api/report-location"
     )
diff --git a/goodmap/api/core_api.py b/goodmap/api/core_api.py
index b2c1280d..09be7455 100644
--- a/goodmap/api/core_api.py
+++ b/goodmap/api/core_api.py
@@ -436,10 +436,13 @@ def get_location_schema():
         The fields a point may carry are configured per deployment, so there is no
         fixed payload for /api/suggest-new-point. This returns the accepted fields
         (excluding only the server-assigned uuid - position is required and must be
-        supplied by the client), the allowed values for each category, the reportable
-        issue types and the photo limits, as the built-in suggest form uses them.
+        supplied by the client), the reportable issue types and the photo limits, as
+        the built-in suggest form uses them.
+
+        A field's own allowed values are part of its schema under `fields`. What this no
+        longer carries is a separate top-level `categories` map repeating them in another
+        shape; /api/categories-full reports the same values with translated labels.
         """
-        category_data = database.get_category_data()
         properties = location_model.model_json_schema().get("properties", {})
         # Matches the fallback /api/report-location applies: an unconfigured
         # reported_issue_types must not make this endpoint advertise fewer accepted
@@ -451,7 +454,6 @@ def get_location_schema():
                 "obligatory_fields": current_app.extensions.get("goodmap", {}).get(
                     "location_obligatory_fields", []
                 ),
-                "categories": category_data.get("categories", {}),
                 "reported_issue_types": [{"value": t, "label": gettext(t)} for t in issue_options],
                 "photo": {
                     "allowed_extensions": sorted(photo_attachment_config.allowed_extensions or []),
diff --git a/goodmap/goodmap.py b/goodmap/goodmap.py
index 113038e4..64139404 100644
--- a/goodmap/goodmap.py
+++ b/goodmap/goodmap.py
@@ -7,7 +7,6 @@
 from typing import Any
 
 from flask import Blueprint, jsonify, redirect, render_template, session
-from flask_babel import gettext
 from flask_wtf.csrf import CSRFError
 from platzky import platzky
 from platzky.config import languages_dict
@@ -276,55 +275,20 @@ def handle_csrf_error(error):
 
     @goodmap.route("/map")
     def index():
-        """Render main map interface with location schema.
+        """Render the main map interface.
 
         Registered at /map rather than / because platzky (>=2.0.0a8) reserves
         the root path for its own homepage dispatch (see
         db.get_home_page_path()). Deployments set site_content.home_page_path
         to "/map" so visiting / still renders this view, with no redirect.
 
-        Prepares and passes location schema including obligatory fields and
-        categories to the frontend for dynamic form generation.
-
         Returns:
-            Rendered map.html template with feature flags and location schema
+            Rendered map.html template with feature flags and the plugin manifest
         """
-        # Prepare location schema for frontend dynamic forms
-        # Include full schema from Pydantic model for better type information
-        category_data = app.db.get_category_data()  # type: ignore[attr-defined]
-        categories = category_data.get("categories", {})
-
-        # Get full JSON schema from Pydantic model
-        model_json_schema = location_model.model_json_schema()
-        properties = model_json_schema.get("properties", {})
-
-        # Filter out uuid and position from properties for frontend form
-        form_fields = {
-            name: spec for name, spec in properties.items() if name not in ("uuid", "position")
-        }
-
-        issue_options_raw = app.db.get_issue_options()  # type: ignore[attr-defined]
-        reported_issue_types = [{"value": t, "label": gettext(t)} for t in issue_options_raw]
-
-        location_schema = {  # TODO remove backward compatibility - deprecation
-            "obligatory_fields": app.extensions["goodmap"][
-                "location_obligatory_fields"
-            ],  # Backward compatibility
-            "categories": categories,  # Backward compatibility
-            "fields": form_fields,
-            "reported_issue_types": reported_issue_types,
-            "photo": {
-                "allowed_extensions": sorted(photo_attachment_config.allowed_extensions or []),
-                "allowed_mime_types": sorted(photo_attachment_config.allowed_mime_types or []),
-                "max_size_bytes": photo_attachment_config.max_size,
-            },
-        }
-
         return render_template(
             "map.html",
             feature_flags=config.feature_flags,
             goodmap_frontend_lib_url=config.goodmap_frontend_lib_url,
-            location_schema=location_schema,
             plugin_manifest=plugin_manifest,
         )
 
diff --git a/goodmap/templates/map.html b/goodmap/templates/map.html
index b165a99b..d1b1eacb 100644
--- a/goodmap/templates/map.html
+++ b/goodmap/templates/map.html
@@ -120,9 +120,6 @@
 window.USE_SERVER_SIDE_CLUSTERING = {{ feature_flags.USE_SERVER_SIDE_CLUSTERING | default(false) | tojson }};
 window.SHOW_ACCESSIBILITY_TABLE = {{ feature_flags.SHOW_ACCESSIBILITY_TABLE | default(false) | tojson }};
 window.FEATURE_FLAGS = {{ feature_flags | tojson }};
-// Location schema for dynamic form building
-// Contains required fields and available categories for new location suggestions
-globalThis.LOCATION_SCHEMA = {{ location_schema | tojson }};
 window.PLUGIN_MANIFEST = {{ plugin_manifest | tojson }};
 </script>
 <script src="{{ goodmap_frontend_lib_url }}" crossorigin="anonymous"></script>
diff --git a/tests/unit_tests/test_core_api.py b/tests/unit_tests/test_core_api.py
index 06844bb7..6dbb03e5 100644
--- a/tests/unit_tests/test_core_api.py
+++ b/tests/unit_tests/test_core_api.py
@@ -40,7 +40,6 @@ def test_location_schema_endpoint_describes_this_instance(test_app):
     assert set(body) == {
         "fields",
         "obligatory_fields",
-        "categories",
         "reported_issue_types",
         "photo",
     }
@@ -52,6 +51,27 @@ def test_location_schema_endpoint_describes_this_instance(test_app):
     assert set(body["photo"]) == {"allowed_extensions", "allowed_mime_types", "max_size_bytes"}
 
 
+def test_location_schema_reports_allowed_values_inside_each_field():
+    """A field's allowed values are part of its own schema under `fields`.
+
+    Removing the top-level `categories` key removed a second copy of them in a different
+    shape, not the values themselves - a client building a suggest payload still needs
+    them, and this is where it reads them from.
+    """
+    test_app = create_test_app(
+        db_overrides={
+            "categories": {"accessible_by": ["bikes", "cars"]},
+            "location_obligatory_fields": [("accessible_by", "list"), ("name", "str")],
+        }
+    )
+    response = test_app.get("/api/location-schema")
+    assert response.status_code == 200
+    body = response.json
+    assert body is not None
+    # frozenset-backed, so the order carries no meaning
+    assert set(body["fields"]["accessible_by"]["enum_items"]) == {"bikes", "cars"}
+
+
 def test_location_schema_endpoint_falls_back_to_default_issue_options():
     """An unconfigured reported_issue_types must not undersell what
     /api/report-location actually accepts (it falls back to the same defaults).
diff --git a/tests/unit_tests/test_goodmap.py b/tests/unit_tests/test_goodmap.py
index 488fc01a..5fab3be2 100644
--- a/tests/unit_tests/test_goodmap.py
+++ b/tests/unit_tests/test_goodmap.py
@@ -107,46 +107,10 @@ def test_frontend_lib_url_uses_bundled_static_when_present():
     assert 'src="/static/frontend/index.min.js"' in response.data.decode("utf-8")
 
 
-def test_map_route_returns_location_schema():
-    """Test that the /map route returns successfully with location_schema"""
-    config = GoodmapConfig(
-        APP_NAME="test_app",
-        SECRET_KEY="test_secret",
-        USE_WWW=False,
-        BLOG_PREFIX="/blog",
-        DB=JsonDbConfig(
-            DATA={
-                "site_content": {"pages": []},
-                "categories": {
-                    "accessibility": ["wheelchair", "elevator"],
-                    "amenities": ["wifi", "parking"],
-                },
-            },
-            TYPE="json",
-        ),
-    )
-    app = goodmap.create_app_from_config(config)
-    # CSRF protection must be disabled in test environment to allow API testing
-    # This is safe because tests run in isolation, not in production
-    app.config["WTF_CSRF_ENABLED"] = False  # NOSONAR
-    client = app.test_client()
-
-    response = client.get("/map")
-    assert response.status_code == 200
-
-    # Verify location_schema is present in the response
-    response_text = response.data.decode("utf-8")
-    assert "LOCATION_SCHEMA" in response_text
-    assert "obligatory_fields" in response_text
-    assert "categories" in response_text
-    assert "accessibility" in response_text
-    assert "amenities" in response_text
-
-
 def test_map_route_includes_photo_constraints():
     """The frontend sources photo upload limits (max size, allowed types) live from
     the backend's AttachmentConfig rather than hardcoding its own copy - this test
-    guards the `photo` key in location_schema that makes that possible.
+    guards the `photo` key in /api/location-schema that makes that possible.
     """
     config = GoodmapConfig(
         APP_NAME="test_app",
@@ -162,13 +126,14 @@ def test_map_route_includes_photo_constraints():
     app.config["WTF_CSRF_ENABLED"] = False  # NOSONAR
     client = app.test_client()
 
-    response = client.get("/map")
+    response = client.get("/api/location-schema")
     assert response.status_code == 200
 
-    response_text = response.data.decode("utf-8")
-    assert '"max_size_bytes":5242880' in response_text
-    assert '"allowed_mime_types":["image/jpeg"]' in response_text
-    assert '"allowed_extensions":["jpeg","jpg"]' in response_text
+    assert response.json is not None
+    photo = response.json["photo"]
+    assert photo["max_size_bytes"] == 5242880
+    assert photo["allowed_mime_types"] == ["image/jpeg"]
+    assert photo["allowed_extensions"] == ["jpeg", "jpg"]
 
 
 def _minimal_config() -> GoodmapConfig:
@@ -264,17 +229,18 @@ def test_map_route_overrides_photo_constraints():
     app.config["WTF_CSRF_ENABLED"] = False  # NOSONAR
     client = app.test_client()
 
-    response = client.get("/map")
+    response = client.get("/api/location-schema")
     assert response.status_code == 200
 
-    response_text = response.data.decode("utf-8")
-    assert '"max_size_bytes":8388608' in response_text
-    assert '"allowed_mime_types":["image/jpeg","image/png"]' in response_text
-    assert '"allowed_extensions":["jpeg","jpg","png"]' in response_text
+    assert response.json is not None
+    photo = response.json["photo"]
+    assert photo["max_size_bytes"] == 8388608
+    assert photo["allowed_mime_types"] == ["image/jpeg", "image/png"]
+    assert photo["allowed_extensions"] == ["jpeg", "jpg", "png"]
 
 
-def test_map_route_location_schema_with_lazy_loading():
-    """Test that location_schema includes obligatory_fields when USE_LAZY_LOADING is enabled"""
+def test_location_schema_endpoint_with_lazy_loading():
+    """The schema includes obligatory_fields when USE_LAZY_LOADING is enabled."""
     config = GoodmapConfig(
         APP_NAME="test_app",
         SECRET_KEY="test_secret",
@@ -300,15 +266,19 @@ def test_map_route_location_schema_with_lazy_loading():
     app.config["WTF_CSRF_ENABLED"] = False  # NOSONAR
     client = app.test_client()
 
-    response = client.get("/map")
+    response = client.get("/api/location-schema")
     assert response.status_code == 200
 
-    # Verify location_schema includes obligatory_fields
-    response_text = response.data.decode("utf-8")
-    assert "LOCATION_SCHEMA" in response_text
-    assert "name" in response_text
-    assert "position" in response_text
-    assert "test_category" in response_text
+    schema = response.json
+    assert schema is not None
+    assert [f[0] for f in schema["obligatory_fields"]] == [
+        "name",
+        "position",
+        "test_category",
+    ]
+    # position is client-supplied, so it must be offered as a field; uuid is not
+    assert "position" in schema["fields"]
+    assert "uuid" not in schema["fields"]
 
 
 def _plugin_ep(name: str, plugin_dir: str | None, base: type = MapOverlayPluginBase):