War Story: We Introduced Hackathons and Increased Innovation by 30%

In Q3 2022, our 42-person engineering organization was shipping features 18% slower than the prior year, with zero new product experiments reaching production in 9 months. We introduced a structured, quarterly hackathon program, and within 6 months, measurable innovation output (defined as new experiments reaching production) increased by 30%, while time-to-prototype for new ideas dropped from 14 days to 5.5 days.

📡 Hacker News Top Stories Right Now

• Show HN: WhatCable, a tiny menu bar app for inspecting USB-C cables (61 points)
• Auto Polo (54 points)
• Show HN: Perfect Bluetooth MIDI for Windows (19 points)
• If I could make my own GitHub (53 points)
• How Mark Klein told the EFF about Room 641A [book excerpt] (605 points)

Key Insights

• Teams running ≥2 internal hackathons per quarter see a 22-35% lift in new experiment production (our benchmark: 30% lift over 6 months)
• We standardized on Prophet v1.1.4 for pre-hackathon demand forecasting, reducing resource overallocation by 41%
• Total hackathon program cost (prizes, catered meals, cloud credits) was $18k per quarter, with $142k in attributed annual revenue from hackathon-born features
• By 2026, 60% of mid-sized engineering orgs will replace ad-hoc hackathons with structured, OKR-aligned sprint-hackathons to avoid "innovation theater"

Metric

Pre-Hackathon (Q2 2022)

Post-Hackathon (Q2 2023)

% Change

New experiments reaching production per quarter

4

5.2

+30%

Time-to-prototype (days)

14

5.5

-60.7%

Engineer participation rate in innovation programs

12%

78%

+550%

Cloud spend on experimental workloads

$2.1k/quarter

$8.4k/quarter

+300%

Attributed revenue from new experiments

$12k/quarter

$47k/quarter

+291.7%

Employee Net Promoter Score (eNPS) for engineering

22

41

+86.4%

import os
import re
import sys
import json
import requests
from typing import Dict, List, Optional, Tuple
from dataclasses import dataclass

# Configuration for hackathon submission validation
GITHUB_API_BASE = "https://api.github.com"
HACKATHON_ORG = "our-eng-org"
MIN_TEAM_SIZE = 1
MAX_TEAM_SIZE = 4
REQUIRED_FILES = ["README.md", "demo.md"]
MAX_REPO_SIZE_MB = 100

@dataclass
class SubmissionResult:
    is_valid: bool
    errors: List[str]
    warnings: List[str]
    repo_metadata: Optional[Dict] = None

def validate_github_repo(repo_url: str) -> Tuple[bool, Optional[Dict], List[str]]:
    """Validate that a GitHub repo exists, is public, and meets size constraints."""
    # Extract owner and repo from URL
    pattern = r"github\.com/([^/]+)/([^/]+)"
    match = re.search(pattern, repo_url)
    if not match:
        return False, None, ["Invalid GitHub URL format"]

    owner, repo = match.groups()
    # Remove trailing .git if present
    repo = repo.removesuffix(".git")

    try:
        # Fetch repo metadata from GitHub API
        response = requests.get(
            f"{GITHUB_API_BASE}/repos/{owner}/{repo}",
            headers={"Accept": "application/vnd.github.v3+json"},
            timeout=10
        )
        response.raise_for_status()
        repo_data = response.json()

        # Check repo is public
        if repo_data.get("private", True):
            return False, repo_data, ["Repository must be public"]

        # Check repo size (GitHub returns size in KB)
        size_mb = repo_data.get("size", 0) / 1024
        if size_mb > MAX_REPO_SIZE_MB:
            return False, repo_data, [f"Repository size {size_mb:.2f}MB exceeds max {MAX_REPO_SIZE_MB}MB"]

        return True, repo_data, []
    except requests.exceptions.RequestException as e:
        return False, None, [f"Failed to fetch repo metadata: {str(e)}"]
    except json.JSONDecodeError:
        return False, None, ["Invalid response from GitHub API"]

def validate_submission(submission: Dict) -> SubmissionResult:
    """Full validation of a hackathon submission."""
    errors = []
    warnings = []
    repo_metadata = None

    # Validate required fields
    required_fields = ["team_name", "repo_url", "team_members", "demo_url"]
    for field in required_fields:
        if field not in submission or not submission[field]:
            errors.append(f"Missing required field: {field}")

    if errors:
        return SubmissionResult(False, errors, warnings)

    # Validate team size
    team_members = submission["team_members"]
    if not isinstance(team_members, list):
        errors.append("team_members must be a list")
    else:
        if len(team_members) < MIN_TEAM_SIZE or len(team_members) > MAX_TEAM_SIZE:
            errors.append(f"Team size must be between {MIN_TEAM_SIZE} and {MAX_TEAM_SIZE}")

    # Validate repo
    repo_valid, repo_metadata, repo_errors = validate_github_repo(submission["repo_url"])
    errors.extend(repo_errors)

    # Check required files exist in repo
    if repo_valid and repo_metadata:
        owner = repo_metadata["owner"]["login"]
        repo = repo_metadata["name"]
        try:
            # Fetch repo tree
            tree_response = requests.get(
                f"{GITHUB_API_BASE}/repos/{owner}/{repo}/git/trees/main?recursive=1",
                timeout=10
            )
            tree_response.raise_for_status()
            tree = tree_response.json()
            file_paths = [item["path"] for item in tree.get("tree", []) if item["type"] == "blob"]

            for required_file in REQUIRED_FILES:
                if not any(f.endswith(required_file) for f in file_paths):
                    warnings.append(f"Missing recommended file: {required_file}")
        except requests.exceptions.RequestException as e:
            warnings.append(f"Could not verify required files: {str(e)}")

    # Validate demo URL is reachable
    try:
        demo_response = requests.head(submission["demo_url"], timeout=5)
        if demo_response.status_code >= 400:
            warnings.append(f"Demo URL returned status {demo_response.status_code}")
    except requests.exceptions.RequestException:
        warnings.append("Demo URL is not reachable")

    return SubmissionResult(
        is_valid=len(errors) == 0,
        errors=errors,
        warnings=warnings,
        repo_metadata=repo_metadata
    )

if __name__ == "__main__":
    # Example usage: validate a sample submission
    sample_submission = {
        "team_name": "Data Dynamo",
        "repo_url": "https://github.com/our-eng-org/hackathon-2023q1-data-pipeline",
        "team_members": ["alice", "bob", "charlie"],
        "demo_url": "https://demo.example.com/data-pipeline"
    }

    result = validate_submission(sample_submission)
    print(json.dumps({
        "is_valid": result.is_valid,
        "errors": result.errors,
        "warnings": result.warnings
    }, indent=2))

    sys.exit(0 if result.is_valid else 1)

import { LinearClient, Issue, WorkflowState } from "@linear/sdk";
import { writeFileSync } from "fs";
import { format, differenceInDays } from "date-fns";

// Configuration
const LINEAR_API_KEY = process.env.LINEAR_API_KEY || "";
const HACKATHON_LABEL = "hackathon-2023q1";
const PRODUCTION_WORKFLOW_STATE = "Production";
const PROTOTYPE_WORKFLOW_STATE = "Prototype";

interface InnovationMetrics {
    totalProjects: number;
    projectsInProduction: number;
    productionRate: number;
    avgTimeToPrototypeDays: number;
    avgTimeToProductionDays: number;
    participationCount: number;
    uniqueParticipants: Set;
}

interface ProjectTimeline {
    issueId: string;
    title: string;
    createdAt: Date;
    prototypeAt?: Date;
    productionAt?: Date;
    teamMembers: string[];
}

async function fetchHackathonProjects(client: LinearClient): Promise {
    try {
        const issues = await client.issues({
            filter: {
                labels: { name: { eq: HACKATHON_LABEL } },
                state: { type: { neq: "canceled" } }
            }
        });
        return issues.nodes;
    } catch (error) {
        console.error("Failed to fetch Linear issues:", error);
        throw new Error(`Linear API error: ${error instanceof Error ? error.message : String(error)}`);
    }
}

function getWorkflowStateTransitionDate(
    issue: Issue,
    targetStateName: string
): Date | undefined {
    // Linear audit logs track state transitions; we use the issue's history
    // Note: This requires the Linear API's audit log scope, enabled in our org
    const history = issue.history?.nodes || [];
    const transition = history.find(entry => 
        entry.type === "workflowStateChanged" && 
        (entry.workflowState as WorkflowState)?.name === targetStateName
    );
    return transition ? new Date(transition.createdAt) : undefined;
}

async function calculateInnovationMetrics(projects: Issue[]): Promise {
    const metrics: InnovationMetrics = {
        totalProjects: 0,
        projectsInProduction: 0,
        productionRate: 0,
        avgTimeToPrototypeDays: 0,
        avgTimeToProductionDays: 0,
        participationCount: 0,
        uniqueParticipants: new Set()
    };

    const timelines: ProjectTimeline[] = [];
    let totalPrototypeDays = 0;
    let totalProductionDays = 0;
    let prototypeCount = 0;
    let productionCount = 0;

    for (const project of projects) {
        metrics.totalProjects++;

        // Get team members (assignees)
        const assignees = project.assignees?.nodes || [];
        const teamMembers = assignees.map(a => a.name);
        metrics.participationCount += teamMembers.length;
        teamMembers.forEach(m => metrics.uniqueParticipants.add(m));

        // Get timeline dates
        const createdAt = new Date(project.createdAt);
        const prototypeAt = getWorkflowStateTransitionDate(project, PROTOTYPE_WORKFLOW_STATE);
        const productionAt = getWorkflowStateTransitionDate(project, PRODUCTION_WORKFLOW_STATE);

        timelines.push({
            issueId: project.id,
            title: project.title,
            createdAt,
            prototypeAt,
            productionAt,
            teamMembers
        });

        // Calculate time to prototype
        if (prototypeAt) {
            const days = differenceInDays(prototypeAt, createdAt);
            totalPrototypeDays += days;
            prototypeCount++;
        }

        // Calculate time to production
        if (productionAt) {
            const days = differenceInDays(productionAt, createdAt);
            totalProductionDays += days;
            productionCount++;
            metrics.projectsInProduction++;
        }
    }

    // Calculate averages
    metrics.avgTimeToPrototypeDays = prototypeCount > 0 ? totalPrototypeDays / prototypeCount : 0;
    metrics.avgTimeToProductionDays = productionCount > 0 ? totalProductionDays / productionCount : 0;
    metrics.productionRate = metrics.totalProjects > 0 ? (metrics.projectsInProduction / metrics.totalProjects) * 100 : 0;

    return metrics;
}

async function main() {
    if (!LINEAR_API_KEY) {
        console.error("LINEAR_API_KEY environment variable is required");
        process.exit(1);
    }

    try {
        const client = new LinearClient({ apiKey: LINEAR_API_KEY });
        console.log(`Fetching projects with label: ${HACKATHON_LABEL}`);

        const projects = await fetchHackathonProjects(client);
        console.log(`Found ${projects.length} hackathon projects`);

        const metrics = await calculateInnovationMetrics(projects);

        // Output metrics to JSON
        const output = {
            ...metrics,
            uniqueParticipants: Array.from(metrics.uniqueParticipants),
            generatedAt: format(new Date(), "yyyy-MM-dd HH:mm:ss")
        };

        writeFileSync("./innovation-metrics.json", JSON.stringify(output, null, 2));
        console.log("Metrics written to innovation-metrics.json");
        console.log(`Production rate: ${metrics.productionRate.toFixed(2)}%`);
        console.log(`Avg time to prototype: ${metrics.avgTimeToPrototypeDays.toFixed(2)} days`);
    } catch (error) {
        console.error("Fatal error:", error);
        process.exit(1);
    }
}

main();

package main

import (
    "context"
    "fmt"
    "log"
    "os"
    "time"

    corev1 "k8s.io/api/core/v1"
    "k8s.io/apimachinery/pkg/api/errors"
    "k8s.io/apimachinery/pkg/api/resource"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/apimachinery/pkg/runtime"
    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/rest"
    "k8s.io/client-go/tools/clientcmd"
    "sigs.k8s.io/controller-runtime/pkg/builder"
    "sigs.k8s.io/controller-runtime/pkg/client"
    "sigs.k8s.io/controller-runtime/pkg/manager"
    "sigs.k8s.io/controller-runtime/pkg/reconcile"
)

// HackathonNamespaceReconciler manages lifecycle of hackathon experiment namespaces
type HackathonNamespaceReconciler struct {
    Client client.Client
    Scheme *runtime.Scheme
    K8s    kubernetes.Interface
}

// Reconcile ensures hackathon namespaces have correct resource quotas and labels
func (r *HackathonNamespaceReconciler) Reconcile(ctx context.Context, req reconcile.Request) (reconcile.Result, error) {
    nsName := req.Name
    log.Printf("Reconciling namespace: %s", nsName)

    // Only process namespaces with hackathon label
    var ns corev1.Namespace
    if err := r.Client.Get(ctx, req.NamespacedName, &ns); err != nil {
        if errors.IsNotFound(err) {
            log.Printf("Namespace %s not found, skipping", nsName)
            return reconcile.Result{}, nil
        }
        log.Printf("Failed to get namespace %s: %v", nsName, err)
        return reconcile.Result{}, err
    }

    // Check if namespace is a hackathon experiment
    hackathonID, exists := ns.Labels["hackathon-id"]
    if !exists {
        log.Printf("Namespace %s has no hackathon-id label, skipping", nsName)
        return reconcile.Result{}, nil
    }

    // Define resource quota for hackathon namespaces: 2 CPU, 4Gi RAM, 10 pods max
    quotaName := fmt.Sprintf("hackathon-quota-%s", hackathonID)
    quota := &corev1.ResourceQuota{
        ObjectMeta: metav1.ObjectMeta{
            Name:      quotaName,
            Namespace: nsName,
            Labels: map[string]string{
                "hackathon-id": hackathonID,
                "managed-by":   "hackathon-operator",
            },
        },
        Spec: corev1.ResourceQuotaSpec{
            Hard: corev1.ResourceList{
                corev1.ResourceRequestsCPU:    resource.MustParse("2"),
                corev1.ResourceRequestsMemory: resource.MustParse("4Gi"),
                corev1.ResourceLimitsCPU:      resource.MustParse("4"),
                corev1.ResourceLimitsMemory:   resource.MustParse("8Gi"),
                corev1.ResourcePods:           resource.MustParse("10"),
            },
        },
    }

    // Create or update resource quota
    existingQuota := &corev1.ResourceQuota{}
    err := r.Client.Get(ctx, client.ObjectKey{Name: quotaName, Namespace: nsName}, existingQuota)
    if err != nil && errors.IsNotFound(err) {
        log.Printf("Creating resource quota %s in namespace %s", quotaName, nsName)
        if err := r.Client.Create(ctx, quota); err != nil {
            log.Printf("Failed to create quota: %v", err)
            return reconcile.Result{}, err
        }
    } else if err != nil {
        log.Printf("Failed to get existing quota: %v", err)
        return reconcile.Result{}, err
    } else {
        // Update existing quota if spec changed
        if existingQuota.Spec.Hard.Cpu().Cmp(*quota.Spec.Hard.Cpu()) != 0 {
            log.Printf("Updating resource quota %s", quotaName)
            existingQuota.Spec = quota.Spec
            if err := r.Client.Update(ctx, existingQuota); err != nil {
                log.Printf("Failed to update quota: %v", err)
                return reconcile.Result{}, err
            }
        }
    }

    // Add finalizer to namespace to clean up resources on deletion
    finalizerName := "hackathon.operator.io/finalizer"
    if !containsString(ns.Finalizers, finalizerName) {
        ns.Finalizers = append(ns.Finalizers, finalizerName)
        if err := r.Client.Update(ctx, &ns); err != nil {
            log.Printf("Failed to add finalizer: %v", err)
            return reconcile.Result{}, err
        }
    }

    // Requeue every 5 minutes to ensure state consistency
    return reconcile.Result{RequeueAfter: 5 * time.Minute}, nil
}

func containsString(slice []string, s string) bool {
    for _, item := range slice {
        if item == s {
            return true
        }
    }
    return false
}

func getK8sConfig() (*rest.Config, error) {
    // Use in-cluster config if running in K8s, else use kubeconfig
    if os.Getenv("KUBERNETES_SERVICE_HOST") != "" {
        return rest.InClusterConfig()
    }
    kubeconfig := os.Getenv("KUBECONFIG")
    if kubeconfig == "" {
        kubeconfig = os.Getenv("HOME") + "/.kube/config"
    }
    return clientcmd.BuildConfigFromFlags("", kubeconfig)
}

func main() {
    config, err := getK8sConfig()
    if err != nil {
        log.Fatalf("Failed to get K8s config: %v", err)
    }

    // Create controller-runtime client
    scheme := runtime.NewScheme()
    corev1.AddToScheme(scheme)

    cl, err := client.New(config, client.Options{Scheme: scheme})
    if err != nil {
        log.Fatalf("Failed to create client: %v", err)
    }

    // Create Kubernetes clientset for raw API access
    clientset, err := kubernetes.NewForConfig(config)
    if err != nil {
        log.Fatalf("Failed to create clientset: %v", err)
    }

    // Create manager
    mgr, err := manager.New(config, manager.Options{Scheme: scheme})
    if err != nil {
        log.Fatalf("Failed to create manager: %v", err)
    }

    // Register reconciler
    err = builder.ControllerManagedBy(mgr).
        For(&corev1.Namespace{}).
        Complete(&HackathonNamespaceReconciler{
            Client: cl,
            Scheme: scheme,
            K8s:    clientset,
        })
    if err != nil {
        log.Fatalf("Failed to register controller: %v", err)
    }

    log.Println("Starting hackathon namespace operator...")
    if err := mgr.Start(context.Background()); err != nil {
        log.Fatalf("Manager failed: %v", err)
    }
}

Case Study: Hackathon Project Reduces Checkout Latency by 62%

• Team size: 3 backend engineers, 1 frontend engineer
• Stack & Versions: Go 1.21, PostgreSQL 15, Redis 7.2, React 18, Gin v1.9.1 (HTTP framework), pgx v5.4.3 (Postgres driver)
• Problem: Pre-hackathon checkout service p99 latency was 2.8s, with 12% of requests timing out during peak traffic (Black Friday 2022 saw 18% cart abandonment due to slow checkout)
• Solution & Implementation: Team built a cached checkout session service using Redis for hot sessions, batched Postgres queries for inventory checks, and added Gin middleware for request tracing. They validated the solution against production traffic replicas during the 48-hour hackathon.
• Outcome: Post-hackathon checkout p99 latency dropped to 1.06s, timeout rate fell to 0.3%, cart abandonment decreased by 9%, saving an estimated $27k/month in recovered revenue. The project was promoted to full production 3 weeks after the hackathon.

Developer Tips for High-Impact Hackathons

1. Align Hackathons with OKRs to Avoid Innovation Theater

One of the biggest mistakes we made in our first ad-hoc hackathon was allowing teams to work on completely unrelated projects: we had 12 projects, only 1 of which aligned with our quarterly OKRs, and zero made it to production. To fix this, we now require all hackathon projects to map to at least one company OKR, validated via a pre-submission checklist using Pydantic v2.4.0 to enforce schema compliance. This small change increased post-hackathon production adoption from 8% to 67% in one quarter. When teams know their work ladders up to organizational goals, they’re more likely to get stakeholder buy-in for full production rollout, and leadership is more willing to allocate resources to polish hackathon prototypes. We also publish a list of "priority problem statements" 2 weeks before each hackathon, sourced directly from product and engineering leadership, so teams can prep ideas that solve real, high-value problems. Avoid the trap of "cool but useless" projects: a hackathon project that reduces checkout latency by 1s is 100x more valuable than a VR office tour, even if the latter is more fun to build. We measure alignment via a simple 1-5 score assigned by a panel of engineering managers, and only projects with a score of 3+ get access to production deployment pipelines post-hackathon.

from pydantic import BaseModel, Field, validator
from typing import List, Optional

class HackathonProjectOKRAlignment(BaseModel):
    project_name: str
    okr_ids: List[str] = Field(..., min_items=1, description="At least one OKR ID required")
    problem_statement: str = Field(..., min_length=50, description="Must be 50+ chars")
    alignment_score: Optional[int] = Field(None, ge=1, le=5)

    @validator("okr_ids")
    def validate_okr_format(cls, v):
        for okr in v:
            if not okr.startswith("OKR-"):
                raise ValueError(f"OKR {okr} must start with OKR-")
        return v

# Example valid submission
project = HackathonProjectOKRAlignment(
    project_name="Checkout Latency Reduction",
    okr_ids=["OKR-2023Q1-ENG-04"],
    problem_statement="Reduce checkout p99 latency from 2.8s to <1.5s to decrease cart abandonment"
)
print(project.dict())

2. Use Pre-Approved Cloud Credit Pools to Remove Friction

Nothing kills hackathon momentum faster than a team waiting 4 hours for a $50 AWS credit approval to test their prototype. In our first hackathon, 30% of teams reported that cloud resource approval delays caused them to miss their prototype deadline. We solved this by creating a pre-funded, isolated AWS account with $20k/quarter in credits, accessible via a self-service CLI tool built on the AWS CLI v2.13.0. Teams can spin up EC2 instances, RDS databases, or Lambda functions without approval, with hard resource limits (max 4 vCPUs, 8Gi RAM per team) to prevent overuse. We also pre-provisioned common services: a shared Redis cluster, a PostgreSQL read replica, and a container registry, so teams don’t waste time setting up boilerplate infrastructure. This reduced time spent on infra setup from 6 hours to 45 minutes per team, freeing up more time for core product work. We audit usage weekly, and teams that exceed limits get a warning before being throttled. For teams using GCP or Azure, we have equivalent pre-funded accounts, all managed via Terraform v1.6.0 to ensure consistent configuration across clouds. The key here is to treat hackathon infra as a product: if it’s hard to use, teams won’t use it, and your innovation output will suffer. We also provide a 1-page "quick start" guide with copy-paste commands for common setups, which reduced infra-related support tickets by 82%.

# Self-service script to spin up a hackathon Redis instance
aws redis create-replication-group \
    --replication-group-id hackathon-team-$(whoami) \
    --replication-group-description "Hackathon Redis instance" \
    --node-type cache.t3.micro \
    --num-cache-clusters 1 \
    --engine redis \
    --engine-version 7.2 \
    --security-group-ids sg-hackathon-redis \
    --cache-subnet-group-name hackathon-subnet \
    --tags Key=Hackathon,Value=2023Q1 Key=Team,Value=$(whoami)

3. Mandate Post-Hackathon Retrospectives with Action Items

A hackathon is wasted if you don’t learn from what worked and what didn’t. In our first two hackathons, we skipped retrospectives, and we repeated the same mistakes (poor infra, unclear judging criteria, no production path) for 3 cycles. Now, we mandate that every team submits a 1-page retrospective within 72 hours of the hackathon end, using mdBook v0.4.36 to generate a static site with all retrospectives, searchable by team and project. Each retro must include 2 things that went well, 2 things that went poorly, and 1 action item for the engineering org to improve the next hackathon. We review these in a public engineering all-hands, and assign action items to specific owners with deadlines. For example, after Q1 2023’s retro, we learned that 60% of teams struggled with production deployment, so we assigned our DevOps lead to create a "hackathon production playbook" by end of Q2, which reduced deployment time from 2 days to 4 hours. We also track whether action items are completed: 92% of retro action items were done in 2023, up from 0% when we didn’t have retros. Retrospectives aren’t just for teams: the hackathon organizing committee also runs a retro, and we publish a "hackathon improvement report" with metrics on participation, production rate, and action item completion. This transparency builds trust with engineers, who see that their feedback directly improves the program, leading to higher participation rates (up from 12% to 78% in 6 months).

# mdBook config for hackathon retrospectives (book.toml)
[book]
title = "2023 Q1 Hackathon Retrospectives"
authors = ["Engineering Team"]
language = "en"

[output.html]
theme = "light"
default-theme = "light"
preferred-dark-theme = "navy"

[output.html.search]
enable = true

[[output.html.additional-css]]
path = "custom.css"

Join the Discussion

We’ve shared our 18-month journey of building a structured hackathon program that delivered real, measurable innovation. Now we want to hear from you: what’s worked (or failed) in your organization’s innovation programs?

Discussion Questions

• By 2025, do you think OKR-aligned hackathons will replace traditional ad-hoc hackathons entirely, or is there still value in "free-form" innovation time?
• We spent $18k/quarter on hackathon prizes and catering, but saw no correlation between prize amount and project quality. Would you cut prize spend to fund more cloud credits, or keep prizes to drive participation?
• We used Linear to track hackathon projects, but some teams prefer GitHub Issues or Jira. Would switching to a single tool improve metrics, or does tool flexibility lead to higher participation?

Frequently Asked Questions

How do you measure "innovation output" to get the 30% number?

We define innovation output as the number of new experiments (features, tools, or services not in the current quarterly roadmap) that reach production within 90 days of the hackathon end. We track this via Linear issues labeled "hackathon-project" that transition to the "Production" workflow state. Pre-hackathon (Q2 2022), we averaged 4 such experiments per quarter. Post-hackathon (Q2 2023), we averaged 5.2 per quarter, which is a 30% lift. We exclude bug fixes, roadmap features, and internal tool updates from this count to ensure we’re only measuring net new innovation.

Did hackathons increase engineer burnout or overtime?

Quite the opposite: we tracked both Employee Net Promoter Score (eNPS) for engineering and average weekly overtime hours. Pre-hackathon, engineering eNPS was 22, and average weekly overtime was 4.2 hours. Post-hackathon, eNPS rose to 41, and overtime dropped to 2.1 hours per week. Hackathons are strictly optional, capped at 48 hours (Friday 6PM to Sunday 6PM), and we mandate 2 days of recovery time (no meetings, no deliverables) for all participants post-hackathon. We also ban work on hackathon projects outside of the 48-hour window to prevent creep.

What’s the minimum engineering team size to run a successful structured hackathon?

We recommend a minimum of 20 full-time engineers to reach critical mass: with our 42-person team, we average 10-12 teams per quarterly hackathon, which generates enough diverse project ideas to drive meaningful innovation. Teams smaller than 20 can partner with product, design, or data science teams to reach 20 total participants, or run bi-annual instead of quarterly hackathons to build up project pipelines. We’ve seen startups with 15 engineers run successful hackathons by inviting contractors and interns to participate, hitting 20 total participants.

Conclusion & Call to Action

After 18 months of running structured, OKR-aligned hackathons, we’re confident that the "innovation theater" criticism of hackathons is only valid for ad-hoc, unstructured programs. When you align projects to business goals, remove infra friction, and mandate retrospectives, hackathons deliver measurable ROI: we’ve seen a 30% lift in innovation output, 60% faster prototyping, and $142k in annual attributed revenue from hackathon-born features. Our recommendation to any engineering leader: replace your ad-hoc hackathons with a structured program in Q1 2024, track the metrics we outlined above, and iterate based on team feedback. The 30% innovation lift isn’t a fluke: it’s the result of treating hackathons as a product, not a one-off event.

30% Increase in production-ready innovation output in 6 months