diff --git a/apps/blog/templates/blog/blog_detail.html b/apps/blog/templates/blog/blog_detail.html
index c3eaec0..62ba78f 100644
--- a/apps/blog/templates/blog/blog_detail.html
+++ b/apps/blog/templates/blog/blog_detail.html
@@ -1,6 +1,7 @@
 {% extends 'base.html' %}
 {% load static %}
 {% load image_tags %}
+{% load poll_tags %}
 
 {% block title %}{{ post.title }} - Snowsune Blog{% endblock %}
 
@@ -20,6 +21,7 @@
 
 {% block extra_css %}
 <link rel="stylesheet" href="{% static 'css/blog.css' %}">
+<link rel="stylesheet" href="{% static 'polls/css/polls.css' %}">
 {% endblock %}
 
 {% block extra_head %}
@@ -100,6 +102,16 @@ <h1 class="post-title">{{ post.title }}</h1>
             {{ post.content_html|safe }}
         </div>
 
+        {% if post.poll %}
+        <section class="post-poll">
+            <h2>Poll</h2>
+            {% poll_widget post.poll %}
+            <p class="poll-discuss">
+                <a href="{{ post.poll.get_absolute_url }}">Open poll page →</a>
+            </p>
+        </section>
+        {% endif %}
+
         <!-- Post Footer -->
         <footer class="post-footer">
             <div class="post-actions">
diff --git a/apps/blog/views.py b/apps/blog/views.py
index 312e7c0..22febe3 100644
--- a/apps/blog/views.py
+++ b/apps/blog/views.py
@@ -42,7 +42,7 @@ class BlogListView(ListView):
     def get_queryset(self):
         queryset = (
             BlogPost.objects.filter(status="published")
-            .select_related("author")
+            .select_related("author", "poll")
             .prefetch_related("tags")
         )
 
@@ -75,7 +75,9 @@ class BlogDetailView(DetailView):
     context_object_name = "post"
 
     def get_queryset(self):
-        return BlogPost.objects.select_related("author").prefetch_related("tags")
+        return BlogPost.objects.select_related("author", "poll").prefetch_related(
+            "tags", "poll__choices"
+        )
 
     def get_context_data(self, **kwargs):
         context = super().get_context_data(**kwargs)
diff --git a/apps/polls/__init__.py b/apps/polls/__init__.py
new file mode 100644
index 0000000..d24d3ba
--- /dev/null
+++ b/apps/polls/__init__.py
@@ -0,0 +1 @@
+# Tyro & Vixi's polls app!
diff --git a/apps/polls/admin.py b/apps/polls/admin.py
new file mode 100644
index 0000000..004bde2
--- /dev/null
+++ b/apps/polls/admin.py
@@ -0,0 +1,118 @@
+from django import forms
+from django.contrib import admin
+from django.utils.html import format_html
+
+from .models import Choice, Poll, Vote
+
+
+class ChoiceInline(admin.TabularInline):
+    model = Choice
+    extra = 3
+    fields = ["text", "order"]
+
+
+class PollAdminForm(forms.ModelForm):
+    class Meta:
+        model = Poll
+        fields = "__all__"
+        widgets = {
+            "description": forms.Textarea(
+                attrs={"rows": 8, "placeholder": "Markdown is fine here~"}
+            ),
+            "flair": forms.TextInput(
+                attrs={"placeholder": "Community, Site, Comics, Events..."}
+            ),
+        }
+
+
+@admin.register(Poll)
+class PollAdmin(admin.ModelAdmin):
+    form = PollAdminForm
+    list_display = [
+        "title",
+        "flair",
+        "choice_type",
+        "status",
+        "is_open_display",
+        "closes_at",
+        "vote_count",
+        "blog_link",
+    ]
+    list_filter = ["status", "choice_type", "flair"]
+    search_fields = ["title", "description", "flair"]
+    prepopulated_fields = {"slug": ("title",)}
+    readonly_fields = ["created_at", "updated_at", "description_html", "blog_post"]
+    inlines = [ChoiceInline]
+    autocomplete_fields = ["created_by"]
+
+    fieldsets = (
+        (
+            "Poll",
+            {
+                "fields": (
+                    "title",
+                    "slug",
+                    "flair",
+                    "description",
+                    "description_html",
+                    "choice_type",
+                    "max_choices",
+                )
+            },
+        ),
+        (
+            "Schedule",
+            {"fields": ("status", "opens_at", "closes_at")},
+        ),
+        (
+            "Discord votes",
+            {
+                "fields": ("discord_votes",),
+                "description": (
+                    "Paste counts after the poll closes. Keys can be choice labels "
+                    'or ids, e.g. {"Tacos": 12, "Sushi": 7} or {"1": 12, "2": 7}.'
+                ),
+            },
+        ),
+        (
+            "Blog",
+            {"fields": ("publish_to_blog", "blog_post")},
+        ),
+        (
+            "Meta",
+            {
+                "fields": ("created_by", "created_at", "updated_at"),
+                "classes": ("collapse",),
+            },
+        ),
+    )
+
+    def save_model(self, request, obj, form, change):
+        if not obj.created_by_id:
+            obj.created_by = request.user
+        super().save_model(request, obj, form, change)
+
+    @admin.display(boolean=True, description="Open now")
+    def is_open_display(self, obj):
+        return obj.is_open
+
+    @admin.display(description="Site votes")
+    def vote_count(self, obj):
+        return obj.votes.count()
+
+    @admin.display(description="Blog post")
+    def blog_link(self, obj):
+        if not obj.blog_post:
+            return "—"
+        url = obj.blog_post.get_absolute_url()
+        return format_html('<a href="{}">{}</a>', url, obj.blog_post.slug)
+
+
+@admin.register(Vote)
+class VoteAdmin(admin.ModelAdmin):
+    list_display = ["user", "poll", "choice", "created_at"]
+    list_filter = ["poll", "created_at"]
+    search_fields = ["user__username", "poll__title", "choice__text"]
+    autocomplete_fields = ["user", "poll"]
+    raw_id_fields = ["choice"]
+    readonly_fields = ["created_at", "updated_at"]
diff --git a/apps/polls/apps.py b/apps/polls/apps.py
new file mode 100644
index 0000000..4a07663
--- /dev/null
+++ b/apps/polls/apps.py
@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class PollsConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "apps.polls"
+    verbose_name = "Polls"
diff --git a/apps/polls/forms.py b/apps/polls/forms.py
new file mode 100644
index 0000000..bc9974c
--- /dev/null
+++ b/apps/polls/forms.py
@@ -0,0 +1,56 @@
+from django import forms
+
+from .models import Poll
+
+
+class VoteForm(forms.Form):
+    """Single or multi choice vote form, built from a poll's options."""
+
+    def __init__(self, poll, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.poll = poll
+        choices = [(c.pk, c.text) for c in poll.choices.all()]
+
+        if poll.choice_type == Poll.CHOICE_SINGLE:
+            self.fields["choice"] = forms.ChoiceField(
+                choices=choices,
+                widget=forms.RadioSelect,
+                required=True,
+                label="Your vote",
+            )
+        else:
+            self.fields["choices"] = forms.MultipleChoiceField(
+                choices=choices,
+                widget=forms.CheckboxSelectMultiple,
+                required=True,
+                label="Your votes",
+            )
+
+    def clean(self):
+        cleaned = super().clean()
+        poll = self.poll
+        valid_ids = {c.pk for c in poll.choices.all()}
+
+        if poll.choice_type == Poll.CHOICE_SINGLE:
+            raw = cleaned.get("choice")
+            if not raw:
+                raise forms.ValidationError("Pick one option.")
+            choice_id = int(raw)
+            if choice_id not in valid_ids:
+                raise forms.ValidationError("That option is not on this poll.")
+            cleaned["choice_ids"] = [choice_id]
+        else:
+            raw_list = cleaned.get("choices") or []
+            if not raw_list:
+                raise forms.ValidationError("Pick at least one option.")
+            choice_ids = [int(pk) for pk in raw_list]
+            if any(pk not in valid_ids for pk in choice_ids):
+                raise forms.ValidationError("One of those options is not on this poll.")
+            if poll.max_choices and len(choice_ids) > poll.max_choices:
+                raise forms.ValidationError(
+                    f"You can pick at most {poll.max_choices} option"
+                    f"{'s' if poll.max_choices != 1 else ''}."
+                )
+            cleaned["choice_ids"] = choice_ids
+
+        return cleaned
diff --git a/apps/polls/migrations/0001_initial.py b/apps/polls/migrations/0001_initial.py
new file mode 100644
index 0000000..9ac6d90
--- /dev/null
+++ b/apps/polls/migrations/0001_initial.py
@@ -0,0 +1,225 @@
+# Generated by Django 5.2.11 on 2026-08-19 15:26
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ("blog", "0003_comment"),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="Poll",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("title", models.CharField(max_length=200)),
+                ("slug", models.SlugField(blank=True, max_length=200, unique=True)),
+                (
+                    "description",
+                    models.TextField(
+                        blank=True,
+                        help_text="Markdown description shown with the poll.",
+                    ),
+                ),
+                ("description_html", models.TextField(blank=True)),
+                (
+                    "flair",
+                    models.CharField(
+                        blank=True,
+                        help_text="Short badge on the poll and blog preview (e.g. Community, Site, Comics).",
+                        max_length=40,
+                    ),
+                ),
+                (
+                    "choice_type",
+                    models.CharField(
+                        choices=[
+                            ("single", "Single choice"),
+                            ("multi", "Multi choice"),
+                        ],
+                        default="single",
+                        help_text="Single choice = pick one. Multi choice = pick several.",
+                        max_length=10,
+                    ),
+                ),
+                (
+                    "max_choices",
+                    models.PositiveIntegerField(
+                        default=0,
+                        help_text="For multi choice: max options a voter can pick. 0 = no limit.",
+                    ),
+                ),
+                (
+                    "status",
+                    models.CharField(
+                        choices=[
+                            ("draft", "Draft"),
+                            ("open", "Open"),
+                            ("closed", "Closed"),
+                        ],
+                        default="draft",
+                        max_length=10,
+                    ),
+                ),
+                (
+                    "opens_at",
+                    models.DateTimeField(
+                        blank=True,
+                        help_text="Optional. If set, voting starts at this time.",
+                        null=True,
+                    ),
+                ),
+                (
+                    "closes_at",
+                    models.DateTimeField(
+                        blank=True,
+                        help_text="Optional. If set, voting ends at this time even if status is still Open.",
+                        null=True,
+                    ),
+                ),
+                (
+                    "discord_votes",
+                    models.JSONField(
+                        blank=True,
+                        default=dict,
+                        help_text='After the poll closes, paste Discord vote counts keyed by choice id or label. Example: {"Pineapple": 14, "No pineapple": 31} or {"1": 14, "2": 31}',
+                    ),
+                ),
+                (
+                    "publish_to_blog",
+                    models.BooleanField(
+                        default=True,
+                        help_text="Create/update a blog post when this poll is opened.",
+                    ),
+                ),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                (
+                    "blog_post",
+                    models.OneToOneField(
+                        blank=True,
+                        help_text="Linked blog post so this poll shows up in the blog / homepage feed.",
+                        null=True,
+                        on_delete=django.db.models.deletion.SET_NULL,
+                        related_name="poll",
+                        to="blog.blogpost",
+                    ),
+                ),
+                (
+                    "created_by",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.SET_NULL,
+                        related_name="polls_created",
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+            ],
+            options={
+                "ordering": ["-created_at"],
+            },
+        ),
+        migrations.CreateModel(
+            name="Choice",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("text", models.CharField(max_length=200)),
+                ("order", models.PositiveIntegerField(default=0)),
+                (
+                    "poll",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="choices",
+                        to="polls.poll",
+                    ),
+                ),
+            ],
+            options={
+                "ordering": ["order", "pk"],
+            },
+        ),
+        migrations.CreateModel(
+            name="Vote",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                (
+                    "choice",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="votes",
+                        to="polls.choice",
+                    ),
+                ),
+                (
+                    "poll",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="votes",
+                        to="polls.poll",
+                    ),
+                ),
+                (
+                    "user",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="poll_votes",
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+            ],
+        ),
+        migrations.AddIndex(
+            model_name="poll",
+            index=models.Index(
+                fields=["status", "closes_at"], name="polls_poll_status_ce9694_idx"
+            ),
+        ),
+        migrations.AddIndex(
+            model_name="poll",
+            index=models.Index(fields=["slug"], name="polls_poll_slug_3e2bd9_idx"),
+        ),
+        migrations.AddIndex(
+            model_name="vote",
+            index=models.Index(
+                fields=["poll", "user"], name="polls_vote_poll_id_cfe401_idx"
+            ),
+        ),
+        migrations.AlterUniqueTogether(
+            name="vote",
+            unique_together={("poll", "user", "choice")},
+        ),
+    ]
diff --git a/apps/polls/migrations/__init__.py b/apps/polls/migrations/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/apps/polls/models.py b/apps/polls/models.py
new file mode 100644
index 0000000..45c914b
--- /dev/null
+++ b/apps/polls/models.py
@@ -0,0 +1,361 @@
+from django.conf import settings
+from django.core.exceptions import ValidationError
+from django.db import models
+from django.db.models import Count, Q
+from django.urls import reverse
+from django.utils import timezone
+from django.utils.text import slugify
+import markdown
+
+from apps.blog.models import BlogPost, Tag
+
+
+class PollQuerySet(models.QuerySet):
+    def visible(self):
+        return self.exclude(status=Poll.STATUS_DRAFT)
+
+    def currently_open(self):
+        now = timezone.now()
+        return self.filter(status=Poll.STATUS_OPEN).filter(
+            Q(opens_at__isnull=True) | Q(opens_at__lte=now),
+            Q(closes_at__isnull=True) | Q(closes_at__gt=now),
+        )
+
+    def ended(self):
+        now = timezone.now()
+        return self.visible().filter(
+            Q(status=Poll.STATUS_CLOSED)
+            | Q(status=Poll.STATUS_OPEN, closes_at__isnull=False, closes_at__lte=now)
+        )
+
+
+class Poll(models.Model):
+    """A site poll, optionally mirrored as a blog post on the front page."""
+
+    STATUS_DRAFT = "draft"
+    STATUS_OPEN = "open"
+    STATUS_CLOSED = "closed"
+    STATUS_CHOICES = [
+        (STATUS_DRAFT, "Draft"),
+        (STATUS_OPEN, "Open"),
+        (STATUS_CLOSED, "Closed"),
+    ]
+
+    CHOICE_SINGLE = "single"
+    CHOICE_MULTI = "multi"
+    CHOICE_TYPE_CHOICES = [
+        (CHOICE_SINGLE, "Single choice"),
+        (CHOICE_MULTI, "Multi choice"),
+    ]
+
+    title = models.CharField(max_length=200)
+    slug = models.SlugField(max_length=200, unique=True, blank=True)
+    description = models.TextField(
+        blank=True, help_text="Markdown description shown with the poll."
+    )
+    description_html = models.TextField(blank=True)
+    flair = models.CharField(
+        max_length=40,
+        blank=True,
+        help_text="Short badge on the poll and blog preview (e.g. Community, Site, Comics).",
+    )
+
+    choice_type = models.CharField(
+        max_length=10,
+        choices=CHOICE_TYPE_CHOICES,
+        default=CHOICE_SINGLE,
+        help_text="Single choice = pick one. Multi choice = pick several.",
+    )
+    max_choices = models.PositiveIntegerField(
+        default=0,
+        help_text="For multi choice: max options a voter can pick. 0 = no limit.",
+    )
+
+    status = models.CharField(
+        max_length=10, choices=STATUS_CHOICES, default=STATUS_DRAFT
+    )
+    opens_at = models.DateTimeField(
+        null=True,
+        blank=True,
+        help_text="Optional. If set, voting starts at this time.",
+    )
+    closes_at = models.DateTimeField(
+        null=True,
+        blank=True,
+        help_text="Optional. If set, voting ends at this time even if status is still Open.",
+    )
+
+    discord_votes = models.JSONField(
+        default=dict,
+        blank=True,
+        help_text=(
+            "After the poll closes, paste Discord vote counts keyed by choice id "
+            'or label. Example: {"Pineapple": 14, "No pineapple": 31} or {"1": 14, "2": 31}'
+        ),
+    )
+
+    blog_post = models.OneToOneField(
+        BlogPost,
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="poll",
+        help_text="Linked blog post so this poll shows up in the blog / homepage feed.",
+    )
+    publish_to_blog = models.BooleanField(
+        default=True,
+        help_text="Create/update a blog post when this poll is opened.",
+    )
+
+    created_by = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="polls_created",
+    )
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    objects = PollQuerySet.as_manager()
+
+    class Meta:
+        ordering = ["-created_at"]
+        indexes = [
+            models.Index(fields=["status", "closes_at"]),
+            models.Index(fields=["slug"]),
+        ]
+
+    def __str__(self):
+        return self.title
+
+    def save(self, *args, **kwargs):
+        if not self.slug:
+            self.slug = slugify(self.title)
+
+        if self.description:
+            self.description_html = markdown.markdown(
+                self.description, extensions=["extra", "codehilite", "toc"]
+            )
+        else:
+            self.description_html = ""
+
+        super().save(*args, **kwargs)
+
+        if self.publish_to_blog and self.status != self.STATUS_DRAFT:
+            self.sync_blog_post()
+
+    def clean(self):
+        super().clean()
+        if self.max_choices and self.choice_type != self.CHOICE_MULTI:
+            raise ValidationError(
+                {"max_choices": "Max choices only applies to multi choice polls."}
+            )
+        self._validate_discord_votes(self.discord_votes)
+
+    def _validate_discord_votes(self, value):
+        if not value:
+            return {}
+        if not isinstance(value, dict):
+            raise ValidationError(
+                {
+                    "discord_votes": "Discord votes must be a JSON object of label/id → count."
+                }
+            )
+        cleaned = {}
+        for key, raw in value.items():
+            try:
+                count = int(raw)
+            except (TypeError, ValueError):
+                raise ValidationError(
+                    {"discord_votes": f'Count for "{key}" must be a whole number.'}
+                )
+            if count < 0:
+                raise ValidationError(
+                    {"discord_votes": f'Count for "{key}" cannot be negative.'}
+                )
+            cleaned[str(key)] = count
+        return cleaned
+
+    def get_absolute_url(self):
+        return reverse("polls:detail", kwargs={"slug": self.slug})
+
+    @property
+    def is_open(self):
+        if self.status != self.STATUS_OPEN:
+            return False
+        now = timezone.now()
+        if self.opens_at and now < self.opens_at:
+            return False
+        if self.closes_at and now >= self.closes_at:
+            return False
+        return True
+
+    @property
+    def has_ended(self):
+        if self.status == self.STATUS_CLOSED:
+            return True
+        if self.status == self.STATUS_OPEN and self.closes_at:
+            return timezone.now() >= self.closes_at
+        return False
+
+    @property
+    def is_visible(self):
+        return self.status != self.STATUS_DRAFT
+
+    def discord_votes_for(self, choice):
+        """Resolve Discord votes for a choice by id or label (case-insensitive)."""
+        data = self.discord_votes or {}
+        if not data:
+            return 0
+
+        pk_key = str(choice.pk)
+        if pk_key in data:
+            try:
+                return int(data[pk_key] or 0)
+            except (TypeError, ValueError):
+                return 0
+        if choice.pk in data:
+            try:
+                return int(data[choice.pk] or 0)
+            except (TypeError, ValueError):
+                return 0
+
+        target = choice.text.strip().lower()
+        for key, raw in data.items():
+            if str(key).strip().lower() == target:
+                try:
+                    return int(raw or 0)
+                except (TypeError, ValueError):
+                    return 0
+        return 0
+
+    def results(self):
+        """Site votes + Discord votes (Discord only counted once the poll has ended)."""
+        include_discord = self.has_ended
+        choices = list(
+            self.choices.annotate(site_count=Count("votes")).order_by("order", "pk")
+        )
+        rows = []
+        for choice in choices:
+            site_votes = choice.site_count
+            discord = self.discord_votes_for(choice) if include_discord else 0
+            rows.append(
+                {
+                    "choice": choice,
+                    "site_votes": site_votes,
+                    "discord_votes": discord,
+                    "total": site_votes + discord,
+                }
+            )
+        grand_total = sum(row["total"] for row in rows)
+        divisor = grand_total or 1
+        for row in rows:
+            row["percent"] = round(100.0 * row["total"] / divisor, 1)
+        return rows
+
+    def voter_count(self):
+        return self.votes.values("user").distinct().count()
+
+    def user_choice_ids(self, user):
+        if not user or not user.is_authenticated:
+            return []
+        return list(self.votes.filter(user=user).values_list("choice_id", flat=True))
+
+    def sync_blog_post(self):
+        """Create or update the linked blog post so the poll appears in the feed."""
+        from django.contrib.auth import get_user_model
+
+        User = get_user_model()
+        author = self.created_by
+        if not author:
+            author = (
+                User.objects.filter(is_superuser=True).first() or User.objects.first()
+            )
+        if not author:
+            return None
+
+        content = self.description or f"Vote on **{self.title}**!"
+        slug = self._blog_slug()
+
+        if self.blog_post:
+            post = self.blog_post
+            post.title = self.title
+            post.content = content
+            if post.status != "published":
+                post.status = "published"
+            post.save()
+        else:
+            post = BlogPost.objects.create(
+                title=self.title,
+                slug=slug,
+                author=author,
+                content=content,
+                status="published",
+                meta_description=self._excerpt_plain()[:300],
+            )
+            Poll.objects.filter(pk=self.pk).update(blog_post=post)
+            self.blog_post = post
+
+        self._sync_blog_tags(post)
+        return post
+
+    def _blog_slug(self):
+        slug = self.slug or slugify(self.title)
+        qs = BlogPost.objects.filter(slug=slug)
+        if self.blog_post_id:
+            qs = qs.exclude(pk=self.blog_post_id)
+        if qs.exists():
+            return f"poll-{slug}"
+        return slug
+
+    def _excerpt_plain(self):
+        if self.description:
+            html = markdown.markdown(self.description, extensions=["extra"])
+            from django.utils.html import strip_tags
+
+            return strip_tags(html).strip()
+        return self.title
+
+    def _sync_blog_tags(self, post):
+        names = ["poll"]
+        if self.flair:
+            names.append(self.flair)
+        for name in names:
+            tag, _created = Tag.objects.get_or_create(
+                name=name, defaults={"slug": slugify(name)}
+            )
+            post.tags.add(tag)
+
+
+class Choice(models.Model):
+    poll = models.ForeignKey(Poll, on_delete=models.CASCADE, related_name="choices")
+    text = models.CharField(max_length=200)
+    order = models.PositiveIntegerField(default=0)
+
+    class Meta:
+        ordering = ["order", "pk"]
+
+    def __str__(self):
+        return self.text
+
+
+class Vote(models.Model):
+    poll = models.ForeignKey(Poll, on_delete=models.CASCADE, related_name="votes")
+    choice = models.ForeignKey(Choice, on_delete=models.CASCADE, related_name="votes")
+    user = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.CASCADE,
+        related_name="poll_votes",
+    )
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    class Meta:
+        unique_together = [["poll", "user", "choice"]]
+        indexes = [
+            models.Index(fields=["poll", "user"]),
+        ]
+
+    def __str__(self):
+        return f"{self.user} → {self.choice} ({self.poll})"
diff --git a/apps/polls/static/polls/css/polls.css b/apps/polls/static/polls/css/polls.css
new file mode 100644
index 0000000..f0f0b0f
--- /dev/null
+++ b/apps/polls/static/polls/css/polls.css
@@ -0,0 +1,231 @@
+/* Polls — matches the site's tile / retro look */
+
+.polls-page {
+    max-width: none;
+}
+
+.polls-header {
+    margin-bottom: 1.5em;
+}
+
+.polls-header h1 {
+    margin: 0.25em 0 0.5em 0;
+}
+
+.polls-list {
+    display: flex;
+    flex-direction: column;
+    gap: 1.5em;
+}
+
+.poll-card {
+    background: var(--tile-background);
+    border: 1px solid var(--text-color);
+    border-radius: 8px;
+    padding: 1.25em;
+}
+
+.poll-card h2 {
+    margin: 0 0 0.5em 0;
+}
+
+.poll-description {
+    margin-bottom: 1em;
+    line-height: 1.5;
+}
+
+.poll-description p:last-child {
+    margin-bottom: 0;
+}
+
+.poll-discuss {
+    margin: 1em 0 0 0;
+    font-size: 0.9em;
+}
+
+.polls-empty,
+.poll-empty {
+    opacity: 0.8;
+}
+
+.polls-pagination {
+    display: flex;
+    gap: 1em;
+    justify-content: center;
+    margin-top: 1.5em;
+}
+
+.post-poll {
+    margin: 1.5em 0 2em 0;
+    padding: 1em;
+    background: var(--tile-background);
+    border: 1px solid var(--text-color);
+    border-radius: 8px;
+}
+
+.post-poll h2 {
+    margin: 0 0 0.5em 0;
+    font-size: 1.25rem;
+}
+
+.poll-widget-header {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.5em;
+    align-items: center;
+    margin-bottom: 0.75em;
+    font-size: 0.875rem;
+}
+
+.poll-flair {
+    display: inline-block;
+    padding: 0.2em 0.6em;
+    background: var(--link-default);
+    color: var(--invert-text-color, #031b20);
+    border-radius: 4px;
+    font-size: 0.75rem;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.03em;
+}
+
+.poll-type,
+.poll-closes,
+.poll-closed {
+    opacity: 0.8;
+}
+
+.poll-closed {
+    font-weight: 600;
+}
+
+.poll-results {
+    display: flex;
+    flex-direction: column;
+    gap: 0.6em;
+    margin-bottom: 1em;
+}
+
+.poll-result-row {
+    display: grid;
+    grid-template-columns: 1fr auto;
+    gap: 0.25em 0.75em;
+}
+
+.poll-result-label {
+    grid-column: 1 / -1;
+    display: flex;
+    justify-content: space-between;
+    gap: 0.75em;
+}
+
+.poll-result-breakdown {
+    font-size: 0.8em;
+    opacity: 0.75;
+    font-weight: normal;
+}
+
+.poll-bar-track {
+    grid-column: 1;
+    height: 0.75em;
+    background: var(--sidebar-bg, rgba(127, 127, 127, 0.2));
+    border: 1px solid var(--text-color);
+    border-radius: 4px;
+    overflow: hidden;
+}
+
+.poll-bar-fill {
+    height: 100%;
+    background: var(--link-default);
+    min-width: 0;
+}
+
+.poll-result-percent {
+    grid-column: 2;
+    font-size: 0.85em;
+    opacity: 0.85;
+    align-self: center;
+}
+
+.poll-voter-count {
+    margin: 0.25em 0 0 0;
+    font-size: 0.85em;
+    opacity: 0.75;
+}
+
+.poll-vote-form fieldset {
+    border: 1px solid var(--text-color);
+    border-radius: 6px;
+    padding: 0.75em 1em;
+    margin: 0 0 0.75em 0;
+}
+
+.poll-legend {
+    font-weight: 600;
+    padding: 0 0.35em;
+}
+
+.poll-vote-form ul {
+    list-style: none;
+    padding: 0;
+    margin: 0.25em 0 0 0;
+}
+
+.poll-vote-form li {
+    margin: 0.35em 0;
+}
+
+.poll-vote-form label {
+    display: flex;
+    gap: 0.5em;
+    align-items: flex-start;
+    cursor: pointer;
+}
+
+.poll-vote-btn {
+    display: inline-block;
+    padding: 0.5em 1em;
+    background: var(--link-default);
+    color: var(--invert-text-color, #031b20);
+    border: 1px solid var(--link-default);
+    border-radius: 4px;
+    cursor: pointer;
+    font-size: 1rem;
+}
+
+.poll-vote-btn:hover {
+    background: var(--link-hover, var(--link-default));
+}
+
+.poll-choice-preview {
+    list-style: none;
+    padding: 0;
+    margin: 0 0 0.75em 0;
+}
+
+.poll-choice-preview li {
+    padding: 0.35em 0;
+    border-bottom: 1px solid var(--text-color);
+    opacity: 0.85;
+}
+
+.poll-choice-preview li:last-child {
+    border-bottom: none;
+}
+
+.polls-sidebar ul {
+    list-style: none;
+    padding: 0;
+    margin: 0 0 1em 0;
+}
+
+.polls-sidebar li {
+    margin: 0.35em 0;
+}
+
+@media (max-width: 768px) {
+    .poll-result-label {
+        flex-direction: column;
+        gap: 0.15em;
+    }
+}
diff --git a/apps/polls/templates/polls/includes/poll_widget.html b/apps/polls/templates/polls/includes/poll_widget.html
new file mode 100644
index 0000000..61c32eb
--- /dev/null
+++ b/apps/polls/templates/polls/includes/poll_widget.html
@@ -0,0 +1,74 @@
+{% load static %}
+
+<div class="poll-widget{% if compact %} poll-widget-compact{% endif %}">
+    <div class="poll-widget-header">
+        {% if poll.flair %}
+        <span class="poll-flair">{{ poll.flair }}</span>
+        {% endif %}
+        <span class="poll-type">
+            {% if poll.choice_type == poll.CHOICE_MULTI %}
+            Multi choice{% if poll.max_choices %} (up to {{ poll.max_choices }}){% endif %}
+            {% else %}
+            Single choice
+            {% endif %}
+        </span>
+        {% if poll.is_open and poll.closes_at %}
+        <span class="poll-closes">Closes {{ poll.closes_at|date:"M j, Y g:i A" }}</span>
+        {% elif poll.has_ended %}
+        <span class="poll-closed">Closed</span>
+        {% endif %}
+    </div>
+
+    {% if show_results %}
+    <div class="poll-results" role="list">
+        {% for row in results %}
+        <div class="poll-result-row" role="listitem">
+            <div class="poll-result-label">
+                <span>{{ row.choice.text }}</span>
+                <span class="poll-result-count">{{ row.total }}
+                    {% if include_discord and row.discord_votes %}
+                    <span class="poll-result-breakdown">({{ row.site_votes }} site + {{ row.discord_votes }} Discord)</span>
+                    {% endif %}
+                </span>
+            </div>
+            <div class="poll-bar-track" aria-hidden="true">
+                <div class="poll-bar-fill" style="width: {{ row.percent }}%"></div>
+            </div>
+            <div class="poll-result-percent">{{ row.percent }}%</div>
+        </div>
+        {% empty %}
+        <p class="poll-empty">No votes yet.</p>
+        {% endfor %}
+        {% if voter_count %}
+        <p class="poll-voter-count">{{ voter_count }} site voter{{ voter_count|pluralize }}</p>
+        {% endif %}
+    </div>
+    {% endif %}
+
+    {% if poll.is_open %}
+        {% if user.is_authenticated %}
+        <form method="post" action="{% url 'polls:vote' poll.slug %}" class="poll-vote-form">
+            {% csrf_token %}
+            <input type="hidden" name="next" value="{{ request.path }}">
+            <fieldset>
+                <legend class="poll-legend">{% if selected_ids %}Change your vote{% else %}Cast your vote{% endif %}</legend>
+                {{ form }}
+            </fieldset>
+            <button type="submit" class="poll-vote-btn">
+                {% if selected_ids %}Update vote{% else %}Vote{% endif %}
+            </button>
+        </form>
+        {% else %}
+        <ul class="poll-choice-preview">
+            {% for choice in choices %}
+            <li>{{ choice.text }}</li>
+            {% endfor %}
+        </ul>
+        <p class="poll-login-prompt">
+            <a href="{% url 'login' %}?next={{ request.path }}">Log in</a> to vote on this poll.
+        </p>
+        {% endif %}
+    {% elif not show_results %}
+        <p class="poll-empty">This poll is not open.</p>
+    {% endif %}
+</div>
diff --git a/apps/polls/templates/polls/poll_archive.html b/apps/polls/templates/polls/poll_archive.html
new file mode 100644
index 0000000..36bee8e
--- /dev/null
+++ b/apps/polls/templates/polls/poll_archive.html
@@ -0,0 +1,61 @@
+{% extends "base.html" %}
+{% load static %}
+{% load poll_tags %}
+
+{% block title %}Poll archive - Snowsune.net{% endblock %}
+
+{% block extra_css %}
+<link rel="stylesheet" href="{% static 'polls/css/polls.css' %}">
+{% endblock %}
+
+{% block content %}
+<div class="polls-page">
+    <header class="polls-header">
+        <h1>Poll archive</h1>
+        <p>Every poll that's already closed.
+            <a href="{% url 'polls:list' %}">Back to open polls</a>
+        </p>
+    </header>
+
+    {% if polls %}
+    <div class="polls-list">
+        {% for poll in polls %}
+        <article class="poll-card">
+            <h2><a href="{{ poll.get_absolute_url }}">{{ poll.title }}</a></h2>
+            {% if poll.flair %}
+            <p class="poll-meta"><span class="poll-flair">{{ poll.flair }}</span>
+                {% if poll.closes_at %}Ended {{ poll.closes_at|date:"F j, Y" }}{% endif %}
+            </p>
+            {% endif %}
+            {% poll_widget poll compact=True %}
+        </article>
+        {% endfor %}
+    </div>
+
+    {% if is_paginated %}
+    <div class="polls-pagination">
+        {% if page_obj.has_previous %}
+        <a href="?page={{ page_obj.previous_page_number }}">← Newer</a>
+        {% endif %}
+        <span>Page {{ page_obj.number }} of {{ page_obj.paginator.num_pages }}</span>
+        {% if page_obj.has_next %}
+        <a href="?page={{ page_obj.next_page_number }}">Older →</a>
+        {% endif %}
+    </div>
+    {% endif %}
+    {% else %}
+    <p class="polls-empty">No closed polls yet.</p>
+    {% endif %}
+</div>
+{% endblock %}
+
+{% block sidebar %}
+<div class="polls-sidebar">
+    <h2>Polls</h2>
+    <ul>
+        <li><a href="{% url 'polls:list' %}">Open polls</a></li>
+        <li><a href="{% url 'polls:archive' %}">Archive</a></li>
+        <li><a href="{% url 'blog:blog_list' %}?tag=poll">Poll blog posts</a></li>
+    </ul>
+</div>
+{% endblock %}
diff --git a/apps/polls/templates/polls/poll_detail.html b/apps/polls/templates/polls/poll_detail.html
new file mode 100644
index 0000000..b5cbb98
--- /dev/null
+++ b/apps/polls/templates/polls/poll_detail.html
@@ -0,0 +1,56 @@
+{% extends "base.html" %}
+{% load static %}
+{% load poll_tags %}
+
+{% block title %}{{ poll.title }} - Polls - Snowsune.net{% endblock %}
+{% block meta_description %}{% if poll.flair %}{{ poll.flair }} poll: {% endif %}{{ poll.title }}{% endblock %}
+
+{% block extra_css %}
+<link rel="stylesheet" href="{% static 'polls/css/polls.css' %}">
+{% endblock %}
+
+{% block content %}
+<div class="polls-page">
+    <article class="poll-card poll-detail">
+        <header class="polls-header">
+            {% if poll.flair %}
+            <span class="poll-flair">{{ poll.flair }}</span>
+            {% endif %}
+            <h1>{{ poll.title }}</h1>
+            {% if poll.description_html %}
+            <div class="poll-description markdown-content">
+                {{ poll.description_html|safe }}
+            </div>
+            {% endif %}
+        </header>
+
+        {% poll_widget poll %}
+
+        <p class="poll-discuss">
+            {% if poll.blog_post %}
+            <a href="{{ poll.blog_post.get_absolute_url }}">Discuss on the blog →</a>
+            {% endif %}
+            <a href="{% url 'polls:list' %}">All open polls</a>
+            ·
+            <a href="{% url 'polls:archive' %}">Archive</a>
+        </p>
+    </article>
+</div>
+{% endblock %}
+
+{% block sidebar %}
+<div class="polls-sidebar">
+    <h2>Polls</h2>
+    <ul>
+        <li><a href="{% url 'polls:list' %}">Open polls</a></li>
+        <li><a href="{% url 'polls:archive' %}">Archive</a></li>
+        <li><a href="{% url 'blog:blog_list' %}?tag=poll">Poll blog posts</a></li>
+    </ul>
+    {% if user.is_staff %}
+    <h3>Staff</h3>
+    <ul>
+        <li><a href="{% url 'admin:polls_poll_change' poll.pk %}">Edit in admin</a></li>
+    </ul>
+    {% endif %}
+</div>
+{% endblock %}
diff --git a/apps/polls/templates/polls/poll_list.html b/apps/polls/templates/polls/poll_list.html
new file mode 100644
index 0000000..0a2714b
--- /dev/null
+++ b/apps/polls/templates/polls/poll_list.html
@@ -0,0 +1,56 @@
+{% extends "base.html" %}
+{% load static %}
+{% load poll_tags %}
+
+{% block title %}Polls - Snowsune.net{% endblock %}
+
+{% block extra_css %}
+<link rel="stylesheet" href="{% static 'polls/css/polls.css' %}">
+{% endblock %}
+
+{% block content %}
+<div class="polls-page">
+    <header class="polls-header">
+        <h1>Polls</h1>
+        <p>Vote on whatever Vixi's asking this week. Closed polls live in the
+            <a href="{% url 'polls:archive' %}">archive</a>{% if ended_count %} ({{ ended_count }}){% endif %}.
+        </p>
+    </header>
+
+    {% if polls %}
+    <div class="polls-list">
+        {% for poll in polls %}
+        <article class="poll-card">
+            <h2><a href="{{ poll.get_absolute_url }}">{{ poll.title }}</a></h2>
+            {% if poll.description_html %}
+            <div class="poll-description markdown-content">
+                {{ poll.description_html|safe }}
+            </div>
+            {% endif %}
+            {% poll_widget poll %}
+            {% if poll.blog_post %}
+            <p class="poll-discuss">
+                <a href="{{ poll.blog_post.get_absolute_url }}">Discuss on the blog →</a>
+            </p>
+            {% endif %}
+        </article>
+        {% endfor %}
+    </div>
+    {% else %}
+    <p class="polls-empty">No open polls right now. Check the
+        <a href="{% url 'polls:archive' %}">archive</a> for past ones.
+    </p>
+    {% endif %}
+</div>
+{% endblock %}
+
+{% block sidebar %}
+<div class="polls-sidebar">
+    <h2>Polls</h2>
+    <ul>
+        <li><a href="{% url 'polls:list' %}">Open polls</a></li>
+        <li><a href="{% url 'polls:archive' %}">Archive</a></li>
+        <li><a href="{% url 'blog:blog_list' %}?tag=poll">Poll blog posts</a></li>
+    </ul>
+</div>
+{% endblock %}
diff --git a/apps/polls/templatetags/__init__.py b/apps/polls/templatetags/__init__.py
new file mode 100644
index 0000000..b6a7863
--- /dev/null
+++ b/apps/polls/templatetags/__init__.py
@@ -0,0 +1 @@
+# Poll template tags
diff --git a/apps/polls/templatetags/poll_tags.py b/apps/polls/templatetags/poll_tags.py
new file mode 100644
index 0000000..cfd44b9
--- /dev/null
+++ b/apps/polls/templatetags/poll_tags.py
@@ -0,0 +1,40 @@
+from django import template
+
+from ..forms import VoteForm
+
+register = template.Library()
+
+
+@register.inclusion_tag("polls/includes/poll_widget.html", takes_context=True)
+def poll_widget(context, poll, compact=False):
+    """Render a vote form and/or results for a poll."""
+    request = context.get("request")
+    user = getattr(request, "user", None)
+    selected_ids = poll.user_choice_ids(user) if poll else []
+    show_results = bool(poll) and (
+        poll.has_ended
+        or bool(selected_ids)
+        or (user and user.is_authenticated and user.is_staff)
+    )
+    form = None
+    if poll and poll.is_open:
+        initial = {}
+        if poll.choice_type == poll.CHOICE_SINGLE and selected_ids:
+            initial["choice"] = selected_ids[0]
+        elif selected_ids:
+            initial["choices"] = [str(pk) for pk in selected_ids]
+        form = VoteForm(poll, initial=initial)
+
+    return {
+        "poll": poll,
+        "request": request,
+        "user": user,
+        "form": form,
+        "choices": list(poll.choices.all()) if poll else [],
+        "selected_ids": selected_ids,
+        "show_results": show_results,
+        "results": poll.results() if poll and show_results else [],
+        "compact": compact,
+        "voter_count": poll.voter_count() if poll else 0,
+        "include_discord": bool(poll and poll.has_ended),
+    }
diff --git a/apps/polls/tests.py b/apps/polls/tests.py
new file mode 100644
index 0000000..03f6cb0
--- /dev/null
+++ b/apps/polls/tests.py
@@ -0,0 +1,200 @@
+from datetime import timedelta
+
+from django.contrib.auth import get_user_model
+from django.core.exceptions import ValidationError
+from django.test import TestCase
+from django.urls import reverse
+from django.utils import timezone
+
+from .models import Choice, Poll, Vote
+
+User = get_user_model()
+
+
+class PollTestMixin:
+    def make_user(self, username="voter", **kwargs):
+        return User.objects.create_user(
+            username=username,
+            email=f"{username}@example.com",
+            password="testpass123",
+            **kwargs,
+        )
+
+    def make_poll(
+        self, *, status=Poll.STATUS_OPEN, choice_type=Poll.CHOICE_SINGLE, **kwargs
+    ):
+        author = kwargs.pop("created_by", None)
+        if author is None:
+            author = User.objects.filter(username="vixi").first()
+            if author is None:
+                author = self.make_user("vixi", is_staff=True)
+        poll = Poll.objects.create(
+            title=kwargs.pop("title", "Pizza toppings"),
+            slug=kwargs.pop("slug", "pizza-toppings"),
+            description=kwargs.pop("description", "Pick your **favorite**."),
+            flair=kwargs.pop("flair", "Community"),
+            choice_type=choice_type,
+            status=status,
+            created_by=author,
+            **kwargs,
+        )
+        if not poll.choices.exists():
+            Choice.objects.create(poll=poll, text="Pineapple", order=0)
+            Choice.objects.create(poll=poll, text="No pineapple", order=1)
+        return Poll.objects.get(pk=poll.pk)
+
+
+class PollModelTests(PollTestMixin, TestCase):
+    def test_markdown_description(self):
+        poll = self.make_poll()
+        self.assertIn("<strong>favorite</strong>", poll.description_html)
+
+    def test_open_poll_creates_blog_post(self):
+        poll = self.make_poll()
+        self.assertIsNotNone(poll.blog_post)
+        self.assertEqual(poll.blog_post.status, "published")
+        self.assertEqual(poll.blog_post.title, poll.title)
+        tag_names = set(poll.blog_post.tags.values_list("name", flat=True))
+        self.assertIn("poll", tag_names)
+        self.assertIn("Community", tag_names)
+
+    def test_draft_poll_skips_blog_post(self):
+        poll = self.make_poll(
+            status=Poll.STATUS_DRAFT, slug="draft-poll", title="Draft"
+        )
+        self.assertIsNone(poll.blog_post)
+
+    def test_closes_at_ends_voting(self):
+        poll = self.make_poll(closes_at=timezone.now() - timedelta(minutes=1))
+        self.assertFalse(poll.is_open)
+        self.assertTrue(poll.has_ended)
+
+    def test_discord_votes_by_label_and_id(self):
+        poll = self.make_poll(status=Poll.STATUS_CLOSED)
+        pineapple = poll.choices.get(text="Pineapple")
+        other = poll.choices.get(text="No pineapple")
+
+        poll.discord_votes = {"Pineapple": 10, str(other.pk): 3}
+        poll.save()
+
+        rows = {row["choice"].text: row for row in poll.results()}
+        self.assertEqual(rows["Pineapple"]["discord_votes"], 10)
+        self.assertEqual(rows["No pineapple"]["discord_votes"], 3)
+        self.assertEqual(rows["Pineapple"]["total"], 10)
+
+    def test_discord_votes_ignored_while_open(self):
+        poll = self.make_poll(discord_votes={"Pineapple": 99})
+        rows = {row["choice"].text: row for row in poll.results()}
+        self.assertEqual(rows["Pineapple"]["discord_votes"], 0)
+        self.assertEqual(rows["Pineapple"]["total"], 0)
+
+    def test_invalid_discord_votes_json(self):
+        poll = self.make_poll()
+        poll.discord_votes = ["not", "an", "object"]
+        with self.assertRaises(ValidationError):
+            poll.full_clean()
+
+
+class PollVoteTests(PollTestMixin, TestCase):
+    def setUp(self):
+        self.user = self.make_user()
+        self.poll = self.make_poll()
+        self.pineapple = self.poll.choices.get(text="Pineapple")
+        self.other = self.poll.choices.get(text="No pineapple")
+
+    def test_login_required_to_vote(self):
+        url = reverse("polls:vote", kwargs={"slug": self.poll.slug})
+        response = self.client.post(url, {"choice": self.pineapple.pk})
+        self.assertEqual(response.status_code, 302)
+        self.assertIn("login", response.url)
+        self.assertEqual(Vote.objects.count(), 0)
+
+    def test_single_choice_vote(self):
+        self.client.login(username="voter", password="testpass123")
+        url = reverse("polls:vote", kwargs={"slug": self.poll.slug})
+        response = self.client.post(url, {"choice": self.pineapple.pk})
+        self.assertEqual(response.status_code, 302)
+        self.assertEqual(Vote.objects.filter(user=self.user).count(), 1)
+        self.assertEqual(Vote.objects.get().choice, self.pineapple)
+
+    def test_changing_single_vote(self):
+        self.client.login(username="voter", password="testpass123")
+        url = reverse("polls:vote", kwargs={"slug": self.poll.slug})
+        self.client.post(url, {"choice": self.pineapple.pk})
+        self.client.post(url, {"choice": self.other.pk})
+        self.assertEqual(Vote.objects.filter(user=self.user).count(), 1)
+        self.assertEqual(Vote.objects.get().choice, self.other)
+
+    def test_multi_choice_vote(self):
+        poll = self.make_poll(
+            title="Snacks",
+            slug="snacks",
+            choice_type=Poll.CHOICE_MULTI,
+        )
+        a, b = poll.choices.all()
+        self.client.login(username="voter", password="testpass123")
+        url = reverse("polls:vote", kwargs={"slug": poll.slug})
+        self.client.post(url, {"choices": [a.pk, b.pk]})
+        self.assertEqual(Vote.objects.filter(user=self.user, poll=poll).count(), 2)
+
+    def test_multi_choice_respects_max(self):
+        poll = self.make_poll(
+            title="Pick one snack",
+            slug="one-snack",
+            choice_type=Poll.CHOICE_MULTI,
+            max_choices=1,
+        )
+        a, b = poll.choices.all()
+        self.client.login(username="voter", password="testpass123")
+        url = reverse("polls:vote", kwargs={"slug": poll.slug})
+        self.client.post(url, {"choices": [a.pk, b.pk]})
+        self.assertEqual(Vote.objects.filter(poll=poll).count(), 0)
+
+    def test_cannot_vote_when_closed(self):
+        self.poll.status = Poll.STATUS_CLOSED
+        self.poll.save()
+        self.client.login(username="voter", password="testpass123")
+        url = reverse("polls:vote", kwargs={"slug": self.poll.slug})
+        self.client.post(url, {"choice": self.pineapple.pk})
+        self.assertEqual(Vote.objects.count(), 0)
+
+
+class PollViewTests(PollTestMixin, TestCase):
+    def test_open_list_and_archive(self):
+        open_poll = self.make_poll()
+        closed = self.make_poll(
+            title="Old poll",
+            slug="old-poll",
+            status=Poll.STATUS_CLOSED,
+        )
+
+        open_page = self.client.get(reverse("polls:list"))
+        self.assertContains(open_page, open_poll.title)
+        self.assertNotContains(open_page, closed.title)
+
+        archive = self.client.get(reverse("polls:archive"))
+        self.assertContains(archive, closed.title)
+        self.assertNotContains(archive, open_poll.title)
+
+    def test_draft_hidden_from_detail(self):
+        poll = self.make_poll(status=Poll.STATUS_DRAFT, slug="secret", title="Secret")
+        response = self.client.get(reverse("polls:detail", kwargs={"slug": poll.slug}))
+        self.assertEqual(response.status_code, 404)
+
+    def test_blog_detail_embeds_poll(self):
+        poll = self.make_poll()
+        response = self.client.get(poll.blog_post.get_absolute_url())
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, "Pineapple")
+        self.assertContains(response, "Log in")
+
+        self.make_user("voter")
+        self.client.login(username="voter", password="testpass123")
+        response = self.client.get(poll.blog_post.get_absolute_url())
+        self.assertContains(response, "Cast your vote")
+
+    def test_home_page_shows_poll_blog_post(self):
+        poll = self.make_poll()
+        response = self.client.get(reverse("home"))
+        self.assertContains(response, poll.title)
+        self.assertContains(response, "Community")
diff --git a/apps/polls/urls.py b/apps/polls/urls.py
new file mode 100644
index 0000000..8478a92
--- /dev/null
+++ b/apps/polls/urls.py
@@ -0,0 +1,12 @@
+from django.urls import path
+
+from . import views
+
+app_name = "polls"
+
+urlpatterns = [
+    path("", views.OpenPollListView.as_view(), name="list"),
+    path("archive/", views.PollArchiveView.as_view(), name="archive"),
+    path("<slug:slug>/", views.PollDetailView.as_view(), name="detail"),
+    path("<slug:slug>/vote/", views.vote, name="vote"),
+]
diff --git a/apps/polls/views.py b/apps/polls/views.py
new file mode 100644
index 0000000..8d019d3
--- /dev/null
+++ b/apps/polls/views.py
@@ -0,0 +1,86 @@
+from django.contrib.auth.decorators import login_required
+from django.db import transaction
+from django.shortcuts import get_object_or_404, redirect
+from django.views.generic import DetailView, ListView
+
+from apps.notifications.utils import (
+    show_error_notification,
+    show_success_notification,
+)
+
+from .forms import VoteForm
+from .models import Poll, Vote
+
+
+class OpenPollListView(ListView):
+    model = Poll
+    template_name = "polls/poll_list.html"
+    context_object_name = "polls"
+
+    def get_queryset(self):
+        return Poll.objects.currently_open().prefetch_related("choices")
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        context["ended_count"] = Poll.objects.ended().count()
+        return context
+
+
+class PollArchiveView(ListView):
+    model = Poll
+    template_name = "polls/poll_archive.html"
+    context_object_name = "polls"
+    paginate_by = 12
+
+    def get_queryset(self):
+        return Poll.objects.ended().prefetch_related("choices")
+
+
+class PollDetailView(DetailView):
+    model = Poll
+    template_name = "polls/poll_detail.html"
+    context_object_name = "poll"
+
+    def get_queryset(self):
+        qs = Poll.objects.prefetch_related("choices")
+        if self.request.user.is_staff:
+            return qs
+        return qs.visible()
+
+
+@login_required
+def vote(request, slug):
+    poll = get_object_or_404(Poll.objects.prefetch_related("choices"), slug=slug)
+
+    if request.method != "POST":
+        return redirect(poll.get_absolute_url())
+
+    if not poll.is_open:
+        show_error_notification(request, "This poll is not open for voting.")
+        return redirect(_next_url(request, poll))
+
+    form = VoteForm(poll, request.POST)
+    if not form.is_valid():
+        errors = form.non_field_errors() or ["Could not save that vote."]
+        show_error_notification(request, str(errors[0]))
+        return redirect(_next_url(request, poll))
+
+    choice_ids = form.cleaned_data["choice_ids"]
+    with transaction.atomic():
+        Vote.objects.filter(poll=poll, user=request.user).delete()
+        Vote.objects.bulk_create(
+            [
+                Vote(poll=poll, user=request.user, choice_id=choice_id)
+                for choice_id in choice_ids
+            ]
+        )
+
+    show_success_notification(request, "Vote saved!")
+    return redirect(_next_url(request, poll))
+
+
+def _next_url(request, poll):
+    nxt = request.POST.get("next") or request.GET.get("next")
+    if nxt and nxt.startswith("/"):
+        return nxt
+    return poll.get_absolute_url()
diff --git a/snowsune/settings.py b/snowsune/settings.py
index ddc253b..33073ef 100644
--- a/snowsune/settings.py
+++ b/snowsune/settings.py
@@ -84,6 +84,7 @@
     "apps.custompages",  # Custom pages with markdown
     "apps.tanks_manager",  # Per-user tank pages + editor
     "apps.vore_day_rumble",  # Vixi's Vore Day Rumble
+    "apps.polls",  # Site polls (also show up as blog posts)
 ]
 
 MIDDLEWARE = [
diff --git a/snowsune/templates/home.html b/snowsune/templates/home.html
index 7091bd0..ce2a120 100644
--- a/snowsune/templates/home.html
+++ b/snowsune/templates/home.html
@@ -116,6 +116,9 @@ <h2>Read the blog!</h2>
                 <h3><a href="{{ post.get_absolute_url }}">{{ post.title }}</a></h3>
                 <div class="blog-meta">
                     <span class="blog-date">{{ post.display_date|date:"F j, Y" }}</span>
+                    {% if post.poll %}
+                    <span class="tag">{{ post.poll.flair|default:"Poll" }}</span>
+                    {% endif %}
                     {% if post.tags.exists %}
                     <span class="blog-tags">
                         {% for tag in post.tags.all %}
diff --git a/snowsune/templates/tools.html b/snowsune/templates/tools.html
index 07f1529..b3158c9 100644
--- a/snowsune/templates/tools.html
+++ b/snowsune/templates/tools.html
@@ -140,6 +140,15 @@ <h3>Comic Book Club</h3>
                     <a href="{% url 'bookclub:index' %}" class="tool-button">Join the comic book club!</a>
                 </div>
             </div>
+
+            <!-- Polls -->
+            <div class="tool-card">
+                <div class="tool-content">
+                    <h3>Polls</h3>
+                    <p>Vote on site polls! Single or multi choice, and closed polls hang out in the archive.</p>
+                    <a href="{% url 'polls:list' %}" class="tool-button">Vote on polls</a>
+                </div>
+            </div>
         </div>
     </section>
 
@@ -227,6 +236,7 @@ <h3>Development Tools</h3>
         <h3>Resources</h3>
         <ul class="sidebar-links">
             <li><a href="{% url 'bookclub:index' %}">Comic Book Club</a></li>
+            <li><a href="{% url 'polls:list' %}">Polls</a></li>
             <li><a href="https://new.belfrycomics.net/">Belfry Webcomics</a></li>
             <li><a href="https://vixencontrolled.net/">Vixen Controlled Archive</a></li>
         </ul>
diff --git a/snowsune/urls.py b/snowsune/urls.py
index 8962d18..a5dfabc 100644
--- a/snowsune/urls.py
+++ b/snowsune/urls.py
@@ -56,6 +56,7 @@
     path("cust/", include("apps.custompages.urls")),
     path("tanks/", include("apps.tanks_manager.urls")),
     path("voreday/", include("apps.vore_day_rumble.urls")),
+    path("polls/", include("apps.polls.urls")),
     # Hidden pages
     path("orfc/", RandalFanclubView.as_view(), name="randal_fanclub"),
     # SEO
diff --git a/snowsune/views/home.py b/snowsune/views/home.py
index 14193e3..025b505 100644
--- a/snowsune/views/home.py
+++ b/snowsune/views/home.py
@@ -9,7 +9,7 @@ def get(self, request, *args, **kwargs):
         latest_posts = (
             BlogPost.objects.filter(status="published")
             .order_by("-published_at", "-created_at")
-            .select_related("author")
+            .select_related("author", "poll")
             .prefetch_related("tags")[:6]
         )