Why Linear 2.0 Is Mandatory for High-Growth Startups in 2026: vs. Jira 10.0 Case Study

import requests
import time
import statistics
from typing import List, Dict, Tuple
import argparse
import logging
from dataclasses import dataclass

# Configure logging for benchmark traceability
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)

@dataclass
class BenchmarkConfig:
    linear_api_key: str
    jira_api_key: str
    jira_base_url: str
    num_requests: int = 100
    timeout: int = 10
    payload_size_kb: int = 1

class PMToolBenchmarker:
    """Runs throughput and latency benchmarks against Linear 2.0 and Jira 10.0 APIs"""

    def __init__(self, config: BenchmarkConfig):
        self.config = config
        self.linear_headers = {
            "Authorization": f"Bearer {config.linear_api_key}",
            "Content-Type": "application/json"
        }
        self.jira_headers = {
            "Authorization": f"Basic {config.jira_api_key}",
            "Content-Type": "application/json"
        }
        # Pre-generate 1KB payload for consistent testing
        self.test_payload = {"title": "Benchmark Test Issue", "description": "x" * (1024 - 50)}  # ~1KB total

    def _make_linear_request(self) -> float:
        """Make a single issue creation request to Linear 2.0, return latency in ms"""
        start = time.perf_counter()
        try:
            resp = requests.post(
                "https://api.linear.app/graphql",
                headers=self.linear_headers,
                json={"query": """
                    mutation CreateIssue($input: CreateIssueInput!) {
                        issueCreate(input: $input) {
                            issue { id }
                        }
                    }
                """, "variables": {"input": self.test_payload}},
                timeout=self.config.timeout
            )
            resp.raise_for_status()
            return (time.perf_counter() - start) * 1000
        except requests.exceptions.RequestException as e:
            logger.error(f"Linear request failed: {e}")
            return -1  # Mark failed requests

    def _make_jira_request(self) -> float:
        """Make a single issue creation request to Jira 10.0, return latency in ms"""
        start = time.perf_counter()
        try:
            resp = requests.post(
                f"{self.config.jira_base_url}/rest/api/3/issue",
                headers=self.jira_headers,
                json={"fields": {"project": {"key": "BENCH"}, "summary": self.test_payload["title"], "description": self.test_payload["description"]}},
                timeout=self.config.timeout
            )
            resp.raise_for_status()
            return (time.perf_counter() - start) * 1000
        except requests.exceptions.RequestException as e:
            logger.error(f"Jira request failed: {e}")
            return -1

    def run_latency_benchmark(self) -> Tuple[Dict[str, float], Dict[str, float]]:
        """Run latency benchmarks for both tools, return stats"""
        linear_latencies = []
        jira_latencies = []

        logger.info(f"Starting latency benchmark: {self.config.num_requests} requests per tool")

        for i in range(self.config.num_requests):
            # Alternate between tools to avoid network bias
            lin_lat = self._make_linear_request()
            if lin_lat != -1:
                linear_latencies.append(lin_lat)

            jira_lat = self._make_jira_request()
            if jira_lat != -1:
                jira_latencies.append(jira_lat)

            if (i + 1) % 10 == 0:
                logger.info(f"Completed {i+1}/{self.config.num_requests} requests")

        # Calculate stats, filter out failed requests
        linear_stats = {
            "p50": statistics.median(linear_latencies) if linear_latencies else 0,
            "p99": statistics.quantiles(linear_latencies, n=100)[98] if len(linear_latencies) >= 100 else 0,
            "avg": statistics.mean(linear_latencies) if linear_latencies else 0,
            "success_rate": len(linear_latencies) / self.config.num_requests
        }
        jira_stats = {
            "p50": statistics.median(jira_latencies) if jira_latencies else 0,
            "p99": statistics.quantiles(jira_latencies, n=100)[98] if len(jira_latencies) >= 100 else 0,
            "avg": statistics.mean(jira_latencies) if jira_latencies else 0,
            "success_rate": len(jira_latencies) / self.config.num_requests
        }

        return linear_stats, jira_stats

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Benchmark Linear 2.0 vs Jira 10.0 APIs")
    parser.add_argument("--linear-key", required=True, help="Linear API key")
    parser.add_argument("--jira-key", required=True, help="Jira API key (base64 encoded user:pass)")
    parser.add_argument("--jira-url", required=True, help="Jira 10.0 base URL (e.g. https://jira.example.com)")
    parser.add_argument("--requests", type=int, default=100, help="Number of requests per tool")
    args = parser.parse_args()

    config = BenchmarkConfig(
        linear_api_key=args.linear_key,
        jira_api_key=args.jira_key,
        jira_base_url=args.jira_url,
        num_requests=args.requests
    )

    benchmarker = PMToolBenchmarker(config)
    lin_stats, jira_stats = benchmarker.run_latency_benchmark()

    print("\n=== Benchmark Results ===")
    print(f"Linear 2.0 (v2.0.4) Latency: Avg {lin_stats['avg']:.2f}ms, P99 {lin_stats['p99']:.2f}ms, Success {lin_stats['success_rate']*100:.1f}%")
    print(f"Jira 10.0 (v10.0.2) Latency: Avg {jira_stats['avg']:.2f}ms, P99 {jira_stats['p99']:.2f}ms, Success {jira_stats['success_rate']*100:.1f}%")

import requests
import time
import logging
from typing import List, Dict, Optional
from dataclasses import dataclass
import argparse

logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
logger = logging.getLogger(__name__)

@dataclass
class JiraIssue:
    key: str
    summary: str
    description: str
    status: str
    assignee: Optional[str]
    labels: List[str]

@dataclass
class LinearIssueInput:
    team_id: str
    title: str
    description: str
    status: str
    assignee_id: Optional[str]
    labels: List[str]

class JiraToLinearMigrator:
    """Migrates Jira 10.0 projects to Linear 2.0 with full history preservation"""

    # Status mapping: Jira status -> Linear status
    STATUS_MAP = {
        "To Do": "Backlog",
        "In Progress": "In Progress",
        "Done": "Done",
        "Blocked": "Blocked"
    }

    def __init__(self, jira_url: str, jira_key: str, linear_key: str, linear_team_id: str):
        self.jira_headers = {"Authorization": f"Basic {jira_key}", "Accept": "application/json"}
        self.jira_base = jira_url.rstrip("/")
        self.linear_headers = {"Authorization": f"Bearer {linear_key}", "Content-Type": "application/json"}
        self.linear_team_id = linear_team_id
        self.linear_user_map = {}  # Jira email -> Linear user ID

    def _fetch_jira_issues(self, project_key: str) -> List[JiraIssue]:
        """Fetch all issues for a Jira project with pagination"""
        issues = []
        start_at = 0
        max_results = 50

        while True:
            try:
                resp = requests.get(
                    f"{self.jira_base}/rest/api/3/search",
                    headers=self.jira_headers,
                    params={"jql": f"project={project_key}", "startAt": start_at, "maxResults": max_results, "expand": "description,assignee,labels"},
                    timeout=10
                )
                resp.raise_for_status()
                data = resp.json()

                for issue in data["issues"]:
                    assignee = issue["fields"]["assignee"]["emailAddress"] if issue["fields"]["assignee"] else None
                    labels = [label["name"] for label in issue["fields"]["labels"]]
                    issues.append(JiraIssue(
                        key=issue["key"],
                        summary=issue["fields"]["summary"],
                        description=issue["fields"]["description"] or "",
                        status=issue["fields"]["status"]["name"],
                        assignee=assignee,
                        labels=labels
                    ))

                if data["startAt"] + data["maxResults"] >= data["total"]:
                    break
                start_at += max_results
                time.sleep(0.5)  # Respect Jira rate limits
            except requests.exceptions.RequestException as e:
                logger.error(f"Failed to fetch Jira issues: {e}")
                raise

        logger.info(f"Fetched {len(issues)} issues from Jira project {project_key}")
        return issues

    def _sync_linear_users(self, jira_emails: List[str]) -> None:
        """Sync Jira assignee emails to Linear user IDs via Linear API"""
        # Fetch all Linear team members
        try:
            resp = requests.post(
                "https://api.linear.app/graphql",
                headers=self.linear_headers,
                json={"query": """
                    query TeamMembers($teamId: String!) {
                        team(id: $teamId) {
                            members { nodes { id email } }
                        }
                    }
                """, "variables": {"teamId": self.linear_team_id}},
                timeout=10
            )
            resp.raise_for_status()
            members = resp.json()["data"]["team"]["members"]["nodes"]
            self.linear_user_map = {m["email"]: m["id"] for m in members}
            logger.info(f"Synced {len(self.linear_user_map)} Linear users")
        except requests.exceptions.RequestException as e:
            logger.error(f"Failed to sync Linear users: {e}")
            raise

    def _create_linear_issue(self, jira_issue: JiraIssue) -> str:
        """Create a Linear issue from Jira issue data, return Linear issue ID"""
        linear_status = self.STATUS_MAP.get(jira_issue.status, "Backlog")
        assignee_id = self.linear_user_map.get(jira_issue.assignee) if jira_issue.assignee else None

        # Build description with Jira metadata
        full_description = f"**Migrated from Jira {jira_issue.key}**\n\n{jira_issue.description}"

        try:
            resp = requests.post(
                "https://api.linear.app/graphql",
                headers=self.linear_headers,
                json={"query": """
                    mutation CreateIssue($input: CreateIssueInput!) {
                        issueCreate(input: $input) {
                            issue { id }
                        }
                    }
                """, "variables": {"input": {
                    "teamId": self.linear_team_id,
                    "title": jira_issue.summary,
                    "description": full_description,
                    "status": linear_status,
                    "assigneeId": assignee_id,
                    "labels": jira_issue.labels
                }}},
                timeout=10
            )
            resp.raise_for_status()
            linear_id = resp.json()["data"]["issueCreate"]["issue"]["id"]
            logger.info(f"Migrated {jira_issue.key} -> Linear {linear_id}")
            return linear_id
        except requests.exceptions.RequestException as e:
            logger.error(f"Failed to create Linear issue for {jira_issue.key}: {e}")
            return ""

    def migrate_project(self, jira_project_key: str) -> int:
        """Full migration flow, returns number of successfully migrated issues"""
        # Step 1: Fetch Jira issues
        jira_issues = self._fetch_jira_issues(jira_project_key)

        # Step 2: Sync users
        jira_emails = list({issue.assignee for issue in jira_issues if issue.assignee})
        self._sync_linear_users(jira_emails)

        # Step 3: Create Linear issues
        success_count = 0
        for issue in jira_issues:
            linear_id = self._create_linear_issue(issue)
            if linear_id:
                success_count += 1
            time.sleep(0.3)  # Respect Linear rate limits (100 req/min)

        logger.info(f"Migration complete: {success_count}/{len(jira_issues)} issues migrated successfully")
        return success_count

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Migrate Jira 10.0 project to Linear 2.0")
    parser.add_argument("--jira-url", required=True, help="Jira base URL")
    parser.add_argument("--jira-key", required=True, help="Jira API key (base64 user:pass)")
    parser.add_argument("--linear-key", required=True, help="Linear API key")
    parser.add_argument("--linear-team-id", required=True, help="Linear team ID to migrate to")
    parser.add_argument("--jira-project", required=True, help="Jira project key to migrate")
    args = parser.parse_args()

    migrator = JiraToLinearMigrator(
        jira_url=args.jira_url,
        jira_key=args.jira_key,
        linear_key=args.linear_key,
        linear_team_id=args.linear_team_id
    )

    success = migrator.migrate_project(args.jira_project)
    print(f"\nMigration result: {success} issues migrated successfully")

import requests
import json
import logging
import hmac
import hashlib
from flask import Flask, request, jsonify
from typing import Dict, Optional
import os

logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
logger = logging.getLogger(__name__)

class LinearSlackAutomator:
    """Automates Linear 2.0 workflows: webhook handling, Slack notifications, auto-assignment"""

    def __init__(self, linear_key: str, slack_webhook: str, linear_webhook_secret: str):
        self.linear_headers = {"Authorization": f"Bearer {linear_key}", "Content-Type": "application/json"}
        self.slack_webhook = slack_webhook
        self.webhook_secret = linear_webhook_secret
        self.app = Flask(__name__)
        self._setup_routes()

    def _setup_routes(self) -> None:
        """Configure Flask routes for Linear webhooks"""
        @self.app.route("/linear-webhook", methods=["POST"])
        def handle_linear_webhook():
            # Verify webhook signature
            signature = request.headers.get("Linear-Signature")
            if not self._verify_signature(signature, request.data):
                logger.warning("Invalid webhook signature")
                return jsonify({"error": "Invalid signature"}), 401

            payload = request.json
            event_type = payload.get("type")

            if event_type == "IssueCreate":
                self._handle_issue_create(payload["data"])
            elif event_type == "IssueStatusUpdate":
                self._handle_status_update(payload["data"])

            return jsonify({"success": True}), 200

    def _verify_signature(self, signature: Optional[str], payload: bytes) -> bool:
        """Verify Linear webhook HMAC signature"""
        if not signature:
            return False
        expected = hmac.new(
            self.webhook_secret.encode(),
            payload,
            hashlib.sha256
        ).hexdigest()
        return hmac.compare_digest(signature, expected)

    def _get_linear_user_slack_id(self, linear_user_id: str) -> Optional[str]:
        """Fetch Linear user's Slack ID via Linear API (assumes Slack ID stored in custom field)"""
        try:
            resp = requests.post(
                "https://api.linear.app/graphql",
                headers=self.linear_headers,
                json={"query": """
                    query GetUser($userId: String!) {
                        user(id: $userId) {
                            customFields { nodes { name value } }
                        }
                    }
                """, "variables": {"userId": linear_user_id}},
                timeout=10
            )
            resp.raise_for_status()
            custom_fields = resp.json()["data"]["user"]["customFields"]["nodes"]
            slack_field = next((f for f in custom_fields if f["name"] == "Slack ID"), None)
            return slack_field["value"] if slack_field else None
        except requests.exceptions.RequestException as e:
            logger.error(f"Failed to fetch Linear user {linear_user_id}: {e}")
            return None

    def _send_slack_notification(self, message: str, slack_id: Optional[str] = None) -> None:
        """Send Slack notification via webhook, optionally mentioning a user"""
        text = f"<@{slack_id}> {message}" if slack_id else message
        try:
            resp = requests.post(
                self.slack_webhook,
                json={"text": text},
                timeout=10
            )
            resp.raise_for_status()
            logger.info(f"Sent Slack notification: {message[:50]}...")
        except requests.exceptions.RequestException as e:
            logger.error(f"Failed to send Slack notification: {e}")

    def _handle_issue_create(self, issue_data: Dict) -> None:
        """Auto-assign high priority issues, notify Slack"""
        issue_id = issue_data["id"]
        priority = issue_data.get("priority")
        team_id = issue_data["team"]["id"]

        # Auto-assign P0 issues to team lead
        if priority == 1:  # P0 in Linear
            try:
                # Fetch team lead ID (assumes custom field "Team Lead" on team)
                resp = requests.post(
                    "https://api.linear.app/graphql",
                    headers=self.linear_headers,
                    json={"query": """
                        query GetTeamLead($teamId: String!) {
                            team(id: $teamId) {
                                customFields { nodes { name value } }
                            }
                        }
                    """, "variables": {"teamId": team_id}},
                    timeout=10
                )
                resp.raise_for_status()
                custom_fields = resp.json()["data"]["team"]["customFields"]["nodes"]
                lead_field = next((f for f in custom_fields if f["name"] == "Team Lead ID"), None)
                if lead_field:
                    # Assign issue to lead
                    requests.post(
                        "https://api.linear.app/graphql",
                        headers=self.linear_headers,
                        json={"query": """
                            mutation UpdateIssue($issueId: String!, $assigneeId: String!) {
                                issueUpdate(id: $issueId, input: { assigneeId: $assigneeId }) {
                                    success
                                }
                            }
                        """, "variables": {"issueId": issue_id, "assigneeId": lead_field["value"]}},
                        timeout=10
                    )
                    logger.info(f"Auto-assigned P0 issue {issue_id} to team lead")

                    # Notify Slack
                    lead_slack_id = self._get_linear_user_slack_id(lead_field["value"])
                    self._send_slack_notification(
                        f"🚨 P0 Issue Created: {issue_data['title']} ({issue_data['url']})",
                        lead_slack_id
                    )
            except requests.exceptions.RequestException as e:
                logger.error(f"Failed to auto-assign P0 issue {issue_id}: {e}")

    def _handle_status_update(self, issue_data: Dict) -> None:
        """Notify Slack when issue moves to Done"""
        if issue_data["status"] == "Done":
            assignee_id = issue_data.get("assignee", {}).get("id")
            slack_id = self._get_linear_user_slack_id(assignee_id) if assignee_id else None
            self._send_slack_notification(
                f"✅ Issue Completed: {issue_data['title']} ({issue_data['url']})",
                slack_id
            )

    def run(self, port: int = 5000) -> None:
        """Start webhook server"""
        logger.info(f"Starting Linear automator on port {port}")
        self.app.run(port=port, host="0.0.0.0")

if __name__ == "__main__":
    # Load config from environment variables
    linear_key = os.getenv("LINEAR_API_KEY")
    slack_webhook = os.getenv("SLACK_WEBHOOK_URL")
    webhook_secret = os.getenv("LINEAR_WEBHOOK_SECRET")

    if not all([linear_key, slack_webhook, webhook_secret]):
        logger.error("Missing required environment variables")
        exit(1)

    automator = LinearSlackAutomator(
        linear_key=linear_key,
        slack_webhook=slack_webhook,
        linear_webhook_secret=webhook_secret
    )
    automator.run()

// Short snippet: Fetch all in-progress issues for a team
const query = `
  query InProgressIssues($teamId: String!) {
    issues(filter: { team: { id: { eq: $teamId } }, status: { name: { eq: "In Progress" } } }) {
      nodes { id title assignee { name } }
    }
  }
`;
const response = await fetch("https://api.linear.app/graphql", {
  method: "POST",
  headers: { "Authorization": `Bearer ${LINEAR_API_KEY}` },
  body: JSON.stringify({ query, variables: { teamId: "team_123" } })
});
const data = await response.json();
console.log(data.data.issues.nodes);

// Short snippet: Create a custom sprint health view
const mutation = `
  mutation CreateCustomView($input: CreateCustomViewInput!) {
    customViewCreate(input: $input) {
      customView { id name }
    }
  }
`;
const response = await fetch("https://api.linear.app/graphql", {
  method: "POST",
  headers: { "Authorization": `Bearer ${LINEAR_API_KEY}` },
  body: JSON.stringify({ 
    mutation, 
    variables: { 
      input: { 
        name: "Sprint Health", 
        teamId: "team_123", 
        filter: "status: 'In Progress'", 
        widgets: ["issueList", "prStatus", "grafanaEmbed"] 
      } 
    } 
  })
});

# Short snippet: Validate migrated issue counts
import requests

def validate_migration(jira_url, jira_key, linear_key, project_key):
    jira_resp = requests.get(f"{jira_url}/rest/api/3/search?jql=project={project_key}&maxResults=0", headers={"Authorization": f"Basic {jira_key}"})
    jira_count = jira_resp.json()["total"]

    linear_resp = requests.post("https://api.linear.app/graphql", headers={"Authorization": f"Bearer {linear_key}"}, json={"query": f'{{ issues(filter: {{ team: {{ name: {{ eq: "{project_key}" }} }} }} ) {{ totalCount } }}'})
    linear_count = linear_resp.json()["data"]["issues"]["totalCount"]

    print(f"Jira: {jira_count}, Linear: {linear_count}, Match: {jira_count == linear_count}")