diff --git a/CHANGELOG.md b/CHANGELOG.md
index 724738f..c077380 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
+## [Unreleased]
+
+### Add
+
+- Add configurable table question type
+
 ## [1.1.1] - 2026-05-27
 
 ### Fixed
diff --git a/public/css/advancedforms.css b/public/css/advancedforms.css
index 866d883..2ba303c 100644
--- a/public/css/advancedforms.css
+++ b/public/css/advancedforms.css
@@ -33,3 +33,44 @@
 [data-glpi-form-editor-active-question] [data-ldap-question-preview] {
         display: none !important;
 }
+
+[data-glpi-form-editor-question]:has([data-af-table-admin]) label.form-check:has([data-glpi-form-editor-original-name="is_mandatory"]) {
+    display: none !important;
+}
+
+[data-af-table-column] .select2-selection--single .select2-selection__rendered,
+[data-af-table-question] td .select2-selection--single .select2-selection__rendered {
+    display: flex !important;
+    align-items: center !important;
+    line-height: normal !important;
+    direction: ltr !important;
+    height: 100% !important;
+}
+[data-af-table-column] .select2-selection--single .select2-selection__rendered::before,
+[data-af-table-question] td .select2-selection--single .select2-selection__rendered::before {
+    display: none !important;
+}
+
+.af-required-toggle {
+    display: inline-flex;
+    align-items: center;
+    color: var(--tblr-secondary);
+}
+.af-required-toggle:hover {
+    color: var(--tblr-body-color);
+}
+.af-required-toggle:has(:checked) {
+    color: var(--tblr-danger);
+}
+.af-required-toggle:has(:focus-visible) {
+    outline: 2px solid var(--tblr-primary);
+    outline-offset: 2px;
+    border-radius: var(--tblr-border-radius);
+}
+
+[data-af-table-question]:has(select.is-invalid) td:not(:has(select.is-invalid)) .select2-container--default .select2-selection {
+    border-color: var(--tblr-border-color) !important;
+}
+[data-af-table-question] td:has(select.is-invalid) .select2-container--default .select2-selection {
+    border-color: var(--tblr-form-invalid-border-color) !important;
+}
diff --git a/public/js/modules/AfTableQuestion.js b/public/js/modules/AfTableQuestion.js
new file mode 100644
index 0000000..8879073
--- /dev/null
+++ b/public/js/modules/AfTableQuestion.js
@@ -0,0 +1,245 @@
+/**
+ * -------------------------------------------------------------------------
+ * advancedforms plugin for GLPI
+ * -------------------------------------------------------------------------
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * -------------------------------------------------------------------------
+ * @copyright Copyright (C) 2025 by the advancedforms plugin team.
+ * @license   MIT https://opensource.org/licenses/mit-license.php
+ * @link      https://github.com/pluginsGLPI/advancedforms
+ * -------------------------------------------------------------------------
+ */
+
+export class AfTableQuestion {
+    static #submitGuardRegistered = false;
+
+    #table;
+    #body;
+    #template;
+    #addBtn;
+    #minRows;
+    #maxRows;
+
+    constructor(tableElement) {
+        this.#table    = tableElement;
+        this.#body     = tableElement.querySelector('[data-af-table-body]');
+        this.#template = tableElement.querySelector('[data-af-table-row-template]');
+        this.#addBtn   = tableElement.querySelector('[data-af-table-add-row]');
+        this.#minRows  = parseInt(tableElement.dataset.afMinRows, 10) || 1;
+        this.#maxRows  = parseInt(tableElement.dataset.afMaxRows, 10) || 50;
+
+        if (!this.#body || !this.#template || !this.#addBtn) {
+            return;
+        }
+
+        this.#addBtn.addEventListener('click', () => this.addRow());
+        this.#body.addEventListener('click', e => {
+            const btn = e.target.closest('[data-af-table-remove-row]');
+            if (btn) {
+                this.removeRow(btn.closest('[data-af-table-row]'));
+            }
+        });
+        // Clear a cell's error state as soon as the user fills it.
+        const clear = e => AfTableQuestion.#clearCellError(e.target);
+        this.#body.addEventListener('input', clear);
+        if (window.$) {
+            // select2 fires its "change" through jQuery, which native
+            // addEventListener('change') handlers never receive.
+            window.$(this.#body).on('change', clear);
+        } else {
+            this.#body.addEventListener('change', clear);
+        }
+        this.#updateButtonStates();
+
+        AfTableQuestion.#registerSubmitGuard();
+    }
+
+    static #registerSubmitGuard() {
+        if (AfTableQuestion.#submitGuardRegistered) { return; }
+        AfTableQuestion.#submitGuardRegistered = true;
+
+        document.addEventListener('click', e => {
+            const trigger = e.target.closest('[data-glpi-form-renderer-action=submit]');
+            if (!trigger) { return; }
+
+            const scope = trigger.closest('form') ?? document;
+            let firstInvalid = null;
+            scope.querySelectorAll('[data-af-table-question]').forEach(table => {
+                const invalid = AfTableQuestion.#validateTable(table);
+                if (invalid && !firstInvalid) { firstInvalid = invalid; }
+            });
+
+            if (firstInvalid) {
+                e.preventDefault();
+                e.stopImmediatePropagation();
+                // Scroll to the cell, as a select2-managed <select> is itself hidden.
+                (firstInvalid.closest('td') ?? firstInvalid)
+                    .scrollIntoView({ behavior: 'smooth', block: 'center' });
+            }
+        }, true);
+    }
+
+    /**
+     * @returns {Element|null} the first invalid control of the table, or null.
+     */
+    static #validateTable(table) {
+        // Skip tables hidden by step-by-step navigation or conditional sections.
+        if (table.offsetParent === null) { return null; }
+
+        const requiredCols = (table.dataset.afRequiredCols ?? '')
+            .split(',')
+            .filter(value => value !== '');
+        if (requiredCols.length === 0) { return null; }
+
+        let firstInvalid = null;
+        table.querySelectorAll('[data-af-table-row]').forEach(row => {
+            const controls = AfTableQuestion.#rowControls(row);
+            const rowHasValue = controls.some(control => AfTableQuestion.#hasValue(control));
+
+            controls.forEach(control => {
+                const colIndex = AfTableQuestion.#columnIndex(control);
+                const invalid = rowHasValue
+                    && requiredCols.includes(colIndex)
+                    && !AfTableQuestion.#hasValue(control);
+                control.classList.toggle('is-invalid', invalid);
+                if (invalid && !firstInvalid) { firstInvalid = control; }
+            });
+        });
+
+        AfTableQuestion.#toggleTableError(table, firstInvalid !== null);
+        return firstInvalid;
+    }
+
+    /** @returns {Element[]} */
+    static #rowControls(row) {
+        return Array.from(row.querySelectorAll(
+            'input[name]:not([type=hidden]):not(.select2-search__field), select[name]',
+        ));
+    }
+
+    static #hasValue(control) {
+        if (control.type === 'checkbox' || control.type === 'radio') {
+            return control.checked;
+        }
+        return (control.value ?? '').trim() !== '';
+    }
+
+    /** Extracts the "col_N" index from a cell control name, as a string. */
+    static #columnIndex(control) {
+        const match = /\[col_(\d+)\]/.exec(control.name ?? '');
+        return match ? match[1] : '';
+    }
+
+    static #clearCellError(control) {
+        if (!control?.classList?.contains('is-invalid')) { return; }
+        control.classList.remove('is-invalid');
+
+        const table = control.closest('[data-af-table-question]');
+        if (table && !table.querySelector('.is-invalid')) {
+            AfTableQuestion.#toggleTableError(table, false);
+        }
+    }
+
+    static #toggleTableError(table, show) {
+        let message = table.querySelector('[data-af-table-error]');
+        if (!show) {
+            message?.remove();
+            return;
+        }
+        if (!message) {
+            message = document.createElement('div');
+            message.setAttribute('data-af-table-error', '');
+            message.className = 'invalid-feedback d-block';
+            message.textContent = table.dataset.afRequiredMsg ?? '';
+            table.appendChild(message);
+        }
+    }
+
+    addRow() {
+        const rowCount = this.#rowCount();
+        if (rowCount >= this.#maxRows) {
+            return;
+        }
+        const clone = this.#template.content.cloneNode(true);
+        clone.querySelectorAll('[name]').forEach(el => {
+            el.name = el.name.replace('__ROW__', rowCount);
+        });
+        this.#body.appendChild(clone);
+        this.#initSelectsInRow(this.#body.lastElementChild);
+        this.#updateButtonStates();
+    }
+
+    #initSelectsInRow(row) {
+        if (!row || !window.setupAdaptDropdown) { return; }
+        const limit = parseInt(this.#table.dataset.afS2Limit, 10) || 100;
+        row.querySelectorAll('[data-af-needs-s2]').forEach(select => {
+            const id = 'dropdown_af_eu_' + Date.now() + '_' + Math.random().toString(36).slice(2, 7);
+            select.id = id;
+            const config = {
+                type: 'adapt',
+                field_id: id,
+                width: '100%',
+                dropdown_css_class: '',
+                placeholder: '',
+                ajax_limit_count: limit,
+            };
+            window.select2_configs = window.select2_configs || {};
+            window.select2_configs[id] = config;
+            window.setupAdaptDropdown(config);
+        });
+    }
+
+    removeRow(rowElement) {
+        if (!rowElement || this.#rowCount() <= this.#minRows) {
+            return;
+        }
+        rowElement.remove();
+        this.#reindexRows();
+        this.#updateButtonStates();
+    }
+
+    #reindexRows() {
+        this.#body.querySelectorAll('[data-af-table-row]').forEach((row, i) => {
+            row.querySelectorAll('[name]').forEach(el => {
+                el.name = el.name.replace(/\[\d+\]/, `[${i}]`);
+            });
+        });
+    }
+
+    #updateButtonStates() {
+        const count = this.#rowCount();
+        const atMax = count >= this.#maxRows;
+        const atMin = count <= this.#minRows;
+
+        this.#addBtn.classList.toggle('opacity-25', atMax);
+        this.#addBtn.classList.toggle('pe-none',    atMax);
+
+        this.#body.querySelectorAll('[data-af-table-remove-row]').forEach(icon => {
+            icon.classList.toggle('opacity-25', atMin);
+            icon.classList.toggle('pe-none',    atMin);
+        });
+    }
+
+    #rowCount() {
+        return this.#body.querySelectorAll('[data-af-table-row]').length;
+    }
+}
diff --git a/public/js/modules/AfTableQuestionConfig.js b/public/js/modules/AfTableQuestionConfig.js
new file mode 100644
index 0000000..f65718c
--- /dev/null
+++ b/public/js/modules/AfTableQuestionConfig.js
@@ -0,0 +1,171 @@
+/**
+ * -------------------------------------------------------------------------
+ * advancedforms plugin for GLPI
+ * -------------------------------------------------------------------------
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * -------------------------------------------------------------------------
+ * @copyright Copyright (C) 2025 by the advancedforms plugin team.
+ * @license   MIT https://opensource.org/licenses/mit-license.php
+ * @link      https://github.com/pluginsGLPI/advancedforms
+ * -------------------------------------------------------------------------
+ */
+
+export class AfTableQuestionConfig {
+    static #delegationRegistered = false;
+
+    constructor() {
+        AfTableQuestionConfig.#register();
+    }
+
+    static #register() {
+        if (AfTableQuestionConfig.#delegationRegistered) { return; }
+        AfTableQuestionConfig.#delegationRegistered = true;
+
+        document.addEventListener('shown.bs.dropdown', (e) => {
+            const dropdown = e.target.closest('.dropdown');
+            if (!dropdown) { return; }
+            const container = dropdown.querySelector('[data-af-table-columns-container]');
+            if (!container || container.dataset.afTableInited) { return; }
+            container.dataset.afTableInited = '1';
+
+            const cardBody = container.closest('.card-body');
+            if (!cardBody) { return; }
+            const template = cardBody.querySelector('[data-af-table-column-template]');
+            const addBtn = cardBody.querySelector('[data-af-table-column-add]');
+
+            AfTableQuestionConfig.#bindRemoveButtons(container);
+
+            // Bind itemtype visibility for all existing columns
+            container.querySelectorAll('[data-af-table-column]').forEach(row => {
+                AfTableQuestionConfig.#bindItemtypeVisibility(row);
+            });
+
+            if (addBtn && template) {
+                addBtn.addEventListener('click', () => {
+                    AfTableQuestionConfig.#addColumn(container, template);
+                });
+            }
+        });
+    }
+
+    static #addColumn(container, template) {
+        if (!container || !template) { return; }
+        const index = container.querySelectorAll('[data-af-table-column]').length;
+        const clone = template.content.cloneNode(true);
+        clone.querySelectorAll('[name]').forEach(el => {
+            el.name = el.name.replace('__INDEX__', index);
+        });
+        container.appendChild(clone);
+        const newRow = container.lastElementChild;
+        AfTableQuestionConfig.#bindRemoveButtons(newRow);
+        AfTableQuestionConfig.#reindex(container);
+
+        const newSelect = newRow.querySelector('[data-af-table-type-select]');
+        AfTableQuestionConfig.#initNewColumnSelect(newSelect, container.dataset.afTableColumnsContainer);
+        AfTableQuestionConfig.#bindItemtypeVisibility(newRow);
+    }
+
+    static #initNewColumnSelect(select, rand) {
+        if (!select || !rand || !window.setupAdaptDropdown) { return; }
+        const templateConfig = window.select2_configs?.['af-table-type-template-' + rand];
+        if (!templateConfig) { return; }
+        const newId = 'dropdown_af_table_type_' + rand + '_' + Date.now() + '_' + Math.random().toString(36).slice(2, 7);
+        select.id = newId;
+        const config = { ...templateConfig, field_id: newId };
+        window.select2_configs[newId] = config;
+        window.setupAdaptDropdown(config);
+    }
+
+    static #bindItemtypeVisibility(columnRow) {
+        const typeSelect = columnRow.querySelector('select[name*="[question_type]"]');
+        if (!typeSelect) { return; }
+
+        const container = columnRow.closest('[data-af-table-columns-container]');
+        const rand = container?.dataset.afTableColumnsContainer;
+
+        const update = () => {
+            const selected = typeSelect.value;
+            columnRow.querySelectorAll('[data-af-itemtype-wrapper]').forEach(wrapper => {
+                const show = wrapper.dataset.afItemtypeWrapper === selected;
+                wrapper.style.display = show ? '' : 'none';
+                const sel = wrapper.querySelector('select');
+                if (!sel) { return; }
+                sel.disabled = !show;
+                if (!show) {
+                    // Clear value without triggering Select2 events to keep state clean
+                    sel.value = '';
+                    if (sel.dataset.afS2Inited && window.$) {
+                        window.$(sel).val('').trigger('change.select2');
+                    }
+                    return;
+                }
+                if (!sel.dataset.afS2Inited) {
+                    sel.dataset.afS2Inited = '1';
+                    AfTableQuestionConfig.#initItemtypeSelect(sel, rand);
+                }
+            });
+        };
+
+        typeSelect.addEventListener('change', update);
+        update();
+    }
+
+    static #initItemtypeSelect(select, rand) {
+        if (!select || !window.setupAdaptDropdown) { return; }
+        if (!select.id) {
+            select.id = 'dropdown_af_itemtype_' + Date.now() + '_' + Math.random().toString(36).slice(2, 7);
+        }
+        const templateConfig = window.select2_configs?.['af-table-type-template-' + rand];
+        const config = {
+            type: 'adapt',
+            field_id: select.id,
+            width: '170px',
+            dropdown_css_class: '',
+            placeholder: select.querySelector('option[value=""]')?.textContent?.trim() ?? '',
+            ajax_limit_count: templateConfig?.ajax_limit_count ?? 100,
+        };
+        window.select2_configs = window.select2_configs || {};
+        window.select2_configs[select.id] = config;
+        window.setupAdaptDropdown(config);
+    }
+
+    static #bindRemoveButtons(scope) {
+        if (!scope) { return; }
+        scope.querySelectorAll('[data-af-table-column-remove]').forEach(btn => {
+            if (btn.dataset.afRemoveBound) { return; }
+            btn.dataset.afRemoveBound = '1';
+            btn.addEventListener('click', () => {
+                const container = btn.closest('[data-af-table-columns-container]');
+                btn.closest('[data-af-table-column]')?.remove();
+                if (container) { AfTableQuestionConfig.#reindex(container); }
+            });
+        });
+    }
+
+    static #reindex(container) {
+        container.querySelectorAll('[data-af-table-column]').forEach((row, i) => {
+            row.querySelectorAll('[name]').forEach(el => {
+                el.name = el.name.replace(/\[columns\]\[\d+\]/, `[columns][${i}]`);
+            });
+        });
+    }
+}
diff --git a/src/Model/QuestionType/TableQuestion.php b/src/Model/QuestionType/TableQuestion.php
new file mode 100644
index 0000000..0890c47
--- /dev/null
+++ b/src/Model/QuestionType/TableQuestion.php
@@ -0,0 +1,845 @@
+<?php
+
+/**
+ * -------------------------------------------------------------------------
+ * advancedforms plugin for GLPI
+ * -------------------------------------------------------------------------
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * -------------------------------------------------------------------------
+ * @copyright Copyright (C) 2025 by the advancedforms plugin team.
+ * @license   MIT https://opensource.org/licenses/mit-license.php
+ * @link      https://github.com/pluginsGLPI/advancedforms
+ * -------------------------------------------------------------------------
+ */
+
+namespace GlpiPlugin\Advancedforms\Model\QuestionType;
+
+use Glpi\Form\QuestionType\QuestionTypeFile;
+use Glpi\Form\QuestionType\QuestionTypeDateTime;
+use Glpi\Form\QuestionType\QuestionTypeRadio;
+use Glpi\Form\QuestionType\QuestionTypeDropdown;
+use Glpi\Form\QuestionType\QuestionTypeUrgency;
+use CommonItilObject_Item;
+use Dropdown;
+use Glpi\Application\View\TemplateRenderer;
+use Glpi\Form\Question;
+use Glpi\Form\QuestionType\AbstractQuestionType;
+use Glpi\Form\QuestionType\AbstractQuestionTypeActors;
+use Glpi\Form\QuestionType\AbstractQuestionTypeSelectable;
+use Glpi\Form\QuestionType\AbstractQuestionTypeShortAnswer;
+use Glpi\Form\QuestionType\QuestionTypeCategoryInterface;
+use Glpi\Form\QuestionType\QuestionTypeInterface;
+use Glpi\Form\QuestionType\QuestionTypeItem;
+use Glpi\Form\QuestionType\QuestionTypeItemDropdown;
+use Glpi\Form\QuestionType\QuestionTypeRequestType;
+use Glpi\Form\QuestionType\QuestionTypeUserDevice;
+use Glpi\Form\QuestionType\QuestionTypesManager;
+use Glpi\Form\QuestionType\QuestionTypeValidationInterface;
+use Glpi\Form\QuestionType\RawAnswerIsHtmlInterface;
+use Glpi\Form\ValidationResult;
+use GlpiPlugin\Advancedforms\Model\Config\ConfigurableItemInterface;
+use GlpiPlugin\Advancedforms\Model\QuestionType\LdapQuestion;
+use Override;
+use Session;
+use User;
+
+use function Safe\json_decode;
+use function Safe\json_encode;
+
+final class TableQuestion extends AbstractQuestionType implements
+    ConfigurableItemInterface,
+    QuestionTypeValidationInterface,
+    RawAnswerIsHtmlInterface
+{
+    #[Override]
+    public function getCategory(): QuestionTypeCategoryInterface
+    {
+        return new AdvancedCategory();
+    }
+
+    #[Override]
+    public function getName(): string
+    {
+        return __('Table', 'advancedforms');
+    }
+
+    #[Override]
+    public function getIcon(): string
+    {
+        return 'ti ti-table';
+    }
+
+    #[Override]
+    public function getWeight(): int
+    {
+        return 50;
+    }
+
+    #[Override]
+    public function getExtraDataConfigClass(): string
+    {
+        return TableQuestionConfig::class;
+    }
+
+    /** @param array<mixed> $input */
+    #[Override]
+    public function validateExtraDataInput(array $input): bool
+    {
+        $columns = $input[TableQuestionConfig::COLUMNS] ?? [];
+        if (!is_array($columns) || $columns === []) {
+            return false;
+        }
+
+        $manager = QuestionTypesManager::getInstance();
+        foreach ($columns as $col) {
+            if (!is_array($col)) {
+                return false;
+            }
+
+            $name = $col[TableQuestionConfig::COL_NAME] ?? '';
+            if (!is_string($name) || $name === '') {
+                return false;
+            }
+
+            $fqcn = $col[TableQuestionConfig::COL_QUESTION_TYPE] ?? '';
+            if (!is_string($fqcn) || !$manager->isValidQuestionType($fqcn)) {
+                return false;
+            }
+        }
+
+        $min_raw = $input[TableQuestionConfig::MIN_ROWS] ?? 1;
+        $max_raw = $input[TableQuestionConfig::MAX_ROWS] ?? 50;
+        $min = is_numeric($min_raw) ? (int) $min_raw : 1;
+        $max = is_numeric($max_raw) ? (int) $max_raw : 50;
+        return $min >= 1 && $max >= $min && $max <= 50;
+    }
+
+    /** @param array<mixed> $input */
+    #[Override]
+    public function prepareExtraData(array $input): array
+    {
+        $columns = array_values(array_map(
+            static function (mixed $col): array {
+                $col      = is_array($col) ? $col : [];
+                $name     = $col[TableQuestionConfig::COL_NAME] ?? '';
+                $type     = $col[TableQuestionConfig::COL_QUESTION_TYPE] ?? '';
+                $itemtype = $col[TableQuestionConfig::COL_ITEMTYPE] ?? '';
+                return [
+                    TableQuestionConfig::COL_NAME          => is_scalar($name) ? (string) $name : '',
+                    TableQuestionConfig::COL_QUESTION_TYPE => is_scalar($type) ? (string) $type : '',
+                    TableQuestionConfig::COL_REQUIRED      => (bool) ($col[TableQuestionConfig::COL_REQUIRED] ?? false),
+                    TableQuestionConfig::COL_ITEMTYPE      => is_scalar($itemtype) ? (string) $itemtype : '',
+                ];
+            },
+            array_filter((array) ($input[TableQuestionConfig::COLUMNS] ?? []), is_array(...)),
+        ));
+
+        $min_raw = $input[TableQuestionConfig::MIN_ROWS] ?? 1;
+        $max_raw = $input[TableQuestionConfig::MAX_ROWS] ?? 50;
+        $min = max(1, is_numeric($min_raw) ? (int) $min_raw : 1);
+        $max = min(50, max($min, is_numeric($max_raw) ? (int) $max_raw : 50));
+
+        return [
+            TableQuestionConfig::COLUMNS  => $columns,
+            TableQuestionConfig::MIN_ROWS => $min,
+            TableQuestionConfig::MAX_ROWS => $max,
+        ];
+    }
+
+    #[Override]
+    public function prepareEndUserAnswer(Question $question, mixed $answer): mixed
+    {
+        if (!is_array($answer)) {
+            return [];
+        }
+
+        // Drop entirely empty rows so blank rows are not persisted.
+        // Mandatory columns are enforced by validateAnswer() before submission.
+        $result = [];
+        foreach ($answer as $row) {
+            if (is_array($row) && $this->rowHasValue($row)) {
+                $result[] = $row;
+            }
+        }
+
+        return $result;
+    }
+
+    #[Override]
+    public function validateAnswer(Question $question, mixed $answer): ValidationResult
+    {
+        $result = new ValidationResult();
+        if (!is_array($answer)) {
+            return $result;
+        }
+
+        $required_columns = [];
+        foreach ($this->loadConfig($question)->getColumns() as $index => $col) {
+            if ($col[TableQuestionConfig::COL_REQUIRED]) {
+                $required_columns[$index] = $col[TableQuestionConfig::COL_NAME];
+            }
+        }
+
+        if ($required_columns === []) {
+            return $result;
+        }
+
+        $row_number = 0;
+        foreach ($answer as $row) {
+            if (!is_array($row)) {
+                continue;
+            }
+
+            $row_number++;
+
+            // Entirely empty rows are dropped on save, so they are not validated.
+            if (!$this->rowHasValue($row)) {
+                continue;
+            }
+
+            foreach ($required_columns as $index => $name) {
+                $value = $row['col_' . $index] ?? '';
+                if (!is_scalar($value) || (string) $value === '') {
+                    $result->addError($question, sprintf(
+                        __('Row %1$s: the column "%2$s" is required.', 'advancedforms'),
+                        $row_number,
+                        $name,
+                    ));
+                }
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * @param array<array-key, mixed> $row
+     */
+    private function rowHasValue(array $row): bool
+    {
+        foreach ($row as $value) {
+            if ($value !== '' && $value !== null) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    #[Override]
+    public function formatRawAnswer(mixed $answer, Question $question): string
+    {
+        $rows = $this->normalizeRawAnswerRows($answer);
+        if ($rows === []) {
+            return '';
+        }
+
+        $columns = $this->loadConfig($question)->getColumns();
+        if ($columns === []) {
+            return '';
+        }
+
+        $twig = TemplateRenderer::getInstance();
+        return $twig->render('@advancedforms/table_answer.html.twig', [
+            'headers' => array_map(
+                static fn(array $col): string => $col[TableQuestionConfig::COL_NAME],
+                $columns,
+            ),
+            'rows' => $this->buildDisplayRows($rows, $columns),
+        ]);
+    }
+
+    /**
+     * GLPI stores the raw answer via a JSON roundtrip, so it may already be a
+     * decoded array by the time formatRawAnswer() is called, or still a JSON string.
+     *
+     * @return list<array<array-key, mixed>>
+     */
+    private function normalizeRawAnswerRows(mixed $answer): array
+    {
+        if (is_array($answer)) {
+            $rows = $answer;
+        } elseif (is_string($answer) && $answer !== '') {
+            $decoded = json_decode($answer, associative: true);
+            $rows    = is_array($decoded) ? $decoded : [];
+        } else {
+            $rows = [];
+        }
+
+        return array_values(array_filter($rows, is_array(...)));
+    }
+
+    /**
+     * Resolves stored cell values into display labels, batching DB access so each
+     * column triggers at most one query instead of one query per cell.
+     *
+     * @param list<array<array-key, mixed>> $rows
+     * @param array<array{name: string, question_type: string, required: bool, itemtype: string}> $columns
+     * @return list<list<string>>
+     */
+    private function buildDisplayRows(array $rows, array $columns): array
+    {
+        $label_maps = [];
+        foreach ($columns as $index => $col) {
+            $label_maps[$index] = $this->buildColumnLabelMap(
+                $col[TableQuestionConfig::COL_QUESTION_TYPE],
+                $col[TableQuestionConfig::COL_ITEMTYPE] ?? '',
+                $this->collectColumnValues($rows, $index),
+            );
+        }
+
+        $display_rows = [];
+        foreach ($rows as $row) {
+            $cells = [];
+            foreach (array_keys($columns) as $index) {
+                $raw     = $row['col_' . $index] ?? '';
+                $value   = is_scalar($raw) ? (string) $raw : '';
+                $cells[] = $value === '' ? '' : ($label_maps[$index][$value] ?? $value);
+            }
+
+            $display_rows[] = $cells;
+        }
+
+        return $display_rows;
+    }
+
+    /**
+     * @param list<array<array-key, mixed>> $rows
+     * @return list<string> Unique non-empty stored values found in the column.
+     */
+    private function collectColumnValues(array $rows, int $index): array
+    {
+        // Collected into a list (not array keys) so numeric values such as "1"
+        // stay strings instead of being coerced to int array keys.
+        $values = [];
+        foreach ($rows as $row) {
+            $raw   = $row['col_' . $index] ?? '';
+            $value = is_scalar($raw) ? (string) $raw : '';
+            if ($value !== '' && !in_array($value, $values, true)) {
+                $values[] = $value;
+            }
+        }
+
+        return $values;
+    }
+
+    /**
+     * Builds a [stored value => display label] map for a column.
+     * An empty map means the stored value is displayed as-is.
+     *
+     * @param list<string> $values Unique non-empty stored values to resolve.
+     * @return array<array-key, string>
+     */
+    private function buildColumnLabelMap(string $fqcn, string $itemtype, array $values): array
+    {
+        return match (true) {
+            $values === [] => [],
+            is_a($fqcn, AbstractQuestionTypeSelectable::class, true) => in_array('1', $values, true) ? ['1' => __('Yes')] : [],
+            is_a($fqcn, AbstractQuestionTypeActors::class, true)     => $this->resolveUserNames($values),
+            is_a($fqcn, QuestionTypeUserDevice::class, true)         => $this->resolveDeviceNames($values),
+            is_a($fqcn, QuestionTypeItem::class, true)               => $this->resolveItemNames($itemtype, $values),
+            default => [],
+        };
+    }
+
+    /**
+     * @param list<string> $values
+     * @return array<array-key, string>
+     */
+    private function resolveUserNames(array $values): array
+    {
+        $ids = $this->toPositiveIds($values);
+        if ($ids === []) {
+            return [];
+        }
+
+        global $DB;
+
+        $map = [];
+        foreach ($DB->request([
+            'SELECT' => ['id', 'name', 'realname', 'firstname'],
+            'FROM'   => User::getTable(),
+            'WHERE'  => ['id' => $ids],
+        ]) as $row) {
+            if (!is_array($row)) {
+                continue;
+            }
+
+            $id = is_numeric($row['id']) ? (int) $row['id'] : 0;
+            $map[(string) $id] = formatUserName(
+                $id,
+                is_string($row['name'] ?? null) ? $row['name'] : null,
+                is_string($row['realname'] ?? null) ? $row['realname'] : null,
+                is_string($row['firstname'] ?? null) ? $row['firstname'] : null,
+            );
+        }
+
+        return $map;
+    }
+
+    /**
+     * @param list<string> $values
+     * @return array<array-key, string>
+     */
+    private function resolveItemNames(string $itemtype, array $values): array
+    {
+        if ($itemtype === '' || !class_exists($itemtype)) {
+            return [];
+        }
+
+        $item = getItemForItemtype($itemtype);
+        if ($item === false) {
+            return [];
+        }
+
+        $ids = $this->toPositiveIds($values);
+        if ($ids === []) {
+            return [];
+        }
+
+        global $DB;
+
+        $map = [];
+        foreach ($DB->request([
+            'SELECT' => ['id', 'name'],
+            'FROM'   => $item->getTable(),
+            'WHERE'  => ['id' => $ids],
+        ]) as $row) {
+            if (!is_array($row)) {
+                continue;
+            }
+
+            $id = is_numeric($row['id']) ? (int) $row['id'] : 0;
+            $map[(string) $id] = is_string($row['name'] ?? null) ? $row['name'] : (string) $id;
+        }
+
+        return $map;
+    }
+
+    /**
+     * @param list<string> $values "Itemtype_id" strings as produced by getMyDevices().
+     * @return array<array-key, string>
+     */
+    private function resolveDeviceNames(array $values): array
+    {
+        global $DB;
+
+        // Group ids by device itemtype so each itemtype is queried only once.
+        $ids_by_itemtype = [];
+        foreach ($values as $value) {
+            if (!str_contains($value, '_')) {
+                continue;
+            }
+
+            [$device_itemtype, $device_id] = explode('_', $value, 2);
+            if (!is_numeric($device_id) || !class_exists($device_itemtype)) {
+                continue;
+            }
+
+            $ids_by_itemtype[$device_itemtype][] = (int) $device_id;
+        }
+
+        $map = [];
+        foreach ($ids_by_itemtype as $device_itemtype => $ids) {
+            $item = getItemForItemtype($device_itemtype);
+            if ($item === false) {
+                continue;
+            }
+
+            foreach ($DB->request([
+                'SELECT' => ['id', 'name'],
+                'FROM'   => $item->getTable(),
+                'WHERE'  => ['id' => $ids],
+            ]) as $row) {
+                if (!is_array($row)) {
+                    continue;
+                }
+
+                $id   = is_numeric($row['id']) ? (int) $row['id'] : 0;
+                $name = is_string($row['name'] ?? null) ? $row['name'] : '';
+                if ($name !== '') {
+                    $map[$device_itemtype . '_' . $id] = $name;
+                }
+            }
+        }
+
+        return $map;
+    }
+
+    /**
+     * @param list<string> $values
+     * @return list<int> Strictly positive integer ids.
+     */
+    private function toPositiveIds(array $values): array
+    {
+        return array_values(array_filter(
+            array_map(static fn(string $value): int => (int) $value, $values),
+            static fn(int $id): bool => $id > 0,
+        ));
+    }
+
+    #[Override]
+    public static function getConfigKey(): string
+    {
+        return 'enable_question_type_table';
+    }
+
+    #[Override]
+    public function getConfigTitle(): string
+    {
+        return __('Table question type', 'advancedforms');
+    }
+
+    #[Override]
+    public function getConfigDescription(): string
+    {
+        return __('Allow users to fill in tabular data with configurable columns.', 'advancedforms');
+    }
+
+    #[Override]
+    public function getConfigIcon(): string
+    {
+        return $this->getIcon();
+    }
+
+    #[Override]
+    public function renderAdministrationTemplate(Question|null $question): string
+    {
+        $config = ($question instanceof Question)
+            ? $this->loadConfig($question)
+            : new TableQuestionConfig();
+
+        $twig = TemplateRenderer::getInstance();
+        return $twig->render(
+            '@advancedforms/editor/question_types/table_admin.html.twig',
+            [
+                'question'        => $question,
+                'config'          => $config,
+                'advanced_config' => $this->renderAdvancedConfigurationTemplate($question),
+            ],
+        );
+    }
+
+    #[Override]
+    public function renderAdvancedConfigurationTemplate(?Question $question): string
+    {
+        $config = ($question instanceof Question)
+            ? $this->loadConfig($question)
+            : new TableQuestionConfig();
+
+        $compatible_types = $this->getCompatibleQuestionTypes();
+
+        // FQCN => icon class, consumed by the select2 formatter defined in the template.
+        $icons = [];
+        foreach (QuestionTypesManager::getInstance()->getQuestionTypes() as $type) {
+            $fqcn = $type::class;
+            if (isset($compatible_types[$fqcn])) {
+                $icons[$fqcn] = $type->getIcon();
+            }
+        }
+
+        $itemtype_options = [
+            QuestionTypeItem::class => Dropdown::buildItemtypesDropdownOptions(
+                (new QuestionTypeItem())->getAllowedItemtypes(),
+            ),
+            QuestionTypeItemDropdown::class => Dropdown::buildItemtypesDropdownOptions(
+                (new QuestionTypeItemDropdown())->getAllowedItemtypes(),
+            ),
+        ];
+
+        $twig = TemplateRenderer::getInstance();
+        return $twig->render(
+            '@advancedforms/editor/question_types/table_config.html.twig',
+            [
+                'question'          => $question,
+                'config'            => $config,
+                'compatible_types'  => $compatible_types,
+                'icons_json'        => json_encode($icons),
+                'ajax_limit_count'  => $this->ajaxLimitCount(),
+                'COL_NAME'          => TableQuestionConfig::COL_NAME,
+                'COL_QUESTION_TYPE' => TableQuestionConfig::COL_QUESTION_TYPE,
+                'COL_REQUIRED'      => TableQuestionConfig::COL_REQUIRED,
+                'COL_ITEMTYPE'      => TableQuestionConfig::COL_ITEMTYPE,
+                'MIN_ROWS'          => TableQuestionConfig::MIN_ROWS,
+                'MAX_ROWS'          => TableQuestionConfig::MAX_ROWS,
+                'itemtype_options'  => $itemtype_options,
+            ],
+        );
+    }
+
+    #[Override]
+    public function renderEndUserTemplate(Question $question): string
+    {
+        $config = $this->loadConfig($question);
+
+        $type_instances = [];
+        foreach (QuestionTypesManager::getInstance()->getQuestionTypes() as $type) {
+            $type_instances[$type::class] = $type;
+        }
+
+        $cell_map           = [];
+        $user_options       = null;
+        $device_options     = null;
+        $glpi_item_options  = []; // keyed by itemtype FQCN to avoid duplicate DB queries
+
+        foreach ($config->getColumns() as $index => $col) {
+            $fqcn     = $col[TableQuestionConfig::COL_QUESTION_TYPE];
+            $type     = $type_instances[$fqcn] ?? null;
+            $itemtype = $col[TableQuestionConfig::COL_ITEMTYPE] ?? '';
+
+            if (is_a($fqcn, AbstractQuestionTypeActors::class, true)) {
+                $user_options     ??= $this->buildUserOptions();
+                $cell_map[$index]  = ['mode' => 'select', 'options' => $user_options];
+            } elseif (is_a($fqcn, QuestionTypeUserDevice::class, true)) {
+                $device_options   ??= $this->buildUserDeviceOptions();
+                $cell_map[$index]  = ['mode' => 'select', 'options' => $device_options];
+            } elseif (is_a($fqcn, QuestionTypeItem::class, true)) {
+                if ($itemtype !== '' && class_exists($itemtype)) {
+                    $glpi_item_options[$itemtype] ??= $this->buildGlpiItemtypeOptions($itemtype);
+                    $cell_map[$index] = ['mode' => 'select', 'options' => $glpi_item_options[$itemtype]];
+                } else {
+                    $cell_map[$index] = ['mode' => 'input', 'input_type' => 'text'];
+                }
+            } else {
+                $cell_map[$index]  = $this->getCellInfo($fqcn, $type);
+            }
+        }
+
+        $twig = TemplateRenderer::getInstance();
+        return $twig->render(
+            '@advancedforms/table_end_user.html.twig',
+            [
+                'question'         => $question,
+                'config'           => $config,
+                'column_cell_map'  => $cell_map,
+                'ajax_limit_count' => $this->ajaxLimitCount(),
+            ],
+        );
+    }
+
+    /**
+     * Resolves the configured select2 AJAX result limit, falling back to 100.
+     */
+    private function ajaxLimitCount(): int
+    {
+        global $CFG_GLPI;
+
+        $value = $CFG_GLPI['ajax_limit_count'] ?? 100;
+        return is_numeric($value) ? (int) $value : 100;
+    }
+
+    /**
+     * Returns question types compatible with a table cell column.
+     * Key = FQCN, Value = display name.
+     *
+     * @return array<string, string>
+     */
+    public function getCompatibleQuestionTypes(): array
+    {
+        // is_a() is used (not in_array) so subclasses of an excluded type are rejected too,
+        // even when their parent type stays compatible (QuestionTypeItemDropdown is allowed).
+        $excluded = [
+            QuestionTypeFile::class,
+            QuestionTypeDateTime::class,
+            QuestionTypeRadio::class,
+            QuestionTypeDropdown::class,
+            QuestionTypeUrgency::class,
+            QuestionTypeRequestType::class,
+            TreeCascadeDropdownQuestion::class,
+            IpAddressQuestion::class,
+            HostnameQuestion::class,
+            HiddenQuestion::class,
+            LdapQuestion::class,
+            self::class,
+        ];
+
+        $types = [];
+        foreach (QuestionTypesManager::getInstance()->getQuestionTypes() as $type) {
+            $fqcn = $type::class;
+            foreach ($excluded as $excluded_fqcn) {
+                if (is_a($fqcn, $excluded_fqcn, true)) {
+                    continue 2;
+                }
+            }
+
+            $types[$fqcn] = $type->getName();
+        }
+
+        return $types;
+    }
+
+    /**
+     * Returns how a table cell should be rendered for the given question type FQCN.
+     *
+     * @param ?QuestionTypeInterface $type Pre-resolved instance; instantiated from $fqcn when null.
+     * @return array{mode: string, input_type?: string, options?: array<string, string>}
+     */
+    public function getCellInfo(string $fqcn, ?QuestionTypeInterface $type = null): array
+    {
+        if (!$type instanceof QuestionTypeInterface) {
+            foreach (QuestionTypesManager::getInstance()->getQuestionTypes() as $instance) {
+                if ($instance::class === $fqcn) {
+                    $type = $instance;
+                    break;
+                }
+            }
+        }
+
+        if ($type?->isHiddenInput()) {
+            return ['mode' => 'input', 'input_type' => 'hidden'];
+        }
+
+        if (is_a($fqcn, AbstractQuestionTypeSelectable::class, true)) {
+            return ['mode' => 'checkbox'];
+        }
+
+        if (is_a($fqcn, AbstractQuestionTypeShortAnswer::class, true)) {
+            $input_type = $type instanceof AbstractQuestionTypeShortAnswer
+                ? $type->getInputType()
+                : 'text';
+            return ['mode' => 'input', 'input_type' => $input_type];
+        }
+
+        return ['mode' => 'input', 'input_type' => 'text'];
+    }
+
+    /**
+     * Builds a [value => label] options array for actor-type columns.
+     * Loads up to 200 active users from the database.
+     *
+     * @return array<int|string, string>
+     */
+    private function buildUserOptions(): array
+    {
+        global $DB;
+
+        $options = ['' => Dropdown::EMPTY_VALUE];
+
+        $rows = $DB->request([
+            'SELECT' => ['id', 'name', 'realname', 'firstname'],
+            'FROM'   => User::getTable(),
+            'WHERE'  => ['is_active' => 1, 'is_deleted' => 0],
+            'ORDER'  => ['realname', 'firstname', 'name'],
+            'LIMIT'  => 200,
+        ]);
+
+        foreach ($rows as $row) {
+            if (!is_array($row)) {
+                continue;
+            }
+
+            $id = is_numeric($row['id']) ? (int) $row['id'] : 0;
+            $options[(string) $id] = formatUserName(
+                $id,
+                is_string($row['name'] ?? null) ? $row['name'] : null,
+                is_string($row['realname'] ?? null) ? $row['realname'] : null,
+                is_string($row['firstname'] ?? null) ? $row['firstname'] : null,
+            );
+        }
+
+        return $options;
+    }
+
+    /**
+     * Builds an optgroup-keyed options array for the User Device column type.
+     * Keys at the top level are group labels; inner keys are "Itemtype_id" strings.
+     *
+     * @return array<string, string|array<string, string>>
+     */
+    private function buildUserDeviceOptions(): array
+    {
+        $devices = CommonItilObject_Item::getMyDevices(
+            intval(Session::getLoginUserID()),
+            Session::getActiveEntities(),
+        );
+
+        return array_merge(['' => Dropdown::EMPTY_VALUE], $devices);
+    }
+
+    /**
+     * Builds a [id => name] options array for a GLPI itemtype (used by Item/ItemDropdown columns).
+     * Applies entity and soft-delete filters when applicable.
+     *
+     * @param class-string $itemtype
+     * @return array<int|string, string>
+     */
+    private function buildGlpiItemtypeOptions(string $itemtype): array
+    {
+        global $DB;
+
+        $options = ['' => Dropdown::EMPTY_VALUE];
+        $item    = getItemForItemtype($itemtype);
+        if ($item === false) {
+            return $options;
+        }
+
+        $where = [];
+
+        if ($item->maybeDeleted()) {
+            $where['is_deleted'] = 0;
+        }
+
+        if ($item->isEntityAssign()) {
+            $where = array_merge($where, getEntitiesRestrictCriteria(
+                $item->getTable(),
+                '',
+                '',
+                $item->maybeRecursive(),
+            ));
+        }
+
+        $criteria = [
+            'SELECT' => ['id', 'name'],
+            'FROM'   => $item->getTable(),
+            'ORDER'  => 'name',
+            'LIMIT'  => 200,
+        ];
+
+        if ($where !== []) {
+            $criteria['WHERE'] = $where;
+        }
+
+        foreach ($DB->request($criteria) as $row) {
+            if (!is_array($row)) {
+                continue;
+            }
+
+            $options[(string) (is_numeric($row['id']) ? (int) $row['id'] : 0)] = is_string($row['name']) ? $row['name'] : '';
+        }
+
+        return $options;
+    }
+
+    private function loadConfig(Question $question): TableQuestionConfig
+    {
+        $decoded = [];
+        if (is_string($question->fields['extra_data'])) {
+            $raw = json_decode($question->fields['extra_data'], associative: true);
+            if (is_array($raw)) {
+                $decoded = $raw;
+            }
+        }
+
+        $config = $this->getExtraDataConfig($decoded);
+        return $config instanceof TableQuestionConfig ? $config : new TableQuestionConfig();
+    }
+}
diff --git a/src/Model/QuestionType/TableQuestionConfig.php b/src/Model/QuestionType/TableQuestionConfig.php
new file mode 100644
index 0000000..53533f2
--- /dev/null
+++ b/src/Model/QuestionType/TableQuestionConfig.php
@@ -0,0 +1,127 @@
+<?php
+
+/**
+ * -------------------------------------------------------------------------
+ * advancedforms plugin for GLPI
+ * -------------------------------------------------------------------------
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * -------------------------------------------------------------------------
+ * @copyright Copyright (C) 2025 by the advancedforms plugin team.
+ * @license   MIT https://opensource.org/licenses/mit-license.php
+ * @link      https://github.com/pluginsGLPI/advancedforms
+ * -------------------------------------------------------------------------
+ */
+
+namespace GlpiPlugin\Advancedforms\Model\QuestionType;
+
+use Glpi\DBAL\JsonFieldInterface;
+use Override;
+
+final readonly class TableQuestionConfig implements JsonFieldInterface
+{
+    public const COLUMNS          = 'columns';
+
+    public const MIN_ROWS         = 'min_rows';
+
+    public const MAX_ROWS         = 'max_rows';
+
+    // Column sub-keys
+    public const COL_NAME          = 'name';
+
+    public const COL_QUESTION_TYPE = 'question_type';
+
+    public const COL_REQUIRED      = 'required';
+
+    public const COL_ITEMTYPE      = 'itemtype';
+
+    /**
+     * @param array<array{name: string, question_type: string, required: bool, itemtype: string}> $columns
+     */
+    public function __construct(
+        private array $columns  = [],
+        private int   $min_rows = 1,
+        private int   $max_rows = 50,
+    ) {}
+
+    /**
+     * @param array{
+     *   columns?: array<array{name?: string, question_type?: string, required?: bool, itemtype?: string}>,
+     *   min_rows?: int,
+     *   max_rows?: int
+     * } $data
+     */
+    #[Override]
+    public static function jsonDeserialize(array $data): self
+    {
+        $columns = array_values(array_map(
+            fn($col) => [
+                self::COL_NAME          => (string) ($col[self::COL_NAME] ?? ''),
+                self::COL_QUESTION_TYPE => (string) ($col[self::COL_QUESTION_TYPE] ?? ''),
+                self::COL_REQUIRED      => (bool) ($col[self::COL_REQUIRED] ?? false),
+                self::COL_ITEMTYPE      => (string) ($col[self::COL_ITEMTYPE] ?? ''),
+            ],
+            array_filter($data[self::COLUMNS] ?? [], is_array(...)),
+        ));
+
+        $min_rows = max(1, (int) ($data[self::MIN_ROWS] ?? 1));
+        $max_rows = min(50, max($min_rows, (int) ($data[self::MAX_ROWS] ?? 50)));
+
+        return new self(
+            columns: $columns,
+            min_rows: $min_rows,
+            max_rows: $max_rows,
+        );
+    }
+
+    /**
+     * @return array{
+     *   columns: array<array{name: string, question_type: string, required: bool, itemtype: string}>,
+     *   min_rows: int,
+     *   max_rows: int
+     * }
+     */
+    #[Override]
+    public function jsonSerialize(): array
+    {
+        return [
+            self::COLUMNS  => $this->columns,
+            self::MIN_ROWS => $this->min_rows,
+            self::MAX_ROWS => $this->max_rows,
+        ];
+    }
+
+    /** @return array<array{name: string, question_type: string, required: bool, itemtype: string}> */
+    public function getColumns(): array
+    {
+        return $this->columns;
+    }
+
+    public function getMinRows(): int
+    {
+        return $this->min_rows;
+    }
+
+    public function getMaxRows(): int
+    {
+        return $this->max_rows;
+    }
+}
diff --git a/src/Service/ConfigManager.php b/src/Service/ConfigManager.php
index 62fc045..b83f04d 100644
--- a/src/Service/ConfigManager.php
+++ b/src/Service/ConfigManager.php
@@ -42,6 +42,7 @@
 use GlpiPlugin\Advancedforms\Model\QuestionType\HostnameQuestion;
 use GlpiPlugin\Advancedforms\Model\QuestionType\IpAddressQuestion;
 use GlpiPlugin\Advancedforms\Model\QuestionType\LdapQuestion;
+use GlpiPlugin\Advancedforms\Model\QuestionType\TableQuestion;
 use GlpiPlugin\Advancedforms\Model\QuestionType\TreeCascadeDropdownQuestion;
 
 final class ConfigManager
@@ -66,6 +67,7 @@ public function getConfigurableQuestionTypes(): array
             new HiddenQuestion(),
             new LdapQuestion(),
             new TreeCascadeDropdownQuestion(),
+            new TableQuestion(),
         ];
     }
 
diff --git a/templates/editor/question_types/table_admin.html.twig b/templates/editor/question_types/table_admin.html.twig
new file mode 100644
index 0000000..ce2bf7a
--- /dev/null
+++ b/templates/editor/question_types/table_admin.html.twig
@@ -0,0 +1,65 @@
+{#
+ # -------------------------------------------------------------------------
+ # advancedforms plugin for GLPI
+ # -------------------------------------------------------------------------
+ #
+ # MIT License
+ #
+ # Permission is hereby granted, free of charge, to any person obtaining a copy
+ # of this software and associated documentation files (the "Software"), to deal
+ # in the Software without restriction, including without limitation the rights
+ # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ # copies of the Software, and to permit persons to whom the Software is
+ # furnished to do so, subject to the following conditions:
+ #
+ # The above copyright notice and this permission notice shall be included in all
+ # copies or substantial portions of the Software.
+ #
+ # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ # SOFTWARE.
+ # -------------------------------------------------------------------------
+ # @copyright Copyright (C) 2025 by the advancedforms plugin team.
+ # @license   MIT https://opensource.org/licenses/mit-license.php
+ # @link      https://github.com/pluginsGLPI/advancedforms
+ # -------------------------------------------------------------------------
+ #}
+
+{% set has_columns = config.getColumns()|length > 0 %}
+
+<div class="w-100" data-af-table-admin>
+    <div class="d-flex justify-content-end mb-1">
+        {{ advanced_config|raw }}
+    </div>
+    {% if has_columns %}
+        <div class="overflow-auto">
+            <table class="table table-bordered table-sm mb-0">
+                <thead>
+                    <tr>
+                        {% for col in config.getColumns() %}
+                            <th class="text-truncate py-1 px-2" style="max-width: 120px; font-size: 0.8rem">
+                                {{ col.name }}
+                                {% if col.required %}<span class="text-danger" aria-hidden="true">*</span>{% endif %}
+                            </th>
+                        {% endfor %}
+                    </tr>
+                </thead>
+                <tbody>
+                    <tr>
+                        {% for col in config.getColumns() %}
+                            <td class="text-muted small py-1 px-2">…</td>
+                        {% endfor %}
+                    </tr>
+                </tbody>
+            </table>
+        </div>
+    {% else %}
+        <div class="form-control text-muted fst-italic">
+            {{ __("Define columns below", "advancedforms") }}
+        </div>
+    {% endif %}
+</div>
diff --git a/templates/editor/question_types/table_config.html.twig b/templates/editor/question_types/table_config.html.twig
new file mode 100644
index 0000000..a996d26
--- /dev/null
+++ b/templates/editor/question_types/table_config.html.twig
@@ -0,0 +1,283 @@
+{#
+ # -------------------------------------------------------------------------
+ # advancedforms plugin for GLPI
+ # -------------------------------------------------------------------------
+ #
+ # MIT License
+ #
+ # Permission is hereby granted, free of charge, to any person obtaining a copy
+ # of this software and associated documentation files (the "Software"), to deal
+ # in the Software without restriction, including without limitation the rights
+ # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ # copies of the Software, and to permit persons to whom the Software is
+ # furnished to do so, subject to the following conditions:
+ #
+ # The above copyright notice and this permission notice shall be included in all
+ # copies or substantial portions of the Software.
+ #
+ # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ # SOFTWARE.
+ # -------------------------------------------------------------------------
+ # @copyright Copyright (C) 2025 by the advancedforms plugin team.
+ # @license   MIT https://opensource.org/licenses/mit-license.php
+ # @link      https://github.com/pluginsGLPI/advancedforms
+ # -------------------------------------------------------------------------
+ #}
+
+{% set rand = random() %}
+
+<script>
+    window.afTableColumnTypeTemplate = window.afTableColumnTypeTemplate || function (item) {
+        const icons = {{ icons_json|raw }};
+        if (!item.id || !icons[item.id]) {
+            return item.text;
+        }
+        return $('<span>', { 'class': 'd-flex align-items-center gap-1' })
+            .append($('<i>', { 'class': icons[item.id] }))
+            .append(document.createTextNode(' ' + item.text));
+    };
+</script>
+
+<div class="dropdown" data-glpi-form-editor-question-extra-details>
+    <button
+        id="af-table-cfg-{{ rand }}"
+        class="btn btn-icon"
+        type="button"
+        data-bs-toggle="dropdown"
+        data-bs-auto-close="outside"
+        aria-expanded="false"
+        title="{{ __('Configure table columns', 'advancedforms') }}"
+        aria-label="{{ __('Configure table columns', 'advancedforms') }}"
+    >
+        <i class="ti ti-settings"></i>
+    </button>
+    <div
+        style="width: 52rem"
+        class="dropdown-menu dropdown-menu-end dropdown-menu-card animate__animated animate__zoomIn"
+        role="menu"
+        aria-labelledby="af-table-cfg-{{ rand }}"
+    >
+        <div class="card">
+            <div class="card-body">
+
+                <p class="fw-semibold mb-2">{{ __('Columns', 'advancedforms') }}</p>
+
+                <div
+                    class="mb-3"
+                    data-af-table-columns-container="{{ rand }}"
+                >
+                    {% for index, col in config.getColumns() %}
+                        <div class="d-flex align-items-center gap-2 mb-2" data-af-table-column>
+                            <input
+                                class="form-control"
+                                style="flex: 1 1 auto; min-width: 0; width: auto"
+                                type="text"
+                                name="extra_data[columns][{{ index }}][{{ COL_NAME }}]"
+                                value="{{ col[COL_NAME] }}"
+                                placeholder="{{ __('Column name', 'advancedforms') }}"
+                            >
+                            {% set col_select %}
+                                {% do call('Dropdown::showFromArray', [
+                                    'extra_data[columns][' ~ index ~ '][' ~ COL_QUESTION_TYPE ~ ']',
+                                    compatible_types,
+                                    {
+                                        'value'             : col[COL_QUESTION_TYPE],
+                                        'class'             : 'form-select',
+                                        'width'             : '200px',
+                                        'templateResult'    : 'window.afTableColumnTypeTemplate',
+                                        'templateSelection' : 'window.afTableColumnTypeTemplate',
+                                    }
+                                ]) %}
+                            {% endset %}
+                            {{ col_select|raw }}
+                            {% for type_fqcn, options in itemtype_options %}
+                                <div data-af-itemtype-wrapper="{{ type_fqcn }}" style="display: none">
+                                    <select
+                                        class="form-select flex-shrink-0"
+                                        style="width: 170px"
+                                        name="extra_data[columns][{{ index }}][{{ COL_ITEMTYPE }}]"
+                                        disabled
+                                    >
+                                        <option value="">{{ __('Select a type', 'advancedforms') }}</option>
+                                        {% for group_or_key, value in options %}
+                                            {% if value is iterable %}
+                                                <optgroup label="{{ group_or_key }}">
+                                                    {% for item_fqcn, name in value %}
+                                                        <option value="{{ item_fqcn }}" {{ col[COL_ITEMTYPE] == item_fqcn ? 'selected' : '' }}>{{ name }}</option>
+                                                    {% endfor %}
+                                                </optgroup>
+                                            {% else %}
+                                                <option value="{{ group_or_key }}" {{ col[COL_ITEMTYPE] == group_or_key ? 'selected' : '' }}>{{ value }}</option>
+                                            {% endif %}
+                                        {% endfor %}
+                                    </select>
+                                </div>
+                            {% endfor %}
+                            <label
+                                class="af-required-toggle cursor-pointer mb-0 flex-shrink-0"
+                                data-bs-toggle="tooltip"
+                                data-bs-placement="top"
+                                title="{{ __('Required column', 'advancedforms') }}"
+                            >
+                                <input
+                                    type="checkbox"
+                                    class="visually-hidden"
+                                    name="extra_data[columns][{{ index }}][{{ COL_REQUIRED }}]"
+                                    value="1"
+                                    aria-label="{{ __('Required column', 'advancedforms') }}"
+                                    {{ col[COL_REQUIRED] ? 'checked' : '' }}
+                                >
+                                <i class="ti ti-asterisk" aria-hidden="true"></i>
+                            </label>
+                            <i
+                                role="button"
+                                class="ti ti-trash ms-1 cursor-pointer text-danger flex-shrink-0"
+                                data-bs-toggle="tooltip"
+                                data-bs-placement="top"
+                                title="{{ __('Remove column', 'advancedforms') }}"
+                                aria-label="{{ __('Remove column', 'advancedforms') }}"
+                                data-af-table-column-remove
+                            ></i>
+                        </div>
+                    {% endfor %}
+                </div>
+
+                {# Template cloned by JS for new columns #}
+                <template data-af-table-column-template="{{ rand }}">
+                    <div class="d-flex align-items-center gap-2 mb-2" data-af-table-column>
+                        <input
+                            class="form-control"
+                            style="flex: 1 1 auto; min-width: 0; width: auto"
+                            type="text"
+                            name="extra_data[columns][__INDEX__][{{ COL_NAME }}]"
+                            placeholder="{{ __('Column name', 'advancedforms') }}"
+                        >
+                        <select
+                            class="form-select"
+                            style="width: 200px; flex-shrink: 0"
+                            name="extra_data[columns][__INDEX__][{{ COL_QUESTION_TYPE }}]"
+                            data-af-table-type-select
+                        >
+                            {% for fqcn, label in compatible_types %}
+                                <option value="{{ fqcn }}">{{ label }}</option>
+                            {% endfor %}
+                        </select>
+                        {% for type_fqcn, options in itemtype_options %}
+                            <div data-af-itemtype-wrapper="{{ type_fqcn }}" style="display: none">
+                                <select
+                                    class="form-select flex-shrink-0"
+                                    style="width: 170px"
+                                    name="extra_data[columns][__INDEX__][{{ COL_ITEMTYPE }}]"
+                                    disabled
+                                >
+                                    <option value="">{{ __('Select a type', 'advancedforms') }}</option>
+                                    {% for group_or_key, value in options %}
+                                        {% if value is iterable %}
+                                            <optgroup label="{{ group_or_key }}">
+                                                {% for item_fqcn, name in value %}
+                                                    <option value="{{ item_fqcn }}">{{ name }}</option>
+                                                {% endfor %}
+                                            </optgroup>
+                                        {% else %}
+                                            <option value="{{ group_or_key }}">{{ value }}</option>
+                                        {% endif %}
+                                    {% endfor %}
+                                </select>
+                            </div>
+                        {% endfor %}
+                        <label
+                            class="af-required-toggle cursor-pointer mb-0 flex-shrink-0"
+                            data-bs-toggle="tooltip"
+                            data-bs-placement="top"
+                            title="{{ __('Required column', 'advancedforms') }}"
+                        >
+                            <input
+                                type="checkbox"
+                                class="visually-hidden"
+                                name="extra_data[columns][__INDEX__][{{ COL_REQUIRED }}]"
+                                value="1"
+                                aria-label="{{ __('Required column', 'advancedforms') }}"
+                            >
+                            <i class="ti ti-asterisk" aria-hidden="true"></i>
+                        </label>
+                        <i
+                            role="button"
+                            class="ti ti-trash ms-1 cursor-pointer text-danger flex-shrink-0"
+                            data-bs-toggle="tooltip"
+                            data-bs-placement="top"
+                            title="{{ __('Remove column', 'advancedforms') }}"
+                            aria-label="{{ __('Remove column', 'advancedforms') }}"
+                            data-af-table-column-remove
+                        ></i>
+                    </div>
+                </template>
+
+                <i
+                    role="button"
+                    class="ti ti-plus cursor-pointer mb-3"
+                    data-bs-toggle="tooltip"
+                    data-bs-placement="top"
+                    title="{{ __('Add column', 'advancedforms') }}"
+                    aria-label="{{ __('Add column', 'advancedforms') }}"
+                    data-af-table-column-add="{{ rand }}"
+                ></i>
+
+                <hr class="mt-3 mb-2">
+
+                <div class="d-flex gap-4 align-items-center flex-wrap">
+                    <label class="d-flex align-items-center gap-2 mb-0">
+                        <span class="text-nowrap">{{ __('Min rows', 'advancedforms') }}</span>
+                        <input
+                            type="number"
+                            class="form-control form-control-sm"
+                            style="width: 5rem"
+                            name="extra_data[{{ MIN_ROWS }}]"
+                            value="{{ config.getMinRows() }}"
+                            min="1"
+                            max="200"
+                            step="1"
+                        >
+                    </label>
+                    <label class="d-flex align-items-center gap-2 mb-0">
+                        <span class="text-nowrap">{{ __('Max rows', 'advancedforms') }}</span>
+                        <input
+                            type="number"
+                            class="form-control form-control-sm"
+                            style="width: 5rem"
+                            name="extra_data[{{ MAX_ROWS }}]"
+                            value="{{ config.getMaxRows() }}"
+                            min="1"
+                            max="200"
+                            step="1"
+                        >
+                    </label>
+                </div>
+
+            </div>
+        </div>
+    </div>
+</div>
+
+<script>
+    window.select2_configs = window.select2_configs || {};
+    window.select2_configs['af-table-type-template-{{ rand }}'] = {
+        type: 'adapt',
+        field_id: 'af-table-type-template-{{ rand }}',
+        width: '200px',
+        dropdown_css_class: '',
+        placeholder: '',
+        ajax_limit_count: {{ ajax_limit_count }},
+        templateresult: window.afTableColumnTypeTemplate,
+        templateselection: window.afTableColumnTypeTemplate,
+    };
+</script>
+
+<script type="module">
+    import { AfTableQuestionConfig } from '/plugins/advancedforms/js/modules/AfTableQuestionConfig.js';
+    new AfTableQuestionConfig();
+</script>
diff --git a/templates/table_answer.html.twig b/templates/table_answer.html.twig
new file mode 100644
index 0000000..908efd4
--- /dev/null
+++ b/templates/table_answer.html.twig
@@ -0,0 +1,49 @@
+{#
+ # -------------------------------------------------------------------------
+ # advancedforms plugin for GLPI
+ # -------------------------------------------------------------------------
+ #
+ # MIT License
+ #
+ # Permission is hereby granted, free of charge, to any person obtaining a copy
+ # of this software and associated documentation files (the "Software"), to deal
+ # in the Software without restriction, including without limitation the rights
+ # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ # copies of the Software, and to permit persons to whom the Software is
+ # furnished to do so, subject to the following conditions:
+ #
+ # The above copyright notice and this permission notice shall be included in all
+ # copies or substantial portions of the Software.
+ #
+ # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ # SOFTWARE.
+ # -------------------------------------------------------------------------
+ # @copyright Copyright (C) 2025 by the advancedforms plugin team.
+ # @license   MIT https://opensource.org/licenses/mit-license.php
+ # @link      https://github.com/pluginsGLPI/advancedforms
+ # -------------------------------------------------------------------------
+ #}
+
+<table class="table table-bordered table-sm">
+    <thead>
+        <tr>
+            {% for header in headers %}
+                <th>{{ header }}</th>
+            {% endfor %}
+        </tr>
+    </thead>
+    <tbody>
+        {% for row in rows %}
+            <tr>
+                {% for cell in row %}
+                    <td>{{ cell }}</td>
+                {% endfor %}
+            </tr>
+        {% endfor %}
+    </tbody>
+</table>
diff --git a/templates/table_end_user.html.twig b/templates/table_end_user.html.twig
new file mode 100644
index 0000000..220e4dc
--- /dev/null
+++ b/templates/table_end_user.html.twig
@@ -0,0 +1,186 @@
+{#
+ # -------------------------------------------------------------------------
+ # advancedforms plugin for GLPI
+ # -------------------------------------------------------------------------
+ #
+ # MIT License
+ #
+ # Permission is hereby granted, free of charge, to any person obtaining a copy
+ # of this software and associated documentation files (the "Software"), to deal
+ # in the Software without restriction, including without limitation the rights
+ # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ # copies of the Software, and to permit persons to whom the Software is
+ # furnished to do so, subject to the following conditions:
+ #
+ # The above copyright notice and this permission notice shall be included in all
+ # copies or substantial portions of the Software.
+ #
+ # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ # SOFTWARE.
+ # -------------------------------------------------------------------------
+ # @copyright Copyright (C) 2025 by the advancedforms plugin team.
+ # @license   MIT https://opensource.org/licenses/mit-license.php
+ # @link      https://github.com/pluginsGLPI/advancedforms
+ # -------------------------------------------------------------------------
+ #}
+
+{% set rand_eu    = random() %}
+{% set input_base = question.getEndUserInputName() %}
+{% set min_rows   = config.getMinRows() %}
+{% set max_rows   = config.getMaxRows() %}
+{% set columns    = config.getColumns() %}
+
+{% set required_cols = [] %}
+{% for col_index, col in columns %}
+    {% if col.required %}{% set required_cols = required_cols|merge([col_index]) %}{% endif %}
+{% endfor %}
+
+<div
+    data-af-table-question="{{ rand_eu }}"
+    data-af-min-rows="{{ min_rows }}"
+    data-af-max-rows="{{ max_rows }}"
+    data-af-s2-limit="{{ ajax_limit_count }}"
+    data-af-required-cols="{{ required_cols|join(',') }}"
+    data-af-required-msg="{{ __('Please fill in all required columns.', 'advancedforms') }}"
+>
+    <table class="table table-bordered table-sm mb-2">
+        <thead>
+            <tr>
+                {% for col in columns %}
+                    <th>
+                        {{ col.name }}
+                        {% if col.required %}<span class="text-danger" aria-hidden="true">*</span>{% endif %}
+                    </th>
+                {% endfor %}
+                <th style="width: 2.5rem"></th>
+            </tr>
+        </thead>
+        <tbody data-af-table-body>
+            {% for row_index in 0..(min_rows - 1) %}
+                <tr data-af-table-row>
+                    {% for col_index, col in columns %}
+                        {% set cell = column_cell_map[col_index] %}
+                        <td class="align-middle">
+                            {% if cell.mode == 'checkbox' %}
+                                <div class="d-flex justify-content-center">
+                                    <input
+                                        type="checkbox"
+                                        value="1"
+                                        class="form-check-input mt-0"
+                                        name="{{ input_base }}[{{ row_index }}][col_{{ col_index }}]"
+                                        {% if col.required %} required {% endif %}
+                                    >
+                                </div>
+                            {% elseif cell.mode == 'select' %}
+                                {% set sel_html %}
+                                    {% do call('Dropdown::showFromArray', [
+                                        input_base ~ '[' ~ row_index ~ '][col_' ~ col_index ~ ']',
+                                        cell.options,
+                                        {
+                                            'class'              : 'form-select form-select-sm',
+                                            'width'              : '100%',
+                                            'display_emptychoice': false,
+                                        }
+                                    ]) %}
+                                {% endset %}
+                                {{ sel_html|raw }}
+                            {% else %}
+                                <input
+                                    class="form-control form-control-sm"
+                                    type="{{ cell.input_type }}"
+                                    name="{{ input_base }}[{{ row_index }}][col_{{ col_index }}]"
+                                    placeholder="{{ col.name }}"
+                                    {% if col.required %} required {% endif %}
+                                >
+                            {% endif %}
+                        </td>
+                    {% endfor %}
+                    <td class="text-center align-middle">
+                        <i
+                            role="button"
+                            class="ti ti-trash cursor-pointer text-danger{% if min_rows >= max_rows %} opacity-25 pe-none{% endif %}"
+                            data-bs-toggle="tooltip"
+                            data-bs-placement="top"
+                            title="{{ __('Remove row', 'advancedforms') }}"
+                            aria-label="{{ __('Remove row', 'advancedforms') }}"
+                            data-af-table-remove-row
+                        ></i>
+                    </td>
+                </tr>
+            {% endfor %}
+        </tbody>
+    </table>
+
+    {# Template for cloning new rows #}
+    <template data-af-table-row-template>
+        <tr data-af-table-row>
+            {% for col_index, col in columns %}
+                {% set cell = column_cell_map[col_index] %}
+                <td class="align-middle">
+                    {% if cell.mode == 'checkbox' %}
+                        <div class="d-flex justify-content-center">
+                            <input
+                                type="checkbox"
+                                value="1"
+                                class="form-check-input mt-0"
+                                name="{{ input_base }}[__ROW__][col_{{ col_index }}]"
+                                {% if col.required %} required {% endif %}
+                            >
+                        </div>
+                    {% elseif cell.mode == 'select' %}
+                        <select
+                            class="form-select form-select-sm"
+                            name="{{ input_base }}[__ROW__][col_{{ col_index }}]"
+                            data-af-needs-s2
+                            {% if col.required %} required {% endif %}
+                        >
+                            {% for val, lbl in cell.options %}
+                                <option value="{{ val }}">{{ lbl }}</option>
+                            {% endfor %}
+                        </select>
+                    {% else %}
+                        <input
+                            class="form-control form-control-sm"
+                            type="{{ cell.input_type }}"
+                            name="{{ input_base }}[__ROW__][col_{{ col_index }}]"
+                            placeholder="{{ col.name }}"
+                            {% if col.required %} required {% endif %}
+                        >
+                    {% endif %}
+                </td>
+            {% endfor %}
+            <td class="text-center align-middle">
+                <i
+                    role="button"
+                    class="ti ti-trash cursor-pointer text-danger"
+                    data-bs-toggle="tooltip"
+                    data-bs-placement="top"
+                    title="{{ __('Remove row', 'advancedforms') }}"
+                    aria-label="{{ __('Remove row', 'advancedforms') }}"
+                    data-af-table-remove-row
+                ></i>
+            </td>
+        </tr>
+    </template>
+
+    <i
+        role="button"
+        class="ti ti-plus cursor-pointer{% if min_rows >= max_rows %} opacity-25 pe-none{% endif %}"
+        data-bs-toggle="tooltip"
+        data-bs-placement="top"
+        title="{{ __('Add a row', 'advancedforms') }}"
+        aria-label="{{ __('Add a row', 'advancedforms') }}"
+        data-af-table-add-row
+    ></i>
+</div>
+
+<script type="module">
+    import { AfTableQuestion } from '/plugins/advancedforms/js/modules/AfTableQuestion.js';
+    const el = document.querySelector('[data-af-table-question="{{ rand_eu|e('js') }}"]');
+    if (el) { new AfTableQuestion(el); }
+</script>
diff --git a/tests/Model/QuestionType/TableQuestionConfigTest.php b/tests/Model/QuestionType/TableQuestionConfigTest.php
new file mode 100644
index 0000000..a8f360f
--- /dev/null
+++ b/tests/Model/QuestionType/TableQuestionConfigTest.php
@@ -0,0 +1,94 @@
+<?php
+
+/**
+ * -------------------------------------------------------------------------
+ * advancedforms plugin for GLPI
+ * -------------------------------------------------------------------------
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * -------------------------------------------------------------------------
+ * @copyright Copyright (C) 2025 by the advancedforms plugin team.
+ * @license   MIT https://opensource.org/licenses/mit-license.php
+ * @link      https://github.com/pluginsGLPI/advancedforms
+ * -------------------------------------------------------------------------
+ */
+
+namespace GlpiPlugin\Advancedforms\Tests\Model\QuestionType;
+
+use GlpiPlugin\Advancedforms\Model\QuestionType\TableQuestionConfig;
+use GlpiPlugin\Advancedforms\Tests\AdvancedFormsTestCase;
+
+final class TableQuestionConfigTest extends AdvancedFormsTestCase
+{
+    public function testDefaultValues(): void
+    {
+        $config = new TableQuestionConfig();
+        $this->assertSame([], $config->getColumns());
+        $this->assertSame(1, $config->getMinRows());
+        $this->assertSame(50, $config->getMaxRows());
+    }
+
+    public function testJsonRoundtrip(): void
+    {
+        $original = new TableQuestionConfig(
+            columns: [
+                ['name' => 'Source IP', 'question_type' => 'Glpi\\Form\\QuestionType\\QuestionTypeShortText', 'required' => true,  'itemtype' => ''],
+                ['name' => 'Port',      'question_type' => 'Glpi\\Form\\QuestionType\\QuestionTypeNumber',    'required' => false, 'itemtype' => ''],
+            ],
+            min_rows: 2,
+            max_rows: 20,
+        );
+        $serialized   = $original->jsonSerialize();
+        $deserialized = TableQuestionConfig::jsonDeserialize($serialized);
+        $this->assertSame($original->getColumns(), $deserialized->getColumns());
+        $this->assertSame($original->getMinRows(), $deserialized->getMinRows());
+        $this->assertSame($original->getMaxRows(), $deserialized->getMaxRows());
+    }
+
+    public function testJsonDeserializeFiltersNonArrayColumns(): void
+    {
+        $config = TableQuestionConfig::jsonDeserialize([
+            'columns'  => ['not_array', ['name' => 'Valid', 'question_type' => 'SomeFqcn', 'required' => false]],
+            'min_rows' => 1,
+            'max_rows' => 50,
+        ]);
+        $this->assertCount(1, $config->getColumns());
+        $this->assertSame('Valid', $config->getColumns()[0]['name']);
+    }
+
+    public function testJsonDeserializeEnforcesMinRow(): void
+    {
+        $config = TableQuestionConfig::jsonDeserialize(['min_rows' => 0, 'max_rows' => 10]);
+        $this->assertSame(1, $config->getMinRows());
+    }
+
+    public function testJsonDeserializeEnforcesMaxRowNotZero(): void
+    {
+        $config = TableQuestionConfig::jsonDeserialize(['min_rows' => 1, 'max_rows' => 0]);
+        $this->assertSame(1, $config->getMaxRows());
+    }
+
+    public function testJsonDeserializeEnforcesMaxRowNotLessThanMin(): void
+    {
+        $config = TableQuestionConfig::jsonDeserialize(['min_rows' => 10, 'max_rows' => 5]);
+        $this->assertSame(10, $config->getMaxRows());
+    }
+}
diff --git a/tests/Model/QuestionType/TableQuestionIntegrationTest.php b/tests/Model/QuestionType/TableQuestionIntegrationTest.php
new file mode 100644
index 0000000..151f88b
--- /dev/null
+++ b/tests/Model/QuestionType/TableQuestionIntegrationTest.php
@@ -0,0 +1,119 @@
+<?php
+
+/**
+ * -------------------------------------------------------------------------
+ * advancedforms plugin for GLPI
+ * -------------------------------------------------------------------------
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * -------------------------------------------------------------------------
+ * @copyright Copyright (C) 2025 by the advancedforms plugin team.
+ * @license   MIT https://opensource.org/licenses/mit-license.php
+ * @link      https://github.com/pluginsGLPI/advancedforms
+ * -------------------------------------------------------------------------
+ */
+
+namespace GlpiPlugin\Advancedforms\Tests\Model\QuestionType;
+
+use Glpi\Form\QuestionType\QuestionTypeInterface;
+use Glpi\Form\QuestionType\QuestionTypeNumber;
+use Glpi\Form\QuestionType\QuestionTypeShortText;
+use GlpiPlugin\Advancedforms\Model\Config\ConfigurableItemInterface;
+use GlpiPlugin\Advancedforms\Model\QuestionType\TableQuestion;
+use GlpiPlugin\Advancedforms\Model\QuestionType\TableQuestionConfig;
+use GlpiPlugin\Advancedforms\Tests\QuestionType\QuestionTypeTestCase;
+use Override;
+use Symfony\Component\DomCrawler\Crawler;
+
+final class TableQuestionIntegrationTest extends QuestionTypeTestCase
+{
+    #[Override]
+    protected function getTestedQuestionType(): QuestionTypeInterface&ConfigurableItemInterface
+    {
+        return new TableQuestion();
+    }
+
+    #[Override]
+    protected function getDefaultExtraDataForQuestionType(QuestionTypeInterface $type): ?string
+    {
+        return json_encode(new TableQuestionConfig(
+            columns: [
+                [
+                    TableQuestionConfig::COL_NAME          => 'Source IP',
+                    TableQuestionConfig::COL_QUESTION_TYPE => QuestionTypeShortText::class,
+                    TableQuestionConfig::COL_REQUIRED      => true,
+                ],
+                [
+                    TableQuestionConfig::COL_NAME          => 'Port',
+                    TableQuestionConfig::COL_QUESTION_TYPE => QuestionTypeNumber::class,
+                    TableQuestionConfig::COL_REQUIRED      => false,
+                ],
+            ],
+            min_rows: 1,
+            max_rows: 50,
+        ));
+    }
+
+    #[Override]
+    protected function validateEditorRenderingWhenEnabled(Crawler $html): void
+    {
+        // The admin preview marker lets plugin CSS hide the question-level
+        // "Mandatory" toggle (required is handled per column instead).
+        $question = $html->filter('[data-glpi-form-editor-question]')->first();
+        $this->assertGreaterThan(0, $question->filter('[data-af-table-admin]')->count());
+
+        // Preview table must show column headers — use combined text to handle required asterisk span
+        $headerText = implode(' ', $html->filter('th')->each(fn(Crawler $n) => $n->text()));
+        $this->assertStringContainsString('Source IP', $headerText);
+        $this->assertStringContainsString('Port', $headerText);
+
+        // Gear settings button must be present
+        $gear = $html->filter('[data-glpi-form-editor-question-extra-details]');
+        $this->assertNotEmpty($gear);
+    }
+
+    #[Override]
+    protected function validateHelpdeskRenderingWhenEnabled(Crawler $html): void
+    {
+        // Dynamic table container must exist
+        $container = $html->filter('[data-af-table-question]');
+        $this->assertNotEmpty($container);
+
+        // Required columns must be exposed to the client validation layer.
+        // The default config marks the first column ("Source IP") as required.
+        $this->assertSame('0', $container->attr('data-af-required-cols'));
+
+        // At least one input row rendered (min_rows = 1)
+        $rows = $html->filter('[data-af-table-body] [data-af-table-row]');
+        $this->assertGreaterThanOrEqual(1, $rows->count());
+
+        // Add-row button must be present
+        $addBtn = $html->filter('[data-af-table-add-row]');
+        $this->assertNotEmpty($addBtn);
+    }
+
+    #[Override]
+    protected function validateHelpdeskRenderingWhenDisabled(Crawler $html): void
+    {
+        $container = $html->filter('[data-af-table-question]');
+        $this->assertEmpty($container);
+    }
+}
diff --git a/tests/Model/QuestionType/TableQuestionTest.php b/tests/Model/QuestionType/TableQuestionTest.php
new file mode 100644
index 0000000..4a314da
--- /dev/null
+++ b/tests/Model/QuestionType/TableQuestionTest.php
@@ -0,0 +1,212 @@
+<?php
+
+/**
+ * -------------------------------------------------------------------------
+ * advancedforms plugin for GLPI
+ * -------------------------------------------------------------------------
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * -------------------------------------------------------------------------
+ * @copyright Copyright (C) 2025 by the advancedforms plugin team.
+ * @license   MIT https://opensource.org/licenses/mit-license.php
+ * @link      https://github.com/pluginsGLPI/advancedforms
+ * -------------------------------------------------------------------------
+ */
+
+namespace GlpiPlugin\Advancedforms\Tests\Model\QuestionType;
+
+use Glpi\Form\QuestionType\QuestionTypeCheckbox;
+use Glpi\Form\QuestionType\QuestionTypeEmail;
+use Glpi\Form\QuestionType\QuestionTypeFile;
+use Glpi\Form\QuestionType\QuestionTypeNumber;
+use Glpi\Form\QuestionType\QuestionTypeRequestType;
+use Glpi\Form\QuestionType\QuestionTypeShortText;
+use GlpiPlugin\Advancedforms\Model\QuestionType\HiddenQuestion;
+use GlpiPlugin\Advancedforms\Model\QuestionType\LdapQuestion;
+use GlpiPlugin\Advancedforms\Model\QuestionType\TreeCascadeDropdownQuestion;
+use GlpiPlugin\Advancedforms\Model\QuestionType\TableQuestion;
+use GlpiPlugin\Advancedforms\Model\QuestionType\TableQuestionConfig;
+use GlpiPlugin\Advancedforms\Tests\AdvancedFormsTestCase;
+
+final class TableQuestionTest extends AdvancedFormsTestCase
+{
+    private TableQuestion $type;
+
+    public function setUp(): void
+    {
+        parent::setUp();
+        $this->type = new TableQuestion();
+    }
+
+    public function testPrepareExtraDataReindexesColumns(): void
+    {
+        $input = [
+            'columns' => [
+                5 => ['name' => 'A', 'question_type' => QuestionTypeShortText::class, 'required' => false],
+                9 => ['name' => 'B', 'question_type' => QuestionTypeNumber::class,    'required' => true],
+            ],
+            'min_rows' => '2',
+            'max_rows' => '20',
+        ];
+        $result = $this->type->prepareExtraData($input);
+        $this->assertArrayHasKey(0, $result[TableQuestionConfig::COLUMNS]);
+        $this->assertArrayHasKey(1, $result[TableQuestionConfig::COLUMNS]);
+        $this->assertSame(2, $result[TableQuestionConfig::MIN_ROWS]);
+        $this->assertSame(20, $result[TableQuestionConfig::MAX_ROWS]);
+    }
+
+    public function testPrepareExtraDataCoercesRequiredToBool(): void
+    {
+        $input = [
+            'columns'  => [['name' => 'X', 'question_type' => QuestionTypeShortText::class, 'required' => '1']],
+            'min_rows' => 1,
+            'max_rows' => 50,
+        ];
+        $result = $this->type->prepareExtraData($input);
+        $this->assertIsBool($result[TableQuestionConfig::COLUMNS][0][TableQuestionConfig::COL_REQUIRED]);
+        $this->assertTrue($result[TableQuestionConfig::COLUMNS][0][TableQuestionConfig::COL_REQUIRED]);
+    }
+
+    public function testCompatibleTypesExcludesFile(): void
+    {
+        $types = $this->type->getCompatibleQuestionTypes();
+        $this->assertArrayNotHasKey(QuestionTypeFile::class, $types);
+    }
+
+    public function testCompatibleTypesExcludesSelf(): void
+    {
+        $types = $this->type->getCompatibleQuestionTypes();
+        $this->assertArrayNotHasKey(TableQuestion::class, $types);
+    }
+
+    public function testCompatibleTypesIncludesShortText(): void
+    {
+        $types = $this->type->getCompatibleQuestionTypes();
+        $this->assertArrayHasKey(QuestionTypeShortText::class, $types);
+    }
+
+    public function testCellInfoForNumber(): void
+    {
+        $info = $this->type->getCellInfo(QuestionTypeNumber::class);
+        $this->assertSame('input', $info['mode']);
+        $this->assertSame('number', $info['input_type']);
+    }
+
+    public function testCellInfoForEmail(): void
+    {
+        $info = $this->type->getCellInfo(QuestionTypeEmail::class);
+        $this->assertSame('input', $info['mode']);
+        $this->assertSame('email', $info['input_type']);
+    }
+
+    public function testCellInfoDefaultsToText(): void
+    {
+        $info = $this->type->getCellInfo(QuestionTypeShortText::class);
+        $this->assertSame('input', $info['mode']);
+        $this->assertSame('text', $info['input_type']);
+    }
+
+    public function testCellInfoForCheckbox(): void
+    {
+        $info = $this->type->getCellInfo(QuestionTypeCheckbox::class);
+        $this->assertSame('checkbox', $info['mode']);
+    }
+
+    public function testCellInfoForHidden(): void
+    {
+        $info = $this->type->getCellInfo(HiddenQuestion::class, new HiddenQuestion());
+        $this->assertSame('input', $info['mode']);
+        $this->assertSame('hidden', $info['input_type']);
+    }
+
+    public function testCompatibleTypesExcludesRequestType(): void
+    {
+        $types = $this->type->getCompatibleQuestionTypes();
+        $this->assertArrayNotHasKey(QuestionTypeRequestType::class, $types);
+    }
+
+    public function testCompatibleTypesExcludesLdap(): void
+    {
+        $types = $this->type->getCompatibleQuestionTypes();
+        $this->assertArrayNotHasKey(LdapQuestion::class, $types);
+    }
+
+    public function testCompatibleTypesExcludesTreeCascadeDropdown(): void
+    {
+        $types = $this->type->getCompatibleQuestionTypes();
+        $this->assertArrayNotHasKey(TreeCascadeDropdownQuestion::class, $types);
+    }
+
+    public function testGetConfigKey(): void
+    {
+        $this->assertSame('enable_question_type_table', TableQuestion::getConfigKey());
+    }
+
+    public function testGetIcon(): void
+    {
+        $this->assertSame('ti ti-table', $this->type->getIcon());
+    }
+
+    public function testGetExtraDataConfigClass(): void
+    {
+        $this->assertSame(TableQuestionConfig::class, $this->type->getExtraDataConfigClass());
+    }
+
+    public function testValidateExtraDataInputAcceptsMaxRows50(): void
+    {
+        $result = $this->type->validateExtraDataInput([
+            'columns'  => [['name' => 'A', 'question_type' => QuestionTypeShortText::class]],
+            'min_rows' => 1,
+            'max_rows' => 50,
+        ]);
+        $this->assertTrue($result);
+    }
+
+    public function testValidateExtraDataInputRejectsMaxRowsAbove50(): void
+    {
+        $result = $this->type->validateExtraDataInput([
+            'columns'  => [['name' => 'A', 'question_type' => QuestionTypeShortText::class]],
+            'min_rows' => 1,
+            'max_rows' => 51,
+        ]);
+        $this->assertFalse($result);
+    }
+
+    public function testValidateExtraDataInputRejectsCraftedLargeMaxRows(): void
+    {
+        $result = $this->type->validateExtraDataInput([
+            'columns'  => [['name' => 'A', 'question_type' => QuestionTypeShortText::class]],
+            'min_rows' => 1,
+            'max_rows' => 99999,
+        ]);
+        $this->assertFalse($result);
+    }
+
+    public function testPrepareExtraDataClampsMaxRowsTo50(): void
+    {
+        $result = $this->type->prepareExtraData([
+            'columns'  => [['name' => 'A', 'question_type' => QuestionTypeShortText::class, 'required' => false]],
+            'min_rows' => 1,
+            'max_rows' => 99999,
+        ]);
+        $this->assertSame(50, $result[TableQuestionConfig::MAX_ROWS]);
+    }
+}
diff --git a/tests/Model/QuestionType/TableQuestionValidationTest.php b/tests/Model/QuestionType/TableQuestionValidationTest.php
new file mode 100644
index 0000000..36e815f
--- /dev/null
+++ b/tests/Model/QuestionType/TableQuestionValidationTest.php
@@ -0,0 +1,234 @@
+<?php
+
+/**
+ * -------------------------------------------------------------------------
+ * advancedforms plugin for GLPI
+ * -------------------------------------------------------------------------
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * -------------------------------------------------------------------------
+ * @copyright Copyright (C) 2025 by the advancedforms plugin team.
+ * @license   MIT https://opensource.org/licenses/mit-license.php
+ * @link      https://github.com/pluginsGLPI/advancedforms
+ * -------------------------------------------------------------------------
+ */
+
+namespace GlpiPlugin\Advancedforms\Tests\Model\QuestionType;
+
+use Glpi\Form\AnswersHandler\AnswersHandler;
+use Glpi\Form\Question;
+use Glpi\Form\QuestionType\QuestionTypeShortText;
+use Glpi\Tests\FormBuilder;
+use GlpiPlugin\Advancedforms\Model\QuestionType\TableQuestion;
+use GlpiPlugin\Advancedforms\Model\QuestionType\TableQuestionConfig;
+use GlpiPlugin\Advancedforms\Tests\AdvancedFormsTestCase;
+
+final class TableQuestionValidationTest extends AdvancedFormsTestCase
+{
+    private TableQuestion $type;
+
+    public function setUp(): void
+    {
+        parent::setUp();
+        $this->type = new TableQuestion();
+    }
+
+    public function testRequiredColumnEmptyInFilledRowProducesError(): void
+    {
+        $question = $this->makeTableQuestion([
+            $this->column('Name', QuestionTypeShortText::class, required: true),
+            $this->column('Comment', QuestionTypeShortText::class, required: false),
+        ]);
+
+        $result = $this->type->validateAnswer($question, [
+            ['col_0' => '', 'col_1' => 'a comment'],
+        ]);
+
+        $this->assertFalse($result->isValid());
+        $this->assertCount(1, $result->getErrors());
+    }
+
+    public function testAllRequiredColumnsFilledIsValid(): void
+    {
+        $question = $this->makeTableQuestion([
+            $this->column('Name', QuestionTypeShortText::class, required: true),
+            $this->column('Comment', QuestionTypeShortText::class, required: false),
+        ]);
+
+        $result = $this->type->validateAnswer($question, [
+            ['col_0' => 'Alice', 'col_1' => ''],
+        ]);
+
+        $this->assertTrue($result->isValid());
+        $this->assertCount(0, $result->getErrors());
+    }
+
+    public function testEntirelyEmptyRowIsSkipped(): void
+    {
+        $question = $this->makeTableQuestion([
+            $this->column('Name', QuestionTypeShortText::class, required: true),
+            $this->column('Comment', QuestionTypeShortText::class, required: false),
+        ]);
+
+        $result = $this->type->validateAnswer($question, [
+            ['col_0' => '', 'col_1' => ''],
+        ]);
+
+        $this->assertTrue($result->isValid());
+    }
+
+    public function testOptionalColumnEmptyIsValid(): void
+    {
+        $question = $this->makeTableQuestion([
+            $this->column('Name', QuestionTypeShortText::class, required: false),
+        ]);
+
+        $result = $this->type->validateAnswer($question, [
+            ['col_0' => ''],
+        ]);
+
+        $this->assertTrue($result->isValid());
+    }
+
+    public function testErrorMessageMentionsColumnName(): void
+    {
+        $question = $this->makeTableQuestion([
+            $this->column('Serial number', QuestionTypeShortText::class, required: true),
+        ]);
+
+        $result = $this->type->validateAnswer($question, [
+            ['col_0' => '', 'col_1' => 'filler'],
+        ]);
+
+        $errors = $result->getErrors();
+        $this->assertCount(1, $errors);
+        $this->assertStringContainsString('Serial number', $errors[0]['message']);
+    }
+
+    public function testNonArrayAnswerIsValid(): void
+    {
+        $question = $this->makeTableQuestion([
+            $this->column('Name', QuestionTypeShortText::class, required: true),
+        ]);
+
+        $result = $this->type->validateAnswer($question, 'not-an-array');
+
+        $this->assertTrue($result->isValid());
+    }
+
+    public function testMultipleMissingRequiredCellsProduceMultipleErrors(): void
+    {
+        $question = $this->makeTableQuestion([
+            $this->column('A', QuestionTypeShortText::class, required: true),
+            $this->column('B', QuestionTypeShortText::class, required: true),
+        ]);
+
+        // Row 1: A missing. Row 2: B missing. Row 3: entirely empty (ignored).
+        $result = $this->type->validateAnswer($question, [
+            ['col_0' => '',     'col_1' => 'b1'],
+            ['col_0' => 'a2',   'col_1' => ''],
+            ['col_0' => '',     'col_1' => ''],
+        ]);
+
+        $this->assertFalse($result->isValid());
+        $this->assertCount(2, $result->getErrors());
+    }
+
+    public function testRequiredValidationCoversEveryCompatibleColumnType(): void
+    {
+        foreach (array_keys($this->type->getCompatibleQuestionTypes()) as $fqcn) {
+            $question = $this->makeTableQuestion([
+                $this->column('Mandatory', $fqcn, required: true),
+                $this->column('Filler', QuestionTypeShortText::class, required: false),
+            ]);
+
+            // Filler is filled so the row counts as non-empty, mandatory cell is empty.
+            $result = $this->type->validateAnswer($question, [
+                ['col_0' => '', 'col_1' => 'filled'],
+            ]);
+
+            $this->assertFalse(
+                $result->isValid(),
+                "Required validation should fail for column type {$fqcn}",
+            );
+        }
+    }
+
+    public function testAnswersHandlerReportsMissingRequiredColumn(): void
+    {
+        // The condition engine only validates questions visible to the current
+        // user, and plugin question types require authentication to be visible.
+        $this->login();
+        $this->enableConfigurableItem($this->type);
+
+        $builder = new FormBuilder('Validation form');
+        $builder->addQuestion(
+            'Table',
+            TableQuestion::class,
+            extra_data: json_encode(new TableQuestionConfig(
+                columns: [
+                    $this->column('Name', QuestionTypeShortText::class, required: true),
+                    $this->column('Comment', QuestionTypeShortText::class, required: false),
+                ],
+            )),
+        );
+        $form = $this->createForm($builder);
+        $question_id = $this->getQuestionId($form, 'Table');
+
+        // Row has data (the comment) but the mandatory "Name" cell is empty.
+        $result = AnswersHandler::getInstance()->validateAnswers($form, [
+            $question_id => [['col_0' => '', 'col_1' => 'a comment']],
+        ]);
+
+        $this->assertFalse($result->isValid());
+    }
+
+    /**
+     * @param array<array{name: string, question_type: string, required: bool, itemtype: string}> $columns
+     */
+    private function makeTableQuestion(array $columns): Question
+    {
+        $this->enableConfigurableItem($this->type);
+
+        $builder = new FormBuilder('Validation form');
+        $builder->addQuestion(
+            'Table',
+            TableQuestion::class,
+            extra_data: json_encode(new TableQuestionConfig(columns: $columns)),
+        );
+        $form = $this->createForm($builder);
+
+        return Question::getById($this->getQuestionId($form, 'Table'));
+    }
+
+    /**
+     * @return array{name: string, question_type: string, required: bool, itemtype: string}
+     */
+    private function column(string $name, string $fqcn, bool $required): array
+    {
+        return [
+            TableQuestionConfig::COL_NAME          => $name,
+            TableQuestionConfig::COL_QUESTION_TYPE => $fqcn,
+            TableQuestionConfig::COL_REQUIRED      => $required,
+            TableQuestionConfig::COL_ITEMTYPE      => '',
+        ];
+    }
+}
diff --git a/tests/e2e/fixtures/advancedforms_fixture.ts b/tests/e2e/fixtures/advancedforms_fixture.ts
new file mode 100644
index 0000000..04d657d
--- /dev/null
+++ b/tests/e2e/fixtures/advancedforms_fixture.ts
@@ -0,0 +1,34 @@
+/**
+ * -------------------------------------------------------------------------
+ * advancedforms plugin for GLPI
+ * -------------------------------------------------------------------------
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * -------------------------------------------------------------------------
+ * @copyright Copyright (C) 2025 by the advancedforms plugin team.
+ * @license   MIT https://opensource.org/licenses/mit-license.php
+ * @link      https://github.com/pluginsGLPI/advancedforms
+ * -------------------------------------------------------------------------
+ */
+
+// Re-export the core GLPI fixture so plugin specs share the same authenticated
+// `test`/`expect` and the worker/profile/api helpers.
+export * from '../../../../../tests/e2e/fixtures/glpi_fixture';
diff --git a/tests/e2e/pages/AdvancedFormsTablePage.ts b/tests/e2e/pages/AdvancedFormsTablePage.ts
new file mode 100644
index 0000000..a8efd39
--- /dev/null
+++ b/tests/e2e/pages/AdvancedFormsTablePage.ts
@@ -0,0 +1,104 @@
+/**
+ * -------------------------------------------------------------------------
+ * advancedforms plugin for GLPI
+ * -------------------------------------------------------------------------
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * -------------------------------------------------------------------------
+ * @copyright Copyright (C) 2025 by the advancedforms plugin team.
+ * @license   MIT https://opensource.org/licenses/mit-license.php
+ * @link      https://github.com/pluginsGLPI/advancedforms
+ * -------------------------------------------------------------------------
+ */
+
+import { Locator, Page, expect } from '@playwright/test';
+import { GlpiPage } from '../../../../../tests/e2e/pages/GlpiPage';
+
+/**
+ * Page helpers for the "Table" question type: enabling it, configuring its
+ * columns in the editor and interacting with the rendered end-user table.
+ */
+export class AdvancedFormsTablePage extends GlpiPage {
+    private static readonly CONFIG_TAB =
+        'GlpiPlugin\\Advancedforms\\Model\\Config\\ConfigTab$1';
+
+    public constructor(page: Page) {
+        super(page);
+    }
+
+    /** Enables the Table question type from the plugin configuration page. */
+    public async enableTableQuestionType(): Promise<void> {
+        await this.page.goto(
+            `/front/config.form.php?forcetab=${AdvancedFormsTablePage.CONFIG_TAB}`,
+        );
+
+        const card = this.page
+            .locator('[data-testid^="feature-"]')
+            .filter({ hasText: 'Table question type' });
+        const toggle = card.getByTestId('feature-toggle');
+
+        if (!(await toggle.isChecked())) {
+            await toggle.check();
+            await this.getButton('Save').click();
+            await expect(card.getByTestId('feature-toggle')).toBeChecked();
+        }
+    }
+
+    /** Opens the column configuration dropdown of a table question in the editor. */
+    public async openColumnConfig(question: Locator): Promise<void> {
+        await question.getByRole('button', { name: 'Configure table columns' }).click();
+        await question.locator('[data-af-table-columns-container]').waitFor({ state: 'visible' });
+    }
+
+    /**
+     * Adds a column in the (already open) configuration dropdown.
+     * `type` is the visible label of a compatible question type (e.g. "Text").
+     */
+    public async addColumn(
+        question: Locator,
+        column: { name: string; type: string; required?: boolean },
+    ): Promise<void> {
+        await question.locator('[data-af-table-column-add]').click();
+
+        const row = question.locator('[data-af-table-column]').last();
+        await row.getByPlaceholder('Column name').fill(column.name);
+
+        // Column type is a select2-enhanced <select>.
+        const type_dropdown = row.locator('.select2-container').first();
+        await type_dropdown.waitFor({ state: 'visible' });
+        await this.doSetDropdownValue(type_dropdown, column.type, false);
+
+        if (column.required) {
+            await row.locator('.af-required-toggle').click();
+        }
+    }
+
+    /** The rendered end-user table container. */
+    public getEndUserTable(): Locator {
+        return this.page.locator('[data-af-table-question]');
+    }
+
+    /** A cell control of the rendered end-user table, by row and column index. */
+    public getEndUserCell(table: Locator, row: number, col: number): Locator {
+        // eslint-disable-next-line playwright/no-raw-locators
+        return table.locator(`[name$="[${row}][col_${col}]"]`);
+    }
+}
diff --git a/tests/e2e/specs/table_question.spec.ts b/tests/e2e/specs/table_question.spec.ts
new file mode 100644
index 0000000..9bb49d6
--- /dev/null
+++ b/tests/e2e/specs/table_question.spec.ts
@@ -0,0 +1,132 @@
+/**
+ * -------------------------------------------------------------------------
+ * advancedforms plugin for GLPI
+ * -------------------------------------------------------------------------
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * -------------------------------------------------------------------------
+ * @copyright Copyright (C) 2025 by the advancedforms plugin team.
+ * @license   MIT https://opensource.org/licenses/mit-license.php
+ * @link      https://github.com/pluginsGLPI/advancedforms
+ * -------------------------------------------------------------------------
+ */
+
+import { randomUUID } from 'crypto';
+import { test, expect, Page } from '../fixtures/advancedforms_fixture';
+import { FormPage } from '../../../../../tests/e2e/pages/FormPage';
+import { Profiles } from '../../../../../tests/e2e/utils/Profiles';
+import { getWorkerEntityId } from '../../../../../tests/e2e/utils/WorkerEntities';
+import { AdvancedFormsTablePage } from '../pages/AdvancedFormsTablePage';
+
+/**
+ * Builds a form with a single Table question through the editor and returns its id.
+ * The table has a required "Name" column and an optional "Comment" column,
+ * both rendered as plain text inputs.
+ */
+async function createFormWithTableQuestion(
+    page: Page,
+    api: { createItem(itemtype: string, fields: object): Promise<number> },
+    form_name: string,
+): Promise<number> {
+    const form = new FormPage(page);
+    const table = new AdvancedFormsTablePage(page);
+
+    await table.enableTableQuestionType();
+
+    const form_id = await api.createItem('Glpi\\Form\\Form', {
+        name: form_name,
+        entities_id: getWorkerEntityId(),
+    });
+    await form.goto(form_id);
+
+    const question = await form.addQuestion('Devices');
+    await form.doChangeQuestionType(question, 'Table');
+
+    await table.openColumnConfig(question);
+    await table.addColumn(question, { name: 'Name', type: 'Text', required: true });
+    await table.addColumn(question, { name: 'Comment', type: 'Text', required: false });
+
+    await form.doSaveFormEditor();
+
+    return form_id;
+}
+
+test.describe('Advanced forms - Table question', () => {
+    test('admin can configure and persist table columns', async ({ page, profile, api }) => {
+        await profile.set(Profiles.SuperAdmin);
+        const form = new FormPage(page);
+        const form_id = await createFormWithTableQuestion(
+            page,
+            api,
+            `E2E table config - ${randomUUID()}`,
+        );
+
+        // Reload the editor and check the columns survived the roundtrip.
+        await form.goto(form_id);
+        const question = page.getByRole('region', { name: 'Question details' }).first();
+        await expect(question.getByText('Name')).toBeVisible();
+        await expect(question.getByText('Comment')).toBeVisible();
+    });
+
+    test('end user can fill and submit the table', async ({ page, profile, api }) => {
+        await profile.set(Profiles.SuperAdmin);
+        const form = new FormPage(page);
+        const table = new AdvancedFormsTablePage(page);
+        const form_name = `E2E table submit - ${randomUUID()}`;
+
+        await createFormWithTableQuestion(page, api, form_name);
+        await form.doPreviewForm();
+
+        const eu_table = table.getEndUserTable();
+        await table.getEndUserCell(eu_table, 0, 0).fill('PC-001');
+        await table.getEndUserCell(eu_table, 0, 1).fill('Spare laptop');
+
+        await page.getByRole('button', { name: 'Submit' }).click();
+
+        // A link to the created answer/item confirms the submission succeeded.
+        await expect(page.getByRole('link', { name: form_name })).toBeVisible();
+    });
+
+    test('required column blocks submission and highlights the empty cell', async ({ page, profile, api }) => {
+        await profile.set(Profiles.SuperAdmin);
+        const form = new FormPage(page);
+        const table = new AdvancedFormsTablePage(page);
+
+        await createFormWithTableQuestion(page, api, `E2E table required - ${randomUUID()}`);
+        await form.doPreviewForm();
+
+        const eu_table = table.getEndUserTable();
+
+        // Fill only the optional column, leaving the required "Name" cell empty.
+        await table.getEndUserCell(eu_table, 0, 1).fill('Has a comment but no name');
+        await page.getByRole('button', { name: 'Submit' }).click();
+
+        // Submission is blocked: the error is shown and the empty required cell
+        // is highlighted, while the optional one is not.
+        await expect(eu_table.getByText('Please fill in all required columns.')).toBeVisible();
+        await expect(table.getEndUserCell(eu_table, 0, 0)).toHaveClass(/is-invalid/);
+        await expect(table.getEndUserCell(eu_table, 0, 1)).not.toHaveClass(/is-invalid/);
+
+        // Filling the required cell clears the error.
+        await table.getEndUserCell(eu_table, 0, 0).fill('PC-002');
+        await expect(table.getEndUserCell(eu_table, 0, 0)).not.toHaveClass(/is-invalid/);
+    });
+});