diff --git a/alembic/versions/20260904_1400_add_poll_option_groups.py b/alembic/versions/20260904_1400_add_poll_option_groups.py
new file mode 100644
index 0000000..dd871c2
--- /dev/null
+++ b/alembic/versions/20260904_1400_add_poll_option_groups.py
@@ -0,0 +1,53 @@
+"""add poll option groups
+
+Revision ID: 9d4e1f6a2b58
+Revises: 7a2c4f9e8b13
+Create Date: 2026-09-04 14:00:00
+
+"""
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "9d4e1f6a2b58"
+down_revision: str | None = "7a2c4f9e8b13"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    op.create_table(
+        "poll_option_groups",
+        sa.Column("id", sa.BigInteger(), autoincrement=True, nullable=False),
+        sa.Column("poll_id", sa.BigInteger(), nullable=False),
+        sa.Column("name", sa.String(), nullable=False),
+        sa.Column("max_selections", sa.Integer(), nullable=True),
+        sa.ForeignKeyConstraint(["poll_id"], ["polls.id"], ondelete="CASCADE"),
+        sa.PrimaryKeyConstraint("id"),
+        sa.Index("ix_poll_option_groups_poll_id", "poll_id"),
+        sa.CheckConstraint(
+            "max_selections IS NULL OR max_selections >= 1",
+            name="ck_poll_option_groups_max_selections_positive",
+        ),
+    )
+    op.add_column("poll_options", sa.Column("group_id", sa.BigInteger(), nullable=True))
+    op.create_foreign_key(
+        "fk_poll_options_group_id_poll_option_groups",
+        "poll_options",
+        "poll_option_groups",
+        ["group_id"],
+        ["id"],
+        ondelete="SET NULL",
+    )
+    op.create_index("ix_poll_options_group_id", "poll_options", ["group_id"])
+
+
+def downgrade() -> None:
+    op.drop_index("ix_poll_options_group_id", table_name="poll_options")
+    op.drop_constraint(
+        "fk_poll_options_group_id_poll_option_groups", "poll_options", type_="foreignkey"
+    )
+    op.drop_column("poll_options", "group_id")
+    op.drop_table("poll_option_groups")
diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md
index e5e4f2c..e8ced80 100644
--- a/docs/ARCHITECTURE.md
+++ b/docs/ARCHITECTURE.md
@@ -224,9 +224,11 @@ Core entities and how they relate. Field-level truth lives in `src/struudel/mode
 erDiagram
     User ||--o{ Poll : creates
     Poll ||--o{ PollOption : has
+    Poll ||--o{ PollOptionGroup : "option groups"
     Poll ||--o{ PollResponse : collects
     Poll }o--o{ User : "poll_users (audience)"
     Poll }o--o{ Group : "poll_groups (audience)"
+    PollOptionGroup ||--o{ PollOption : caps
     PollOption ||--o{ PollResponseOption : "voted on"
     PollResponse ||--o{ PollResponseOption : contains
     PollResponse }o--|| User : "by"
@@ -244,6 +246,7 @@ erDiagram
   - `SINGLE_CHOICE` — user picks exactly one option: exactly one `YES`, rest `NO`
   - `MULTI_CHOICE` — user picks N options: any number of `YES`, rest `NO`, no `MAYBE`
 - **Option types** are mixable per poll (`DATE`, `DATETIME`, `TEXT`). A CHECK constraint (`ck_poll_options_value_matches_type`) enforces that exactly the value column matching `option_type` is non-null.
+- **Option groups**: `PollOption.group_id` (nullable) optionally points at a `PollOptionGroup` — an author-defined subset of a poll's options with an optional `max_selections` cap (e.g. "max 1 of A and B"). A group's `max_selections`/`name` are single-sourced on `PollOptionGroup`, not duplicated per option. `group_id` uses `ondelete="SET NULL"`: deleting a group ungroups its member options — they stay on the poll with their votes intact, they just lose the cap.
 - **Custom options**: user-added options require `poll.allow_custom_options=True`; they carry `is_custom=True` and `created_by_id`. Other users can still vote on them.
 - **One response per user per poll**: enforced by `uq_poll_responses_poll_user`. Re-submitting overwrites. Edit window is bounded by `poll.allow_edit_responses` and `poll.edit_responses_until`.
 - **Lifecycle**: `starts_at` gates participation at runtime (no background flip; users simply can't vote yet). `ends_at` triggers an `ACTIVE → CLOSED` transition via the periodic Huey task `close_due_polls_task` (every 5 minutes, `tasks/poll/close_due.py`). `auto_delete_at` is set by the app when a poll transitions to `CLOSED` and the `auto_delete` flag in `poll.attributes` is truthy — the value is `now + settings.poll_retention_days` (default 30). The periodic Huey task `purge_expired_polls_task` (daily at 03:00 UTC, `tasks/poll/purge_expired.py`) deletes polls whose `auto_delete_at` has passed.
@@ -273,6 +276,11 @@ erDiagram
   is rejected in `SINGLE_CHOICE` and `MULTI_CHOICE`; `SINGLE_CHOICE` allows at most
   one YES; `MULTI_CHOICE` honours the `max_yes_choices` cap when set. Routes turn
   `InvalidVoteError` into a 400.
+- **Per-group selection caps**: independent of `response_mode` and unrelated to
+  `max_yes_choices` (no reconciliation between the two), `_validate_group_limits`
+  rejects a submission where the YES count among a `PollOptionGroup`'s member
+  options exceeds its `max_selections`. MAYBE never counts toward a group's cap.
+  Ungrouped options (`group_id IS NULL`) are never capped.
 - **Anonymity**: when `poll.attributes.anonymous_votes=True`, the response summary
   returns `ResponseRow.user=None` and the comment field is hidden in the UI (otherwise
   the comment becomes a fingerprint).
diff --git a/src/struudel/blueprints/polls/forms.py b/src/struudel/blueprints/polls/forms.py
index ac61f11..bd1bff9 100644
--- a/src/struudel/blueprints/polls/forms.py
+++ b/src/struudel/blueprints/polls/forms.py
@@ -46,6 +46,16 @@ def _normalize_to_utc(value: datetime | None) -> datetime | None:
 ]
 
 
+class PollOptionGroupData(BaseModel):
+    model_config = ConfigDict(str_strip_whitespace=True, extra="ignore")
+
+    client_key: str = Field(min_length=1)
+    name: str = Field(min_length=1)
+    max_selections: Annotated[int | None, BeforeValidator(_empty_to_none)] = Field(
+        default=None, ge=1
+    )
+
+
 class PollOptionData(BaseModel):
     model_config = ConfigDict(str_strip_whitespace=True, extra="ignore")
 
@@ -53,6 +63,7 @@ class PollOptionData(BaseModel):
     date_value: OptionalDate = None
     datetime_value: OptionalDateTime = None
     text_value: OptionalStr = None
+    group_client_key: OptionalStr = None
 
     @model_validator(mode="after")
     def _exactly_one_value(self) -> PollOptionData:
@@ -107,6 +118,10 @@ class PollForm(BaseModel):
         Json[list[PollOptionData]],
         BeforeValidator(_empty_to_empty_list),
     ] = Field(default_factory=list)
+    groups: Annotated[
+        Json[list[PollOptionGroupData]],
+        BeforeValidator(_empty_to_empty_list),
+    ] = Field(default_factory=list)
 
     audience_users: Annotated[
         Json[list[AudienceMember]],
@@ -147,6 +162,14 @@ def _check_max_yes_choices(self) -> PollForm:
             raise ValueError("max_yes_choices must be between 1 and 50")
         return self
 
+    @model_validator(mode="after")
+    def _check_option_group_references(self) -> PollForm:
+        group_keys = {g.client_key for g in self.groups}
+        for opt in self.options:
+            if opt.group_client_key is not None and opt.group_client_key not in group_keys:
+                raise ValueError(f"option references unknown group {opt.group_client_key!r}")
+        return self
+
 
 class VoteItem(BaseModel):
     model_config = ConfigDict(extra="ignore")
diff --git a/src/struudel/blueprints/polls/routes.py b/src/struudel/blueprints/polls/routes.py
index 3abd7dd..2469faf 100644
--- a/src/struudel/blueprints/polls/routes.py
+++ b/src/struudel/blueprints/polls/routes.py
@@ -19,7 +19,7 @@
 from struudel.database import SessionLocal
 from struudel.models.group import Group
 from struudel.models.poll import Poll, PollStatus
-from struudel.models.poll_option import PollOption, PollOptionType
+from struudel.models.poll_option import PollOption, PollOptionGroup, PollOptionType
 from struudel.models.poll_response import PollResponse
 from struudel.models.user import User
 from struudel.services import poll as poll_service
@@ -108,6 +108,7 @@ def new() -> str | Response | tuple[str, int]:
             poll=None,
             form_data={},
             poll_options=[],
+            poll_option_groups=[],
             initial_users=[],
             initial_groups=[],
             errors=[],
@@ -121,7 +122,8 @@ def new() -> str | Response | tuple[str, int]:
                 "polls/edit.html",
                 poll=None,
                 form_data=request.form,
-                poll_options=_form_options_fallback(request.form.get("options", "")),
+                poll_options=_form_list_fallback(request.form.get("options", "")),
+                poll_option_groups=_form_list_fallback(request.form.get("groups", "")),
                 initial_users=_audience_chips_from_form(
                     request.form.get("audience_users", ""), "user"
                 ),
@@ -148,7 +150,8 @@ def new() -> str | Response | tuple[str, int]:
                     "polls/edit.html",
                     poll=None,
                     form_data=request.form,
-                    poll_options=_form_options_fallback(request.form.get("options", "")),
+                    poll_options=_form_list_fallback(request.form.get("options", "")),
+                    poll_option_groups=_form_list_fallback(request.form.get("groups", "")),
                     initial_users=_audience_chips_from_form(
                         request.form.get("audience_users", ""), "user"
                     ),
@@ -165,7 +168,8 @@ def new() -> str | Response | tuple[str, int]:
                     "polls/edit.html",
                     poll=None,
                     form_data=request.form,
-                    poll_options=_form_options_fallback(request.form.get("options", "")),
+                    poll_options=_form_list_fallback(request.form.get("options", "")),
+                    poll_option_groups=_form_list_fallback(request.form.get("groups", "")),
                     initial_users=_audience_chips_from_form(
                         request.form.get("audience_users", ""), "user"
                     ),
@@ -182,7 +186,8 @@ def new() -> str | Response | tuple[str, int]:
                     "polls/edit.html",
                     poll=None,
                     form_data=request.form,
-                    poll_options=_form_options_fallback(request.form.get("options", "")),
+                    poll_options=_form_list_fallback(request.form.get("options", "")),
+                    poll_option_groups=_form_list_fallback(request.form.get("groups", "")),
                     initial_users=_audience_chips_from_form(
                         request.form.get("audience_users", ""), "user"
                     ),
@@ -199,7 +204,8 @@ def new() -> str | Response | tuple[str, int]:
                     "polls/edit.html",
                     poll=None,
                     form_data=request.form,
-                    poll_options=_form_options_fallback(request.form.get("options", "")),
+                    poll_options=_form_list_fallback(request.form.get("options", "")),
+                    poll_option_groups=_form_list_fallback(request.form.get("groups", "")),
                     initial_users=_audience_chips_from_form(
                         request.form.get("audience_users", ""), "user"
                     ),
@@ -232,6 +238,7 @@ def edit(poll_id: int) -> str | Response | tuple[str, int]:
                 poll=poll,
                 form_data=_poll_to_form_data(poll),
                 poll_options=_poll_options_to_dicts(poll.options),
+                poll_option_groups=_poll_option_groups_to_dicts(poll.option_groups),
                 initial_users=_audience_users_to_dicts(users),
                 initial_groups=_audience_groups_to_dicts(groups),
                 errors=[],
@@ -245,10 +252,14 @@ def edit(poll_id: int) -> str | Response | tuple[str, int]:
                     "polls/edit.html",
                     poll=poll,
                     form_data=request.form,
-                    poll_options=_form_options_fallback(
+                    poll_options=_form_list_fallback(
                         request.form.get("options", ""),
                         fallback=_poll_options_to_dicts(poll.options),
                     ),
+                    poll_option_groups=_form_list_fallback(
+                        request.form.get("groups", ""),
+                        fallback=_poll_option_groups_to_dicts(poll.option_groups),
+                    ),
                     initial_users=_audience_chips_from_form(
                         request.form.get("audience_users", ""), "user"
                     ),
@@ -269,10 +280,14 @@ def edit(poll_id: int) -> str | Response | tuple[str, int]:
                 "polls/edit.html",
                 poll=poll,
                 form_data=request.form,
-                poll_options=_form_options_fallback(
+                poll_options=_form_list_fallback(
                     request.form.get("options", ""),
                     fallback=_poll_options_to_dicts(poll.options),
                 ),
+                poll_option_groups=_form_list_fallback(
+                    request.form.get("groups", ""),
+                    fallback=_poll_option_groups_to_dicts(poll.option_groups),
+                ),
                 initial_users=_audience_chips_from_form(
                     request.form.get("audience_users", ""), "user"
                 ),
@@ -297,10 +312,14 @@ def edit(poll_id: int) -> str | Response | tuple[str, int]:
                     "polls/edit.html",
                     poll=poll,
                     form_data=request.form,
-                    poll_options=_form_options_fallback(
+                    poll_options=_form_list_fallback(
                         request.form.get("options", ""),
                         fallback=_poll_options_to_dicts(poll.options),
                     ),
+                    poll_option_groups=_form_list_fallback(
+                        request.form.get("groups", ""),
+                        fallback=_poll_option_groups_to_dicts(poll.option_groups),
+                    ),
                     initial_users=_audience_chips_from_form(
                         request.form.get("audience_users", ""), "user"
                     ),
@@ -317,10 +336,14 @@ def edit(poll_id: int) -> str | Response | tuple[str, int]:
                     "polls/edit.html",
                     poll=poll,
                     form_data=request.form,
-                    poll_options=_form_options_fallback(
+                    poll_options=_form_list_fallback(
                         request.form.get("options", ""),
                         fallback=_poll_options_to_dicts(poll.options),
                     ),
+                    poll_option_groups=_form_list_fallback(
+                        request.form.get("groups", ""),
+                        fallback=_poll_option_groups_to_dicts(poll.option_groups),
+                    ),
                     initial_users=_audience_chips_from_form(
                         request.form.get("audience_users", ""), "user"
                     ),
@@ -337,10 +360,14 @@ def edit(poll_id: int) -> str | Response | tuple[str, int]:
                     "polls/edit.html",
                     poll=poll,
                     form_data=request.form,
-                    poll_options=_form_options_fallback(
+                    poll_options=_form_list_fallback(
                         request.form.get("options", ""),
                         fallback=_poll_options_to_dicts(poll.options),
                     ),
+                    poll_option_groups=_form_list_fallback(
+                        request.form.get("groups", ""),
+                        fallback=_poll_option_groups_to_dicts(poll.option_groups),
+                    ),
                     initial_users=_audience_chips_from_form(
                         request.form.get("audience_users", ""), "user"
                     ),
@@ -357,10 +384,14 @@ def edit(poll_id: int) -> str | Response | tuple[str, int]:
                     "polls/edit.html",
                     poll=poll,
                     form_data=request.form,
-                    poll_options=_form_options_fallback(
+                    poll_options=_form_list_fallback(
                         request.form.get("options", ""),
                         fallback=_poll_options_to_dicts(poll.options),
                     ),
+                    poll_option_groups=_form_list_fallback(
+                        request.form.get("groups", ""),
+                        fallback=_poll_option_groups_to_dicts(poll.option_groups),
+                    ),
                     initial_users=_audience_chips_from_form(
                         request.form.get("audience_users", ""), "user"
                     ),
@@ -576,8 +607,9 @@ def _poll_to_form_data(poll: Poll) -> dict[str, Any]:
     passthrough_attributes: set[str] = {"max_yes_choices"}
     audience_fields: set[str] = {"audience_users", "audience_groups"}
     for name in PollForm.model_fields:
-        if name == "options" or name in audience_fields:
-            # rendered separately via initial_users / initial_groups / poll_options
+        if name in {"options", "groups"} or name in audience_fields:
+            # rendered separately via initial_users / initial_groups / poll_options /
+            # poll_option_groups
             continue
         if name in bool_attribute_defaults:
             data[name] = bool(poll.attributes.get(name, bool_attribute_defaults[name]))
@@ -616,10 +648,22 @@ def _poll_options_to_dicts(options: Iterable[PollOption]) -> list[dict[str, Any]
             entry["datetime_value"] = to_local(o.datetime_value).strftime("%Y-%m-%dT%H:%M")
         elif o.option_type == PollOptionType.TEXT:
             entry["text_value"] = o.text_value or ""
+        entry["group_client_key"] = str(o.group_id) if o.group_id is not None else None
         result.append(entry)
     return result
 
 
+def _poll_option_groups_to_dicts(groups: Iterable[PollOptionGroup]) -> list[dict[str, Any]]:
+    return [
+        {
+            "client_key": str(g.id),
+            "name": g.name,
+            "max_selections": g.max_selections,
+        }
+        for g in groups
+    ]
+
+
 def _render_vote(
     db: Any,
     *,
@@ -643,6 +687,9 @@ def _render_vote(
             "id": o.id,
             "label": _option_label(o),
             "is_custom": o.is_custom,
+            "group_id": o.group_id,
+            "group_name": o.group.name if o.group is not None else None,
+            "group_max_selections": o.group.max_selections if o.group is not None else None,
         }
         for o in options
     ]
@@ -719,13 +766,13 @@ def _audience_groups_to_dicts(groups: Iterable[Any]) -> list[dict[str, Any]]:
     ]
 
 
-def _form_options_fallback(
+def _form_list_fallback(
     raw: str, fallback: list[dict[str, Any]] | None = None
 ) -> list[dict[str, Any]]:
     try:
         parsed = json.loads(raw) if raw else []
     except (ValueError, TypeError):
-        log.debug("invalid options payload on form re-render, using fallback")
+        log.debug("invalid list payload on form re-render, using fallback")
         return fallback or []
     if not isinstance(parsed, list):
         return fallback or []
diff --git a/src/struudel/blueprints/polls/templates/polls/edit.html b/src/struudel/blueprints/polls/templates/polls/edit.html
index ceb91d6..632bdfe 100644
--- a/src/struudel/blueprints/polls/templates/polls/edit.html
+++ b/src/struudel/blueprints/polls/templates/polls/edit.html
@@ -363,7 +363,32 @@ <h1 class="text-2xl font-bold flex-1 truncate">
         </div>
         {% endif %}
 
-        <div x-data='optionsEditor({{ poll_options | tojson }})' class="space-y-2">
+        <div x-data='optionsEditor({{ poll_options | tojson }}, {{ poll_option_groups | tojson }})' class="space-y-2">
+            <div class="rounded-lg bg-base-200/40 border border-base-200 p-3 space-y-2">
+                <div class="flex items-center justify-between">
+                    <span class="text-xs font-semibold text-base-content/70">Groups</span>
+                    <button type="button" @click="addGroup()" class="btn btn-ghost btn-xs">
+                        <i class="ti ti-plus"></i>Add group
+                    </button>
+                </div>
+                <p class="text-xs text-base-content/55">
+                    Group options together to cap how many of them a voter may select, e.g. "max 1 of A and B".
+                </p>
+                <template x-for="group in optionGroups" :key="group._uid">
+                    <div class="flex items-center gap-2">
+                        <input type="text" x-model="group.name" placeholder="Group name"
+                               class="input input-sm flex-1">
+                        <input type="number" x-model.number="group.maxSelections" min="1"
+                               placeholder="Max" class="input input-sm w-20" title="Max selections in this group">
+                        <button type="button" @click="removeGroup(group._uid)"
+                                class="btn btn-ghost btn-sm text-base-content/40 hover:text-error" title="Remove group">
+                            <i class="ti ti-trash"></i>
+                        </button>
+                    </div>
+                </template>
+                <div x-show="optionGroups.length === 0" class="text-xs text-base-content/50">No groups yet.</div>
+            </div>
+
             <ul x-ref="list" class="space-y-2">
                 <template x-for="(opt, idx) in options" :key="opt._uid">
                     <li class="group flex items-stretch gap-2 bg-base-100 border border-base-300 rounded-lg p-2 hover:border-base-content/20 transition-colors">
@@ -376,6 +401,13 @@ <h1 class="text-2xl font-bold flex-1 truncate">
                             <option value="DATETIME">Date + time</option>
                             <option value="TEXT">Text</option>
                         </select>
+                        <select x-model.number="opt.group_uid" x-show="optionGroups.length > 0"
+                                class="select select-sm w-36" title="Group">
+                            <option :value="null" :selected="opt.group_uid === null">No group</option>
+                            <template x-for="group in optionGroups" :key="group._uid">
+                                <option :value="group._uid" :selected="group._uid === opt.group_uid" x-text="group.name || 'Unnamed group'"></option>
+                            </template>
+                        </select>
                         <template x-if="opt.type === 'DATE'">
                             <input type="date" x-model="opt.date_value"
                                    class="input input-sm flex-1">
@@ -412,6 +444,7 @@ <h1 class="text-2xl font-bold flex-1 truncate">
             </button>
 
             <input type="hidden" name="options" :value="serialize()">
+            <input type="hidden" name="groups" :value="serializeGroups()">
         </div>
 
         <p x-show="status === 'ACTIVE' && !hasOptions" x-cloak
diff --git a/src/struudel/blueprints/polls/templates/polls/vote.html b/src/struudel/blueprints/polls/templates/polls/vote.html
index 6c6aa42..793b25a 100644
--- a/src/struudel/blueprints/polls/templates/polls/vote.html
+++ b/src/struudel/blueprints/polls/templates/polls/vote.html
@@ -129,6 +129,14 @@ <h1 class="text-2xl font-bold flex-1 truncate">{{ poll.title }}</h1>
             </div>
             {% endif %}
 
+            <template x-for="g in groupsSummary()" :key="g.id">
+                <div class="text-xs"
+                     :class="g.count >= g.max ? 'text-warning font-medium' : 'text-base-content/60'">
+                    <i class="ti ti-list-check"></i>
+                    <span x-text="g.name"></span>: <span x-text="g.count"></span> / <span x-text="g.max"></span> selected<span x-show="g.count >= g.max"> — limit reached</span>
+                </div>
+            </template>
+
             <ul class="divide-y divide-base-200 -mx-6 border-y border-base-200">
                 {% for opt in options %}
                 <li class="flex items-center gap-3 px-6 py-3 hover:bg-base-200/40 transition-colors"
@@ -139,6 +147,9 @@ <h1 class="text-2xl font-bold flex-1 truncate">{{ poll.title }}</h1>
                         {% if opt.is_custom %}
                         <span class="badge badge-ghost badge-sm">custom</span>
                         {% endif %}
+                        {% if opt.group %}
+                        <span class="badge badge-outline badge-sm">{{ opt.group.name }}</span>
+                        {% endif %}
                     </div>
 
                     {% if poll.allow_guests %}
@@ -157,6 +168,7 @@ <h1 class="text-2xl font-bold flex-1 truncate">{{ poll.title }}</h1>
                     <div class="join">
                         <button type="button"
                                 @click="set({{ opt.id }}, 'YES')"
+                                :disabled="!canSelect({{ opt.id }})"
                                 :class="votes[{{ opt.id }}] === 'YES' ? 'btn-success' : ''"
                                 class="btn btn-sm join-item" title="Yes">
                             <i class="ti ti-check"></i>
@@ -177,6 +189,7 @@ <h1 class="text-2xl font-bold flex-1 truncate">{{ poll.title }}</h1>
                     {% elif mode == 'SINGLE_CHOICE' %}
                     <button type="button"
                             @click="set({{ opt.id }}, 'YES')"
+                            :disabled="!canSelect({{ opt.id }})"
                             :class="votes[{{ opt.id }}] === 'YES' ? 'btn-success' : 'btn-ghost'"
                             class="btn btn-sm">
                         <i class="ti ti-check" x-show="votes[{{ opt.id }}] === 'YES'"></i>
diff --git a/src/struudel/models/__init__.py b/src/struudel/models/__init__.py
index f7f19b3..e22a911 100644
--- a/src/struudel/models/__init__.py
+++ b/src/struudel/models/__init__.py
@@ -4,6 +4,7 @@
 from struudel.models.poll import PollStatus as PollStatus
 from struudel.models.poll import PollVisibility as PollVisibility
 from struudel.models.poll_option import PollOption as PollOption
+from struudel.models.poll_option import PollOptionGroup as PollOptionGroup
 from struudel.models.poll_option import PollOptionType as PollOptionType
 from struudel.models.poll_response import PollResponse as PollResponse
 from struudel.models.poll_response import PollResponseOption as PollResponseOption
@@ -14,6 +15,7 @@
     "Group",
     "Poll",
     "PollOption",
+    "PollOptionGroup",
     "PollOptionType",
     "PollResponse",
     "PollResponseMode",
diff --git a/src/struudel/models/poll.py b/src/struudel/models/poll.py
index 5f9954a..01d7426 100644
--- a/src/struudel/models/poll.py
+++ b/src/struudel/models/poll.py
@@ -15,7 +15,7 @@
 
 if TYPE_CHECKING:
     from struudel.models.group import Group
-    from struudel.models.poll_option import PollOption
+    from struudel.models.poll_option import PollOption, PollOptionGroup
     from struudel.models.poll_response import PollResponse
     from struudel.models.user import User
 
@@ -123,6 +123,11 @@ class Poll(Base, TimestampMixin):
         cascade="all, delete-orphan",
         order_by="PollOption.sort_order",
     )
+    option_groups: Mapped[list[PollOptionGroup]] = relationship(
+        "PollOptionGroup",
+        back_populates="poll",
+        cascade="all, delete-orphan",
+    )
     responses: Mapped[list[PollResponse]] = relationship(
         "PollResponse",
         back_populates="poll",
diff --git a/src/struudel/models/poll_option.py b/src/struudel/models/poll_option.py
index 96f37f7..658bba7 100644
--- a/src/struudel/models/poll_option.py
+++ b/src/struudel/models/poll_option.py
@@ -22,6 +22,31 @@ class PollOptionType(StrEnum):
     TEXT = "TEXT"
 
 
+class PollOptionGroup(Base):
+    __tablename__ = "poll_option_groups"
+    __table_args__ = (
+        sa.CheckConstraint(
+            "max_selections IS NULL OR max_selections >= 1",
+            name="ck_poll_option_groups_max_selections_positive",
+        ),
+    )
+
+    id: Mapped[int] = mapped_column(sa.BigInteger, primary_key=True)
+    poll_id: Mapped[int] = mapped_column(
+        sa.BigInteger,
+        sa.ForeignKey("polls.id", ondelete="CASCADE"),
+        index=True,
+    )
+    name: Mapped[str] = mapped_column(sa.String())
+    max_selections: Mapped[int | None] = mapped_column(sa.Integer())
+
+    poll: Mapped[Poll] = relationship("Poll", back_populates="option_groups")
+    options: Mapped[list[PollOption]] = relationship("PollOption", back_populates="group")
+
+    def __repr__(self) -> str:
+        return f"<PollOptionGroup id={self.id} poll_id={self.poll_id} name={self.name!r}>"
+
+
 class PollOption(Base, TimestampMixin):
     __tablename__ = "poll_options"
     __table_args__ = (
@@ -65,9 +90,15 @@ class PollOption(Base, TimestampMixin):
         sa.BigInteger,
         sa.ForeignKey("users.id", ondelete="SET NULL"),
     )
+    group_id: Mapped[int | None] = mapped_column(
+        sa.BigInteger,
+        sa.ForeignKey("poll_option_groups.id", ondelete="SET NULL"),
+        index=True,
+    )
 
     poll: Mapped[Poll] = relationship("Poll", back_populates="options")
     created_by: Mapped[User | None] = relationship("User", foreign_keys=[created_by_id])
+    group: Mapped[PollOptionGroup | None] = relationship("PollOptionGroup", back_populates="options")
     response_votes: Mapped[list[PollResponseOption]] = relationship(
         "PollResponseOption",
         back_populates="option",
diff --git a/src/struudel/services/poll.py b/src/struudel/services/poll.py
index c75171c..0c16c55 100644
--- a/src/struudel/services/poll.py
+++ b/src/struudel/services/poll.py
@@ -12,7 +12,7 @@
 from struudel.config import settings
 
 if TYPE_CHECKING:
-    from struudel.blueprints.polls.forms import PollForm, PollOptionData
+    from struudel.blueprints.polls.forms import PollForm, PollOptionData, PollOptionGroupData
 from struudel.models.associations import (
     poll_groups,
     poll_users,
@@ -20,7 +20,7 @@
 )
 from struudel.models.group import Group
 from struudel.models.poll import Poll, PollResponseMode, PollStatus, PollVisibility
-from struudel.models.poll_option import PollOption, PollOptionType
+from struudel.models.poll_option import PollOption, PollOptionGroup, PollOptionType
 from struudel.models.poll_response import PollResponse, PollResponseOption, PollResponseStatus
 from struudel.models.user import User
 
@@ -398,7 +398,10 @@ def create_poll(
     _apply_auto_delete_at(poll)
     db.add(poll)
     db.flush()
-    _apply_options(db, poll=poll, options=form.options)
+    group_id_by_client_key = _apply_groups(db, poll=poll, groups=form.groups)
+    _apply_options(
+        db, poll=poll, options=form.options, group_id_by_client_key=group_id_by_client_key
+    )
     db.commit()
     db.refresh(poll)
 
@@ -478,7 +481,10 @@ def update_poll(
     poll.attributes = attributes
     _apply_auto_delete_at(poll)
 
-    _apply_options(db, poll=poll, options=form.options)
+    group_id_by_client_key = _apply_groups(db, poll=poll, groups=form.groups)
+    _apply_options(
+        db, poll=poll, options=form.options, group_id_by_client_key=group_id_by_client_key
+    )
     db.commit()
     db.refresh(poll)
 
@@ -632,7 +638,54 @@ def options_have_destructive_changes(
     return any(_model_option_key(o) not in new_keys for o in existing)
 
 
-def _apply_options(db: Session, *, poll: Poll, options: list[PollOptionData]) -> None:
+def _apply_groups(db: Session, *, poll: Poll, groups: list[PollOptionGroupData]) -> dict[str, int]:
+    """Upserts poll.option_groups from the submitted list, deletes removed ones
+    (their options are ungrouped via ON DELETE SET NULL, not deleted), and
+    returns client_key -> real group_id.
+
+    A submitted group's `client_key` is the stringified existing group id for a
+    group that already exists, or an opaque client-generated value (e.g. "new-1")
+    for one being created — see PollOptionGroupData.
+    """
+    existing_by_id = {
+        g.id: g
+        for g in db.scalars(sa.select(PollOptionGroup).where(PollOptionGroup.poll_id == poll.id))
+    }
+
+    client_key_to_id: dict[str, int] = {}
+    kept_ids: set[int] = set()
+    for g in groups:
+        existing = existing_by_id.get(int(g.client_key)) if g.client_key.isdigit() else None
+        if existing is not None:
+            existing.name = g.name
+            existing.max_selections = g.max_selections
+            kept_ids.add(existing.id)
+            client_key_to_id[g.client_key] = existing.id
+        else:
+            new_group = PollOptionGroup(
+                poll_id=poll.id, name=g.name, max_selections=g.max_selections
+            )
+            db.add(new_group)
+            db.flush()
+            kept_ids.add(new_group.id)
+            client_key_to_id[g.client_key] = new_group.id
+
+    to_delete = [gid for gid in existing_by_id if gid not in kept_ids]
+    if to_delete:
+        db.execute(sa.delete(PollOptionGroup).where(PollOptionGroup.id.in_(to_delete)))
+
+    db.flush()
+    return client_key_to_id
+
+
+def _apply_options(
+    db: Session,
+    *,
+    poll: Poll,
+    options: list[PollOptionData],
+    group_id_by_client_key: dict[str, int] | None = None,
+) -> None:
+    group_id_by_client_key = group_id_by_client_key or {}
     existing = list(
         db.scalars(
             sa.select(PollOption).where(
@@ -647,10 +700,14 @@ def _apply_options(db: Session, *, poll: Poll, options: list[PollOptionData]) ->
 
     kept_ids: set[int] = set()
     for idx, opt in enumerate(options):
+        group_id = (
+            group_id_by_client_key.get(opt.group_client_key) if opt.group_client_key else None
+        )
         match = existing_by_key.get(_form_option_key(opt))
         if match is not None and match.id not in kept_ids:
             if match.sort_order != idx:
                 match.sort_order = idx
+            match.group_id = group_id
             kept_ids.add(match.id)
         else:
             db.add(
@@ -659,6 +716,7 @@ def _apply_options(db: Session, *, poll: Poll, options: list[PollOptionData]) ->
                     option_type=opt.type,
                     sort_order=idx,
                     is_custom=False,
+                    group_id=group_id,
                     date_value=opt.date_value if opt.type == PollOptionType.DATE else None,
                     datetime_value=(
                         opt.datetime_value if opt.type == PollOptionType.DATETIME else None
@@ -1053,9 +1111,13 @@ def submit_response(
     comment: str | None,
     guest_counts: dict[int, int] | None = None,
 ) -> PollResponse:
-    valid_option_ids = set(
-        db.scalars(sa.select(PollOption.id).where(PollOption.poll_id == poll.id)).all()
-    )
+    option_rows = db.execute(
+        sa.select(PollOption.id, PollOption.group_id, PollOptionGroup.max_selections)
+        .select_from(PollOption)
+        .outerjoin(PollOptionGroup, PollOption.group_id == PollOptionGroup.id)
+        .where(PollOption.poll_id == poll.id)
+    ).all()
+    valid_option_ids = {row.id for row in option_rows}
     if not valid_option_ids:
         raise InvalidVoteError("This poll has no options to vote on")
 
@@ -1063,6 +1125,8 @@ def submit_response(
     guest_counts = guest_counts or {}
 
     _validate_votes_against_mode(poll=poll, votes=filtered_votes)
+    option_group_info = {row.id: (row.group_id, row.max_selections) for row in option_rows}
+    _validate_group_limits(votes=filtered_votes, option_group_info=option_group_info)
 
     # Idempotent upsert via the (poll_id, user_id) unique constraint, so two
     # parallel submits from the same user collapse into one row instead of
@@ -1124,3 +1188,26 @@ def _validate_votes_against_mode(*, poll: Poll, votes: dict[int, PollResponseSta
         max_yes = poll.attributes.get("max_yes_choices")
         if isinstance(max_yes, int) and max_yes > 0 and yes_count > max_yes:
             raise InvalidVoteError(f"This poll allows at most {max_yes} selection(s)")
+
+
+def _validate_group_limits(
+    *,
+    votes: dict[int, PollResponseStatus],
+    option_group_info: dict[int, tuple[int | None, int | None]],
+) -> None:
+    """Enforces PollOptionGroup.max_selections, independent of response_mode."""
+    group_yes_counts: dict[int, int] = {}
+    group_max: dict[int, int] = {}
+    for option_id, status in votes.items():
+        if status != PollResponseStatus.YES:
+            continue
+        group_id, max_selections = option_group_info.get(option_id, (None, None))
+        if group_id is None or max_selections is None:
+            continue
+        group_yes_counts[group_id] = group_yes_counts.get(group_id, 0) + 1
+        group_max[group_id] = max_selections
+
+    for group_id, count in group_yes_counts.items():
+        max_selections = group_max[group_id]
+        if count > max_selections:
+            raise InvalidVoteError(f"This group allows at most {max_selections} selection(s)")
diff --git a/src/struudel/static/js/polls-edit.js b/src/struudel/static/js/polls-edit.js
index d990a58..28a9c25 100644
--- a/src/struudel/static/js/polls-edit.js
+++ b/src/struudel/static/js/polls-edit.js
@@ -32,10 +32,24 @@ function dateHourPicker(initial) {
     };
 }
 
-function optionsEditor(initial) {
+function optionsEditor(initial, initialGroups) {
     let seq = 0;
+    let groupSeq = 0;
+    const mkGroup = (g) => ({
+        _uid: ++groupSeq,
+        clientKey: (g && g.client_key) || `new-${groupSeq}`,
+        name: (g && g.name) || "",
+        maxSelections: (g && g.max_selections) || null,
+    });
+    const optionGroups = (initialGroups || []).map(mkGroup);
+    const groupUidByClientKey = {};
+    optionGroups.forEach((g) => {
+        groupUidByClientKey[g.clientKey] = g._uid;
+    });
+
     const mk = (o) => {
         const dt = (o && o.datetime_value) || "";
+        const groupClientKey = (o && o.group_client_key) || null;
         return {
             _uid: ++seq,
             type: (o && o.type) || "DATE",
@@ -43,10 +57,12 @@ function optionsEditor(initial) {
             datetime_date: dt.length >= 10 ? dt.slice(0, 10) : "",
             datetime_hour: dt.length >= 13 ? dt.slice(11, 13) : "10",
             text_value: (o && o.text_value) || "",
+            group_uid: groupClientKey ? groupUidByClientKey[groupClientKey] ?? null : null,
         };
     };
     return {
         options: (initial || []).map(mk),
+        optionGroups,
         init() {
             this.$watch("options", (val) => {
                 this.$dispatch("options-count-changed", { count: val.length });
@@ -64,11 +80,35 @@ function optionsEditor(initial) {
             });
         },
         add() {
-            this.options.push(mk());
+            const above = this.options[this.options.length - 1];
+            const newOption = mk();
+            newOption.group_uid = above ? above.group_uid : null;
+            this.options.push(newOption);
         },
         remove(i) {
             this.options.splice(i, 1);
         },
+        addGroup() {
+            this.optionGroups.push(mkGroup());
+        },
+        // Matches the server-side FK (ON DELETE SET NULL): removing a group
+        // ungroups its member options rather than deleting them.
+        removeGroup(gUid) {
+            this.options.forEach((o) => {
+                if (o.group_uid === gUid) o.group_uid = null;
+            });
+            this.optionGroups = this.optionGroups.filter((g) => g._uid !== gUid);
+        },
+        groupFor(opt) {
+            return this.optionGroups.find((g) => g._uid === opt.group_uid) || null;
+        },
+        serializeGroups() {
+            return JSON.stringify(this.optionGroups.map((g) => ({
+                client_key: g.clientKey,
+                name: g.name,
+                max_selections: g.maxSelections || null,
+            })));
+        },
         serialize() {
             return JSON.stringify(this.options.map((o) => {
                 const base = { type: o.type };
@@ -79,6 +119,8 @@ function optionsEditor(initial) {
                         : null;
                 }
                 if (o.type === "TEXT") base.text_value = o.text_value || null;
+                const group = this.groupFor(o);
+                base.group_client_key = group ? group.clientKey : null;
                 return base;
             }));
         },
diff --git a/src/struudel/static/js/polls-vote.js b/src/struudel/static/js/polls-vote.js
index eee62c5..be201c6 100644
--- a/src/struudel/static/js/polls-vote.js
+++ b/src/struudel/static/js/polls-vote.js
@@ -5,19 +5,29 @@
 //
 // Required keys:
 //   mode            "YES_NO_MAYBE" | "SINGLE_CHOICE" | "MULTI_CHOICE"
-//   options         [{id, ...}, ...] — order does not matter
+//   options         [{id, group_id, group_name, group_max_selections, ...}, ...] — order does not matter
 //   initialVotes    { [optId]: "YES" | "MAYBE" | "NO" }
 //   initialGuests   { [optId]: number }   — 0 if unset
 //   maxYes          number | null         — only used in MULTI_CHOICE
 //   allowGuests     boolean
 //   maxGuests       number | null         — null means unlimited
+//
+// Option groups cap how many YES votes a voter may cast among a poll
+// author-defined subset of options (e.g. "max 1 of A and B"), independent
+// of `mode`/`maxYes` — the two mechanisms are enforced separately.
 
 function voteEditor({ mode, options, initialVotes, initialGuests, maxYes, allowGuests, maxGuests }) {
     const votes = {};
     const guests = {};
+    const groupByOption = {};
     options.forEach((o) => {
         votes[o.id] = initialVotes[o.id] || "NO";
         guests[o.id] = initialGuests[o.id] || 0;
+        groupByOption[o.id] = {
+            id: o.group_id,
+            name: o.group_name,
+            max: o.group_max_selections,
+        };
     });
     return {
         mode,
@@ -26,7 +36,19 @@ function voteEditor({ mode, options, initialVotes, initialGuests, maxYes, allowG
         maxGuests,
         votes,
         guests,
+        groupYesCount(groupId) {
+            return Object.entries(this.votes).filter(
+                ([id, status]) => status === "YES" && groupByOption[id].id === groupId,
+            ).length;
+        },
+        canSelectGroup(id) {
+            const group = groupByOption[id];
+            if (!group || group.id === null || !group.max) return true;
+            if (this.votes[id] === "YES") return true;
+            return this.groupYesCount(group.id) < group.max;
+        },
         set(id, status) {
+            if (status === "YES" && !this.canSelectGroup(id)) return;
             if (this.mode === "SINGLE_CHOICE" && status === "YES") {
                 for (const k of Object.keys(this.votes)) {
                     this.votes[k] = "NO";
@@ -53,6 +75,7 @@ function voteEditor({ mode, options, initialVotes, initialGuests, maxYes, allowG
             return Object.values(this.votes).filter((v) => v === "YES").length;
         },
         canSelect(id) {
+            if (!this.canSelectGroup(id)) return false;
             if (this.mode !== "MULTI_CHOICE" || !this.maxYes) return true;
             if (this.votes[id] === "YES") return true;
             return this.yesCount() < this.maxYes;
@@ -60,6 +83,21 @@ function voteEditor({ mode, options, initialVotes, initialGuests, maxYes, allowG
         limitReached() {
             return this.mode === "MULTI_CHOICE" && this.maxYes && this.yesCount() >= this.maxYes;
         },
+        groupsSummary() {
+            const seen = new Set();
+            const summary = [];
+            for (const o of options) {
+                if (o.group_id === null || !o.group_max_selections || seen.has(o.group_id)) continue;
+                seen.add(o.group_id);
+                summary.push({
+                    id: o.group_id,
+                    name: o.group_name,
+                    max: o.group_max_selections,
+                    count: this.groupYesCount(o.group_id),
+                });
+            }
+            return summary;
+        },
         serialize() {
             return JSON.stringify(
                 Object.entries(this.votes).map(([option_id, status]) => ({