diff --git a/.env-example b/.env-example
index 4d29238..6d55022 100644
--- a/.env-example
+++ b/.env-example
@@ -3,3 +3,13 @@ api_key=xoxb-something
 default_channel=dev_test
 payment_key="If you're going to work with ping_payment, you'll need to fill this out."
 payment_value="Otherwise, don't worry about it."
+
+enable_blossom=false
+blossom_email=""
+blossom_password=""
+blossom_api_key=""
+blossom_api_url="https://grafeas.org"
+
+QUEUE_POST_TIMEOUT=18
+DEFAULT_CTQ_DURATION=12
+MAX_GRAPH_ENTRIES=10
diff --git a/bubbles/commands/ctq_graphs.py b/bubbles/commands/ctq_graphs.py
new file mode 100644
index 0000000..7f3b06e
--- /dev/null
+++ b/bubbles/commands/ctq_graphs.py
@@ -0,0 +1,774 @@
+"""Generation of graphs for the !ctqstats command."""
+import re
+from datetime import datetime
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+from matplotlib import pyplot as plt
+
+from bubbles.commands.ctq_utils import (
+    CLAIMED_COLOR,
+    COMPLETED_COLOR,
+    FIGURE_DPI,
+    MAX_GRAPH_ENTRIES,
+    PRIMARY_COLOR,
+    QUEUE_POST_TIMEOUT,
+    SECONDARY_COLOR,
+    TEXT_COLOR,
+    UNCLAIMED_COLOR,
+    _convert_blossom_date,
+    _format_hour_duration,
+    _get_rank,
+    _reformat_figure,
+)
+
+header_regex = re.compile(
+    r"^\s*\*(?P<format>\w+)\s*Transcription:?(?:\s*(?P<type>[^\n*]+))?\*", re.IGNORECASE
+)
+
+# If one of the words on the right is included in the post type,
+# take the word on the left as post type.
+post_type_simplification_map = {
+    "Twitter": ["Twitter"],
+    "Facebook": ["Facebook"],
+    "Tumblr": ["Tumblr"],
+    "Reddit": ["Reddit"],
+    "Picture": ["Picture", "Photo"],
+    "Review": ["Review"],
+    "YouTube": ["YouTube", "You Tube"],
+    "Code": ["Code", "Program"],
+    "Chat": ["Chat", "Message", "Discord", "Email", "E-Mail"],
+    "Meme": ["Meme"],
+    "Comic": ["Comic"],
+    "Social Media": ["Social Media"],
+    "Image": ["Image"],
+    "Video": ["Video"],
+    "Text": ["Text"],
+}
+
+
+# Transcription template for a bar chart
+BAR_CHART_TRANSCRIPTION = """### {title}
+
+\\[*A horizontal bar chart, showing "{x_label}" on the x-axis in {primary_color} \
+bars for each "{y_label}" on the y-axis:*]
+
+{entry_list}"""
+
+BAR_CHART_ENTRY = "- **{label}**: {value}"
+BAR_CHART_SPECIAL_ENTRY = "- **{label}** \\[*in {secondary_color}*]: {value}"
+
+# Transcription template for a scatter plot
+SCATTER_PLOT_TRANSCRIPTION = """### {title}
+
+\\[*A scatter plot, showing "{x_label}" on the x axis and "{y_label}" on the y axis.*]
+
+<bla bla bla>"""
+
+
+def _get_username(post: Dict) -> str:
+    """Get the username for the given post."""
+    return "u/" + post["user"]["username"]
+
+
+def _get_subreddit_name(post: Dict) -> str:
+    """Get the subreddit name for the given post."""
+    return "r/" + post["url"].split("/")[4]
+
+
+def _get_transcription_characters(post: Dict) -> int:
+    """Get the number of characters in the transcription for the given post."""
+    return len(post["transcription"]["text"])
+
+
+def _get_transcription_words(post: Dict) -> int:
+    """Get the number of words in the transcription for the given post."""
+    return len(post["transcription"]["text"].split())
+
+
+def _escape_reddit_formatting(text: Any) -> str:
+    """Escape Reddit formatting."""
+    return (
+        str(text)
+        .replace("u/", r"u\/")
+        .replace("r/", r"r\/")
+        .replace("_", r"\_")
+        .replace("*", r"\*")
+    )
+
+
+def _get_post_format_and_type(post: Dict) -> Tuple[str, Optional[str]]:
+    """Determine the type of the post."""
+    text: str = post["transcription"]["text"]
+    header = text.split("---")[0]
+
+    match = header_regex.search(header)
+    if match is None:
+        print(f"Unrecognized post type: {header}")
+        return "Post", "Post"
+
+    tr_format = match.group("format")
+    if tr_format:
+        tr_format = tr_format.strip()
+    tr_type = match.group("type")
+    if tr_type:
+        tr_type = tr_type.strip()
+
+    return tr_format, tr_type
+
+
+def _get_simplified_post_type(post: Dict) -> str:
+    """Get a simplified post type, grouping together multiple types."""
+    post_format, post_type = _get_post_format_and_type(post)
+    post_type = post_type or post_format
+
+    # Simplify the post type into common groups
+    for simple_type, words in post_type_simplification_map.items():
+        for word in words:
+            if word.casefold() in post_type.casefold():
+                return simple_type
+
+    return post_type
+
+
+def _get_event_stream(submissions: List[Dict]) -> List[Tuple[str, datetime]]:
+    """Get a list of events from the submissions.
+
+    Each event is a tuple (<type>, <time>) where type is one of:
+    - created: A new submissions has been created
+    - claimed: A submission has been claimed
+    - completed: A submission has been completed
+
+    The events are sorted by date, ascending.
+    """
+    events = []
+
+    # Generate events for creation, claim and done
+    for post in submissions:
+        # Created
+        events.append(("created", _convert_blossom_date(post["create_time"])))
+        if post["claim_time"]:
+            # Claimed
+            events.append(("claimed", _convert_blossom_date(post["claim_time"])))
+
+            if post["complete_time"]:
+                events.append(("completed", _convert_blossom_date(post["complete_time"])))
+        else:
+            # Expired (dropped off the queue)
+            events.append(
+                (
+                    "expired",
+                    _convert_blossom_date(post["create_time"]) + QUEUE_POST_TIMEOUT,
+                )
+            )
+
+    # Sort by event date
+    events.sort(key=lambda evt: evt[1])
+    return events
+
+
+def _generate_aggregated_bar_chart(
+    *,  # Don't allow positional arguments
+    posts: List[Dict],
+    get_key: Callable,
+    get_value: Callable,
+    default_value: Any = 0,
+    update_value: Callable = lambda a, b: a + b,
+    final_update_value: Callable = lambda value: value,
+    aggregate_rest: Callable = sum,
+    title: str,
+    x_label: str,
+    y_label: str,
+    rest_label: Optional[str] = None,
+) -> Tuple[plt.Figure, str]:
+    """A helper function to generate a generic plot of aggregated data.
+
+    :param posts: The posts to generate the bar chart for.
+    :param get_key: Function to determine the key of a post.
+    :param get_value: Function to determine the value of a post.
+    :param default_value: The default value if no post was given so far.
+    :param update_value: Function to update the value given the previous aggregate and a new value.
+    :param final_update_value: Function to apply a final update to the aggregate value.
+    :param aggregate_rest: Function to aggregate the rest of the entries.
+    :param title: The title of the chart.
+    :param x_label: The label of the x-axis.
+    :param y_label: The label of the y_axis.
+    :param rest_label: The label of the aggregated rest values. If this is None, the rest
+    values will not be aggregated.
+    """
+    count_dir = {}
+
+    # Get the value for each post and aggregate them by key
+    for post in posts:
+        key = get_key(post)
+        cur_count = count_dir.get(key, default_value)
+        count_dir[key] = update_value(cur_count, get_value(post))
+
+    # Sort the users by completed transcriptions
+    count_list = [(key, final_update_value(value)) for key, value in count_dir.items()]
+    count_list.sort(key=lambda entry: entry[1], reverse=True)
+
+    plot_entries = count_list[:MAX_GRAPH_ENTRIES]
+    colors = [PRIMARY_COLOR for _ in range(0, len(plot_entries))]
+
+    has_other_entry = rest_label is not None and len(count_list) > MAX_GRAPH_ENTRIES
+    if has_other_entry:
+        # Aggregate the rest of the entries
+        other_count = aggregate_rest([entry[1] for entry in count_list[MAX_GRAPH_ENTRIES:]])
+        plot_entries.append((rest_label, other_count))
+        colors.append(SECONDARY_COLOR)
+
+    # We want to display the entries top to bottom, so we need to reverse them
+    labels = [entry[0] for entry in reversed(plot_entries)]
+    data = [entry[1] for entry in reversed(plot_entries)]
+    colors.reverse()
+
+    fig: plt.Figure = plt.Figure()
+    ax: plt.Axes = fig.gca()
+
+    ax.barh(labels, data, color=colors)
+    ax.set_ylabel(y_label)
+    ax.set_xlabel(x_label)
+    ax.set_title(title)
+
+    # Annotate data
+    for x, y in zip(data, labels):
+        ax.annotate(
+            x,
+            (x, y),
+            textcoords="offset points",
+            xytext=(3, 0),
+            ha="left",
+            va="center",
+        )
+    _reformat_figure(fig)
+
+    # Automatically create a transcription
+    if has_other_entry:
+        entries = [
+            BAR_CHART_ENTRY.format(
+                label=_escape_reddit_formatting(label),
+                value=_escape_reddit_formatting(value),
+            )
+            for label, value in plot_entries[:-1]
+        ]
+        other = plot_entries[-1]
+        entries.append(
+            BAR_CHART_SPECIAL_ENTRY.format(label=other[0], value=other[1], secondary_color="violet")
+        )
+    else:
+        entries = [
+            BAR_CHART_ENTRY.format(
+                label=_escape_reddit_formatting(label),
+                value=_escape_reddit_formatting(value),
+            )
+            for label, value in plot_entries
+        ]
+    entry_list = "\n".join(entries)
+
+    transcription = BAR_CHART_TRANSCRIPTION.format(
+        title=_escape_reddit_formatting(title),
+        x_label=_escape_reddit_formatting(x_label),
+        y_label=_escape_reddit_formatting(y_label),
+        entry_list=entry_list,
+        primary_color="green",
+    )
+
+    return fig, transcription
+
+
+def user_transcription_count(completed_posts: List[Dict]) -> Tuple[plt.Figure, str]:
+    """Generate stats for transcriptions per user."""
+    return _generate_aggregated_bar_chart(
+        posts=completed_posts,
+        get_key=_get_username,
+        get_value=lambda _post: 1,
+        title=f"Top {MAX_GRAPH_ENTRIES} volunteers with the most transcriptions",
+        x_label="Transcriptions",
+        y_label="Volunteer",
+        rest_label="Other volunteers",
+    )
+
+
+def user_video_transcription_count(
+    completed_posts: List[Dict],
+) -> Tuple[plt.Figure, str]:
+    """Generate stats for transcriptions per user."""
+    video_posts = [
+        post for post in completed_posts if _get_post_format_and_type(post)[0].lower() == "video"
+    ]
+
+    return _generate_aggregated_bar_chart(
+        posts=video_posts,
+        get_key=_get_username,
+        get_value=lambda _post: 1,
+        title=f"Top {MAX_GRAPH_ENTRIES} volunteers with the most video transcriptions",
+        x_label="Video transcriptions",
+        y_label="Volunteer",
+        rest_label="Other volunteers",
+    )
+
+
+def sub_transcription_count(completed_posts: List[Dict]) -> Tuple[plt.Figure, str]:
+    """Generate stats for transcriptions per subreddit."""
+    return _generate_aggregated_bar_chart(
+        posts=completed_posts,
+        get_key=_get_subreddit_name,
+        get_value=lambda _post: 1,
+        title=f"Top {MAX_GRAPH_ENTRIES} subreddits with the most transcriptions",
+        x_label="Transcriptions",
+        y_label="Subreddit",
+        rest_label="Other Subreddits",
+    )
+
+
+def user_max_transcription_length(
+    completed_posts: List[Dict],
+) -> Tuple[plt.Figure, str]:
+    """Generate max transcription length stats per user."""
+    return _generate_aggregated_bar_chart(
+        posts=completed_posts,
+        get_key=_get_username,
+        get_value=_get_transcription_characters,
+        update_value=lambda a, b: max(a, b),
+        aggregate_rest=max,
+        title=f"Top {MAX_GRAPH_ENTRIES} volunteers with the longest transcriptions",
+        x_label="Transcription length",
+        y_label="Volunteer",
+    )
+
+
+def sub_max_transcription_length(completed_posts: List[Dict]) -> Tuple[plt.Figure, str]:
+    """Generate max transcription length stats per subreddit."""
+    return _generate_aggregated_bar_chart(
+        posts=completed_posts,
+        get_key=_get_subreddit_name,
+        get_value=_get_transcription_characters,
+        update_value=lambda a, b: max(a, b),
+        aggregate_rest=max,
+        title=f"Top {MAX_GRAPH_ENTRIES} subreddits with the longest transcriptions",
+        x_label="Transcription length",
+        y_label="Subreddit",
+    )
+
+
+def user_avg_transcription_length(
+    completed_posts: List[Dict],
+) -> Tuple[plt.Figure, str]:
+    """Generate average transcription length stats per user."""
+    return _generate_aggregated_bar_chart(
+        posts=completed_posts,
+        get_key=_get_username,
+        get_value=lambda post: (_get_transcription_characters(post), 1),
+        default_value=(0, 0),
+        # Sum up both the total transcription length and the transcription count
+        update_value=lambda a, b: (a[0] + b[0], a[1] + b[1]),
+        # Divide total transcription length by the number of transcriptions
+        final_update_value=lambda x: int(x[0] / x[1]),
+        aggregate_rest=lambda values: int(sum(values) / len(values)),
+        title=f"Top {MAX_GRAPH_ENTRIES} volunteers with the longest average transcriptions",
+        x_label="Average transcription length",
+        y_label="Volunteer",
+        rest_label="Other volunteers",
+    )
+
+
+def sub_avg_transcription_length(completed_posts: List[Dict]) -> Tuple[plt.Figure, str]:
+    """Generate average transcription length stats per subreddit."""
+    return _generate_aggregated_bar_chart(
+        posts=completed_posts,
+        get_key=_get_subreddit_name,
+        get_value=lambda post: (_get_transcription_characters(post), 1),
+        default_value=(0, 0),
+        # Sum up both the total transcription length and the transcription count
+        update_value=lambda a, b: (a[0] + b[0], a[1] + b[1]),
+        # Divide total transcription length by the number of transcriptions
+        final_update_value=lambda x: int(x[0] / x[1]),
+        aggregate_rest=lambda values: int(sum(values) / len(values)),
+        title=f"Top {MAX_GRAPH_ENTRIES} subreddits with the longest average transcriptions",
+        x_label="Average transcription length",
+        y_label="Subreddit",
+        rest_label="Other subreddits",
+    )
+
+
+def post_types(completed_posts: List[Dict]) -> Tuple[plt.Figure, str]:
+    """Generate stats per post type."""
+    return _generate_aggregated_bar_chart(
+        posts=completed_posts,
+        get_key=_get_simplified_post_type,
+        get_value=lambda _post: 1,
+        title=f"Top {MAX_GRAPH_ENTRIES} post types with the most transcriptions",
+        x_label="Transcriptions",
+        y_label="Post type",
+        rest_label="Other types",
+    )
+
+
+def user_transcription_length_vs_count(
+    completed_posts: List[Dict],
+) -> Tuple[plt.Figure, str]:
+    """Generate a plot of the transcription count vs. length per user."""
+    user_dir = {}
+
+    # Aggregate the values for each user
+    for post in completed_posts:
+        username = _get_username(post)
+        cur_value = user_dir.get(
+            username,
+            {"gamma": post["user"]["gamma"], "count": 0, "length": 0},
+        )
+        user_dir[username] = {
+            "gamma": cur_value["gamma"],
+            "count": cur_value["count"] + 1,
+            "length": cur_value["length"] + _get_transcription_characters(post),
+        }
+
+    # Average transcription length
+    x = [int(user["length"] / user["count"]) for user in user_dir.values()]
+    # Transcription count
+    y = [user["count"] for user in user_dir.values()]
+    # Rank colors
+    colors = [_get_rank(user["gamma"])["color"] for user in user_dir.values()]
+
+    x_label = "Average transcription length"
+    y_label = "Transcription count"
+    title = "Transcription count vs. length per user"
+
+    fig: plt.Figure = plt.Figure()
+    ax: plt.Axes = fig.gca()
+
+    ax.scatter(x, y, color=colors)
+
+    ax.set_xlabel(x_label)
+    ax.set_ylabel(y_label)
+    ax.set_title(title)
+
+    _reformat_figure(fig)
+
+    return fig, f"### {title}"
+
+
+def sub_transcription_length_vs_count(
+    completed_posts: List[Dict],
+) -> Tuple[plt.Figure, str]:
+    """Generate a plot of the transcription count vs. length per user."""
+    sub_dir = {}
+
+    # Aggregate the values for each subreddit
+    for post in completed_posts:
+        sub = _get_subreddit_name(post)
+        cur_value = sub_dir.get(
+            sub,
+            {"count": 0, "length": 0},
+        )
+        sub_dir[sub] = {
+            "count": cur_value["count"] + 1,
+            "length": cur_value["length"] + _get_transcription_characters(post),
+        }
+
+    # Average transcription length
+    x = [int(sub["length"] / sub["count"]) for sub in sub_dir.values()]
+    # Transcription count
+    y = [sub["count"] for sub in sub_dir.values()]
+
+    fig: plt.Figure = plt.Figure()
+    ax: plt.Axes = fig.gca()
+
+    ax.scatter(x, y, color=PRIMARY_COLOR)
+
+    title = "Average transcription length"
+    x_label = "Transcription count"
+    y_label = "Transcription count vs. length per subreddit"
+
+    ax.set_xlabel(x_label)
+    ax.set_ylabel(y_label)
+    ax.set_title(title)
+
+    _reformat_figure(fig)
+    return fig, f"### {title}"
+
+
+def post_timeline(
+    submissions: List[Dict], start_time: datetime, end_time: datetime
+) -> Tuple[plt.Figure, str]:
+    """Generate a timeline of posts."""
+    events = _get_event_stream(submissions)
+
+    unclaimed_count = 0
+    claimed_count = 0
+    completed_count = 0
+
+    unclaimed = []
+    claimed = []
+    completed = []
+
+    dates = []
+
+    all_claimed_time: Optional[datetime] = None
+    all_completed_time: Optional[datetime] = None
+
+    fig: plt.Figure = plt.Figure()
+    ax: plt.Axes = fig.gca()
+
+    title = "Posts over time"
+
+    ax.set_ylabel("Posts")
+    ax.set_xlabel("Time")
+    ax.set_title(title)
+
+    for event, time in events:
+        if start_time <= time <= end_time:
+            # Add an entry before the change
+            dates.append(time)
+            unclaimed.append(unclaimed_count)
+            claimed.append(claimed_count)
+            completed.append(completed_count)
+
+        # Process the change
+        if event == "created":
+            unclaimed_count += 1
+        if event == "expired":
+            unclaimed_count -= 1
+        elif event == "claimed":
+            unclaimed_count -= 1
+            claimed_count += 1
+        elif event == "completed":
+            claimed_count -= 1
+            completed_count += 1
+
+        if start_time <= time <= end_time:
+            # Add an entry after the change
+            dates.append(time)
+            unclaimed.append(unclaimed_count)
+            claimed.append(claimed_count)
+            completed.append(completed_count)
+
+            # Add a vertical line if the queue is ALMOST cleared
+            # (No unclaimed posts remaining)
+            if not all_claimed_time and unclaimed_count == 0:
+                all_claimed_time = time
+
+            # Add a vertical line if the queue is cleared
+            # (All posts completed)
+            if not all_completed_time and (unclaimed_count + claimed_count) == 0:
+                all_completed_time = time
+
+    max_count = max(max(unclaimed), max(claimed), max(completed))
+
+    # Posts over time
+    ax.plot(dates, unclaimed, color=UNCLAIMED_COLOR, label="Unclaimed")
+    ax.plot(dates, claimed, color=CLAIMED_COLOR, label="Claimed")
+    ax.plot(dates, completed, color=COMPLETED_COLOR, label="Completed")
+
+    # Vertical lines to indicate when the queue has been cleared
+    if all_claimed_time:
+        ax.axvline(
+            all_claimed_time,
+            color=CLAIMED_COLOR,
+            linestyle="dashed",
+            label="All posts claimed",
+        )
+        ax.annotate(
+            all_claimed_time.strftime("%H:%M"),
+            (all_claimed_time, max_count),
+            ha="right",
+            va="center",
+            fontsize="13",
+        )
+    if all_completed_time:
+        ax.axvline(
+            all_completed_time,
+            color=COMPLETED_COLOR,
+            linestyle="dashed",
+            label="All posts completed",
+        )
+        ax.annotate(
+            all_completed_time.strftime("%H:%M"),
+            (all_completed_time, max_count * 0.8),
+            ha="right",
+            va="center",
+            fontsize="13",
+        )
+    ax.legend()
+
+    _reformat_figure(fig)
+    return fig, f"### {title}"
+
+
+def general_stats(
+    submissions: List[Dict],
+    completed_posts: List[Dict],
+    start_time: datetime,
+    end_time: datetime,
+) -> Tuple[plt.Figure, str]:
+    """Generate general stats for the event."""
+    users = set()
+    subs = set()
+    types = set()
+    characters = 0
+    words = 0
+
+    # Aggregate the stats from the posts
+    for post in completed_posts:
+        users.add(_get_username(post))
+        subs.add(_get_subreddit_name(post))
+        types.add(_get_simplified_post_type(post))
+        characters += _get_transcription_characters(post)
+        words += _get_transcription_words(post)
+
+    events = _get_event_stream(submissions)
+
+    unclaimed_count = 0
+    claimed_count = 0
+    completed_count = 0
+
+    all_claimed_time = None
+    all_completed_time = None
+
+    # Determine when the queue has been cleared
+    for event, time in events:
+        # Process the change
+        if event == "created":
+            unclaimed_count += 1
+        if event == "expired":
+            unclaimed_count -= 1
+        elif event == "claimed":
+            unclaimed_count -= 1
+            claimed_count += 1
+        elif event == "completed":
+            claimed_count -= 1
+            completed_count += 1
+
+        if start_time <= time <= end_time:
+            # Check if there are no unclaimed posts left
+            if not all_claimed_time and unclaimed_count == 0:
+                all_claimed_time = time - start_time
+
+            # Check if all posts have been completed
+            if not all_completed_time and (unclaimed_count + claimed_count) == 0:
+                all_completed_time = time - start_time
+
+    stats = {
+        "Participants": len(users),
+        "Subreddits": len(subs),
+        "Post types": len(types),
+        "Transcriptions": len(completed_posts),
+        "Words written": words,
+        "Characters typed": characters,
+    }
+
+    if all_claimed_time:
+        stats["All claimed"] = _format_hour_duration(all_claimed_time)
+    if all_completed_time:
+        stats["All completed"] = _format_hour_duration(all_completed_time)
+
+    title = "CtQ in Numbers"
+
+    # Generate the chart
+    fig: plt.Figure = plt.Figure()
+    # Disable the axes https://stackoverflow.com/a/9295367
+    ax = plt.Axes(fig, [0.0, 0.0, 1.0, 1.0])
+    ax.set_axis_off()
+    fig.add_axes(ax)
+
+    # Font sizes
+    title_size_f = 25
+    number_size_f = 23
+    text_size_f = 12
+    outer_margin_f = 17
+    line_margin_f = 3
+
+    height_f = (
+        outer_margin_f * 2
+        + title_size_f
+        + line_margin_f
+        + len(stats) * (number_size_f + line_margin_f)
+    )
+
+    # Sizes in percentages
+    title_size_perc = title_size_f / height_f
+    number_size_perc = number_size_f / height_f
+    line_margin_perc = line_margin_f / height_f
+    outer_margin_perc = outer_margin_f / height_f
+
+    # Add the title
+    fig.text(
+        0.5,
+        1 - outer_margin_perc,
+        title,
+        horizontalalignment="center",
+        verticalalignment="center",
+        fontsize=str(title_size_f),
+        color=TEXT_COLOR,
+    )
+
+    # For every stat, add the number on the left side in one of the colors
+    # On the right side, add the name of the stat in normal text
+    for i, key in enumerate(stats):
+        height = (
+            1
+            - outer_margin_perc
+            - title_size_perc
+            - line_margin_perc
+            - i * (number_size_perc + line_margin_perc)
+        )
+        color = PRIMARY_COLOR if i % 2 == 0 else SECONDARY_COLOR
+
+        # Add thousand separators
+        formatted_stat = "{:,}".format(stats[key]) if isinstance(stats[key], int) else stats[key]
+
+        # The number part of the stat
+        fig.text(
+            0.5,
+            height,
+            f"{formatted_stat} ",
+            horizontalalignment="right",
+            verticalalignment="center",
+            fontsize=str(number_size_f),
+            color=color,
+        )
+        # The name of the stat
+        fig.text(
+            0.5,
+            height,
+            key,
+            horizontalalignment="left",
+            verticalalignment="center",
+            fontsize=str(text_size_f),
+            color=TEXT_COLOR,
+        )
+
+    # No idea what units the font size is in, but it's not in pixels
+    font_adjustment_factor = 3.2
+    height_px = height_f * font_adjustment_factor
+    _reformat_figure(fig, width=5, height=height_px / FIGURE_DPI)
+    return fig, f"### {title}"
+
+
+def generate_ctq_graphs(
+    submissions: List[Dict], start_time: datetime, end_time: datetime
+) -> Tuple[List[plt.Figure], str]:
+    """Generate the graphs for the CtQ event and their transcriptions."""
+    completed_posts = [post for post in submissions if post["transcription"] and post["user"]]
+
+    # We got a list of tuples, we make it a tuple of lists
+    # https://stackoverflow.com/a/13635074
+    figures, transcriptions = zip(
+        *[
+            user_transcription_count(completed_posts),
+            user_video_transcription_count(completed_posts),
+            sub_transcription_count(completed_posts),
+            user_max_transcription_length(completed_posts),
+            sub_max_transcription_length(completed_posts),
+            user_avg_transcription_length(completed_posts),
+            sub_avg_transcription_length(completed_posts),
+            post_types(completed_posts),
+            user_transcription_length_vs_count(completed_posts),
+            sub_transcription_length_vs_count(completed_posts),
+            post_timeline(submissions, start_time, end_time),
+            general_stats(submissions, completed_posts, start_time, end_time),
+        ]
+    )
+
+    transcription = "\n\n---\n\n".join(transcriptions)
+    return figures, transcription
diff --git a/bubbles/commands/ctq_stats.py b/bubbles/commands/ctq_stats.py
new file mode 100644
index 0000000..0748fc6
--- /dev/null
+++ b/bubbles/commands/ctq_stats.py
@@ -0,0 +1,293 @@
+import logging
+import tempfile
+from datetime import datetime, timezone
+from typing import Any, Callable, Dict, List
+
+import requests.exceptions
+
+from bubbles.commands.ctq_graphs import generate_ctq_graphs
+from bubbles.commands.ctq_utils import (
+    DEFAULT_CTQ_DURATION,
+    DEFAULT_CTQ_START,
+    QUEUE_POST_TIMEOUT,
+    _convert_blossom_date,
+    _extract_blossom_id,
+    _get_elapsed,
+    _get_list_chunks,
+)
+from bubbles.config import PluginManager, blossom
+
+
+def _is_submission_in_queue(submission: Dict, start_date: datetime, end_date: datetime) -> bool:
+    """Determine if the given submission was in the queue during the given time frame."""
+    create_time = _convert_blossom_date(submission["create_time"])
+
+    if start_date <= create_time <= end_date:
+        # The submission entered the queue in the time frame
+        return True
+
+    first_time = start_date - QUEUE_POST_TIMEOUT
+
+    if create_time < first_time or create_time > end_date:
+        # The submission entered the queue too early or too late
+        return False
+
+    claim_time = (
+        _convert_blossom_date(submission["claim_time"]) if submission["claim_time"] else None
+    )
+
+    if claim_time and claim_time < start_date:
+        # The transcription has already been worked on before the event
+        return False
+
+    return True
+
+
+def get_ctq_submissions(start_date: datetime, end_date: datetime, say: Callable) -> List[Dict]:
+    """Get the submissions during the CtQ time."""
+    start = datetime.now(tz=timezone.utc)
+    say("Fetching the queue submissions from Blossom... (0%)")
+
+    # Posts remain in the queue for a given time
+    # We need to consider the posts that were already there at the start
+    first_time = start_date - QUEUE_POST_TIMEOUT
+
+    submissions = []
+    page = 1
+
+    # Fetch the submissions in the time frame
+    while True:
+        response = blossom.get(
+            "submission",
+            params={
+                "page_size": 500,
+                "page": page,
+                "create_time__gte": first_time.isoformat(),
+                "create_time__lte": end_date.isoformat(),
+                "removed_from_queue": False,
+            },
+        )
+        if not response.ok:
+            say(f"Error while fetching the submissions: {response.status_code}\n{response.content}")
+            return []
+
+        try:
+            data = response.json()
+        except requests.exceptions.JSONDecodeError as e:
+            logging.exception(e, exc_info=True)
+            logging.error(response.text)
+            return []
+
+        submissions += data["results"]
+
+        percentage = len(submissions) / data["count"] if data["count"] > 0 else 1
+
+        say(f"Fetching the queue submissions from Blossom... ({percentage:.0%})")
+
+        if data["next"] is None:
+            # No more submissions to fetch
+            break
+
+        page += 1
+
+    # Filter out the submissions that have been done before the start
+    submissions = [
+        submission
+        for submission in submissions
+        if _is_submission_in_queue(submission, start_date, end_date)
+    ]
+
+    say(f"Fetched {len(submissions)} queue submissions from Blossom ({_get_elapsed(start)})")
+
+    return submissions
+
+
+def attach_transcriptions(submissions: List[Dict], say: Callable) -> List[Dict]:
+    """For each submission, attach the corresponding transcription (if available)."""
+    start = datetime.now(tz=timezone.utc)
+    say("Fetching the transcriptions from Blossom... (0%)")
+
+    updated_submissions = []
+
+    tr_count = 0
+
+    chunks = _get_list_chunks(submissions, 25)
+
+    # Try to get the transcriptions for the submissions
+    for idx, chunk in enumerate(chunks):
+        for submission in chunk:
+            updated_submission = dict(**submission, transcription=None)
+
+            if not submission["completed_by"]:
+                # There's no transcription to attach
+                updated_submissions.append(updated_submission)
+                continue
+
+            author_id = _extract_blossom_id(submission["completed_by"])
+
+            # Try to get the transcription from Blossom
+            response = blossom.get(
+                "transcription",
+                params={
+                    "page_size": 1,
+                    "page": 1,
+                    "author": author_id,
+                    "submission": submission["id"],
+                },
+            )
+            if not response.ok:
+                say(
+                    "Error while fetching the transcriptions: "
+                    f"{response.status_code}\n{response.content}"
+                )
+                return []
+
+            results = response.json()["results"]
+
+            if len(results) > 0:
+                # Attach the transcription text
+                transcription = results[0]
+                updated_submission["transcription"] = transcription
+                tr_count += 1
+
+            updated_submissions.append(updated_submission)
+
+        percentage = (idx + 1) / len(chunks)
+        say(f"Fetching the transcriptions from Blossom... ({percentage:.0%})")
+
+    say(f"Fetched {tr_count} transcriptions from Blossom ({_get_elapsed(start)})")
+
+    return updated_submissions
+
+
+def attach_users(submissions: List[Dict], say: Callable) -> List[Dict]:
+    """For each submission, attach the corresponding user (if available)."""
+    start = datetime.now(tz=timezone.utc)
+    say("Fetching the users from Blossom... (0%)")
+
+    updated_submissions = []
+
+    user_cache = {}
+
+    chunks = _get_list_chunks(submissions, 25)
+
+    # Try to get the transcriptions for the submissions
+    for idx, chunk in enumerate(chunks):
+        for submission in chunk:
+            updated_submission = dict(**submission, user=None)
+
+            if not submission["completed_by"]:
+                # There's no transcription to attach
+                updated_submissions.append(updated_submission)
+                continue
+
+            user_id = _extract_blossom_id(submission["completed_by"])
+
+            # Try to get the user from the cache, if available
+            if user := user_cache.get(user_id):
+                updated_submission["user"] = user
+                updated_submissions.append(updated_submission)
+                continue
+
+            # Try to get the user from Blossom
+            response = blossom.get(
+                "volunteer",
+                params={"page_size": 1, "page": 1, "id": user_id},
+            )
+            if not response.ok:
+                say(f"Error while fetching the users: {response.status_code}\n{response.content}")
+                return []
+
+            results = response.json()["results"]
+
+            if len(results) > 0:
+                # Attach the transcription text
+                user = results[0]
+                updated_submission["user"] = user
+                # Cache the user for later
+                user_cache[user_id] = user
+
+            updated_submissions.append(updated_submission)
+
+        percentage = (idx + 1) / len(chunks)
+        say(f"Fetching the users from Blossom... ({percentage:.0%})")
+
+    say(f"Fetched {len(user_cache)} users from Blossom ({_get_elapsed(start)})")
+
+    return updated_submissions
+
+
+def generate_ctq_stats(start_date: datetime, end_date: datetime, say: Callable) -> None:
+    """Generate the stats for the CtQ event."""
+    start = datetime.now(tz=timezone.utc)
+    say(f"start: {start_date}, end: {end_date}")
+
+    submissions = get_ctq_submissions(start_date, end_date, say)
+    submissions = attach_transcriptions(submissions, say)
+    submissions = attach_users(submissions, say)
+
+    figures, transcription = generate_ctq_graphs(submissions, start_date, end_date)
+
+    with tempfile.NamedTemporaryFile(delete=False, mode="w", encoding="utf-8", suffix=".txt") as fp:
+        fp.write(transcription)
+        say(f"Transcription: file://{fp.name}")
+
+    say(f"Here are the CtQ stats! ({_get_elapsed(start)})", figures=figures)
+
+
+def ctq_stats(payload: Any) -> None:
+    """Process the !ctqstats command."""
+    say = payload["extras"]["say"]
+    args = payload.get("text").split()
+
+    if len(args) < 2:
+        # No start time provided
+        if not DEFAULT_CTQ_START:
+            say(f"Please provide the start time of the CtQ event, e.g. 2021-01-30T12:00")
+            return
+        else:
+            start_date_str = DEFAULT_CTQ_START
+    else:
+        start_date_str = args[1]
+
+    # Parse the start time
+    try:
+        start_date = datetime.fromisoformat(start_date_str)
+        start_date = start_date.replace(tzinfo=start_date.tzinfo or timezone.utc)
+    except ValueError:
+        say(f"'{start_date_str}' is not a valid date/time. Try something like 2021-01-30T12:00.")
+        return
+
+    if len(args) >= 3:
+        # An end time was provided
+        if len(args) > 3:
+            # Too many arguments
+            say(f"You provided too many arguments, I need a start time and an optional end time.")
+            return
+
+        # Parse the end time
+        end_date_str = args[2]
+        try:
+            end_date = datetime.fromisoformat(end_date_str)
+            end_date = end_date.replace(tzinfo=end_date.tzinfo or timezone.utc)
+        except ValueError:
+            say(f"'{end_date_str}' is not a valid date/time. Try something like 2021-01-30T12:00.")
+            return
+    else:
+        # No end time provided, use the default CTQ duration
+        end_date = start_date + DEFAULT_CTQ_DURATION
+
+    if end_date <= start_date:
+        # The end time must be after the start time
+        say("The end time must be after the start time.")
+        return
+
+    generate_ctq_stats(start_date, end_date, say)
+
+
+PluginManager.register_plugin(
+    ctq_stats,
+    r"ctqstats",
+    help="!ctqstats <start_date> <end_date> - Generate stats for a Clear the Queue event."
+    "<end_date> is optional and defaults to 12 hours after the start date.",
+)
diff --git a/bubbles/commands/ctq_utils.py b/bubbles/commands/ctq_utils.py
new file mode 100644
index 0000000..69521f3
--- /dev/null
+++ b/bubbles/commands/ctq_utils.py
@@ -0,0 +1,117 @@
+import os
+from datetime import datetime, timedelta, timezone
+
+# The time for which posts remain in the queue until they are removed
+from typing import Dict, List, Optional, TypeVar
+
+from matplotlib import pyplot as plt
+
+QUEUE_POST_TIMEOUT = timedelta(hours=int(os.getenv("QUEUE_POST_TIMEOUT", "18")))
+# The default duration of a CtQ event
+# Set this lower when debugging to reduce loading times
+DEFAULT_CTQ_DURATION = timedelta(hours=int(os.getenv("DEFAULT_CTQ_DURATION", "12")))
+# A default value for the CtQ start time
+# This can be useful during development to test the generation without
+# specifying the times every time.
+# This variable should NOT be set in production
+DEFAULT_CTQ_START = os.getenv("DEFAULT_CTQ_START")
+# The maximum number of entries to display per chart
+MAX_GRAPH_ENTRIES = int(os.getenv("MAX_GRAPH_ENTRIES", "10"))
+
+BACKGROUND_COLOR = "#36393f"  # Discord background color
+TEXT_COLOR = "white"
+LINE_COLOR = "white"
+PRIMARY_COLOR = "#94e044"
+SECONDARY_COLOR = "#8282ed"
+
+UNCLAIMED_COLOR = "#ffc033"
+CLAIMED_COLOR = "#0eebd0"
+COMPLETED_COLOR = "#94e044"
+
+FIGURE_DPI = 200.0
+FIGURE_WIDTH = 10
+FIGURE_HEIGHT = 4.2
+
+# Global settings for all plots
+plt.rcParams["figure.facecolor"] = BACKGROUND_COLOR
+plt.rcParams["axes.facecolor"] = BACKGROUND_COLOR
+plt.rcParams["axes.labelcolor"] = TEXT_COLOR
+plt.rcParams["axes.edgecolor"] = LINE_COLOR
+plt.rcParams["text.color"] = TEXT_COLOR
+plt.rcParams["xtick.color"] = LINE_COLOR
+plt.rcParams["ytick.color"] = LINE_COLOR
+plt.rcParams["grid.color"] = LINE_COLOR
+plt.rcParams["grid.alpha"] = 0.8
+plt.rcParams["figure.dpi"] = FIGURE_DPI
+
+FLAIR_RANKS = [
+    {"name": "Initiate", "threshold": 1, "color": "#ffffff"},
+    {"name": "Pink", "threshold": 25, "color": "#e696be"},
+    {"name": "Green", "threshold": 50, "color": "#00ff00"},
+    {"name": "Teal", "threshold": 100, "color": "#00cccc"},
+    {"name": "Purple", "threshold": 250, "color": "#ff67ff"},
+    {"name": "Gold", "threshold": 500, "color": "#ffd700"},
+    {"name": "Diamond", "threshold": 1000, "color": "#add8e6"},
+    {"name": "Ruby", "threshold": 2500, "color": "#ff7ac2"},
+    {"name": "Topaz", "threshold": 5000, "color": "#ff7d4d"},
+    {"name": "Jade", "threshold": 10000, "color": "#31c831"},
+    {"name": "Sapphire", "threshold": 20000, "color": "#99afef"},
+]
+
+T = TypeVar("T")
+
+
+def _get_list_chunks(original_list: List[T], chunk_size: int) -> List[List[T]]:
+    """Partition a list into chunks of the given size.
+
+    We mostly use this if we want to iterate through a full list,
+    but send a progress update to Slack in-between.
+    """
+    # See https://favtutor.com/blogs/partition-list-python
+    return [original_list[i : i + chunk_size] for i in range(0, len(original_list), chunk_size)]
+
+
+def _get_elapsed(start: datetime) -> str:
+    """Get a string representing the elapsed time."""
+    duration = datetime.now(tz=timezone.utc) - start
+    return f"{duration.total_seconds():.3f} s"
+
+
+def _extract_blossom_id(blossom_url: str) -> str:
+    """Extract the ID from a Blossom URL."""
+    return blossom_url.split("/")[-2]
+
+
+def _convert_blossom_date(blossom_date: Optional[str]) -> Optional[datetime]:
+    """Convert a Blossom date string to a datetime object."""
+    return (
+        # Python doesn't like Z for UTC
+        datetime.fromisoformat(blossom_date.replace("Z", "+00:00"))
+        if blossom_date
+        else None
+    )
+
+
+def _reformat_figure(
+    fig: plt.Figure, width: float = FIGURE_WIDTH, height: float = FIGURE_HEIGHT
+) -> None:
+    """Reformat the given figure to the default size."""
+    fig.set_size_inches(width, height)
+    fig.tight_layout()
+
+
+def _get_rank(gamma: int) -> Dict:
+    """Get the rank matching the gamma score."""
+    for rank in reversed(FLAIR_RANKS):
+        if gamma >= rank["threshold"]:
+            return rank
+
+    return FLAIR_RANKS[0]
+
+
+def _format_hour_duration(duration: timedelta) -> str:
+    """Format a duration in the HH:MM h format."""
+    hours, rem = divmod(duration.seconds, 3600)
+    minutes, _ = divmod(rem, 60)
+
+    return f"{hours:02d}:{minutes:02d} h"
diff --git a/bubbles/commands/suggest_upvote_filter_val.py b/bubbles/commands/suggest_upvote_filter_val.py
index dd8efdf..32a4d5f 100644
--- a/bubbles/commands/suggest_upvote_filter_val.py
+++ b/bubbles/commands/suggest_upvote_filter_val.py
@@ -109,7 +109,6 @@ def get_total_count_of_posts_in_24_hours(post_list: List) -> int:
     current_time = time.time()
 
     for post in post_list:
-
         if timedelta(seconds=current_time - post.created_utc) < timedelta(days=1):
             submissions_last_24h.append(post)
 
diff --git a/bubbles/config.py b/bubbles/config.py
index e26ebeb..0aa5c3e 100644
--- a/bubbles/config.py
+++ b/bubbles/config.py
@@ -92,6 +92,7 @@ class AuthResponse:
     )
     print("blossom loaded!")
 else:
+    logging.warning("Blossom is disabled, set ENABLE_BLOSSOM env variable to true")
     blossom = mock.MagicMock()
 
 # There is an overloaded __get__ in the underlying Bolt app, so this type
diff --git a/bubbles/interactive.py b/bubbles/interactive.py
index debd421..2249de9 100644
--- a/bubbles/interactive.py
+++ b/bubbles/interactive.py
@@ -1,7 +1,8 @@
 import random
-from typing import Any
+from typing import Any, Optional
 
 import click
+import matplotlib.pyplot as plt
 from utonium import PluginManager
 
 
@@ -53,8 +54,32 @@ def say(self, message: str, *args: Any, **kwargs: Any) -> dict:
         click.echo(message)
         return self.build_message_payload(message)
 
-    def _base_payload(self) -> dict:
+    def say(self, message: str, figures: Optional[list[plt.Figure]] = None) -> None:
+        print_msg = message
+
+        if figures and len(figures) > 0:
+            # Save the figures and add them to the message
+            attachments = []
+            for fig in figures:
+                # Save the figure to a file in the temp folder
+                file = NamedTemporaryFile(delete=False, suffix=".png")
+                fig.savefig(file, format="png")
+                attachments.append(file)
+                plt.close(fig)
+                file.close()
+
+            # Generate (in most cases) clickable links to the files
+            attachment_links = ", ".join(
+                [f"file://{attachment.name}" for attachment in attachments]
+            )
+            print_msg += f"\n[{len(attachments)} Attachment(s): {attachment_links}]"
+
+        print(print_msg)
+        return self.build_payload(message)
+
+    def build_payload(self, text: str) -> dict:
         return {
+            "text": text,
             "user": "console",
             "channel": "console",
             "ts": str(random.randint(0, 9999) + random.random()),