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

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)
    }
}

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())

# 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)

# 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"