Case Study Monday.com vs HubSpot: What You Need to Know

#!/usr/bin/env python3
"""
Benchmark script: Monday.com vs HubSpot API latency comparison.
Hardware: AWS t3.medium (2 vCPU, 4 GB RAM), us-east-1
Python: 3.11.6
Monday SDK: pip install monday 4.2.1
HubSpot SDK: pip install hubspot-api-client 8.2.0
"""
import time
import statistics
import monday
from hubspot import HubSpot
from hubspot.crm.contacts import SimplePublicObjectInput

# --- Configuration ---
MONDAY_API_KEY = "YOUR_MONDEY_API_KEY"
HUBSPOT_API_KEY = "YOUR_HUBSPOT_API_KEY"
NUM_RECORDS = 500
RUNS = 5

# --- Monday.com Client ---
mon_client = monday.MondayClient(api_key=MONDAY_API_KEY)

# --- HubSpot Client ---
hub_client = HubSpot(api_key=HUBSPOT_API_KEY)


def benchmark_monday():
    """Create, read, update, delete NUM_RECORDS items on Monday.com."""
    latencies = {"create": [], "read": [], "update": [], "delete": []}
    board_id = 123456789  # Replace with your test board
    group_id = "new_group123"

    for run in range(RUNS):
        item_ids = []

        # CREATE phase
        start = time.perf_counter()
        for i in range(NUM_RECORDS):
            try:
                resp = mon_client.items.create_item(
                    board_id=board_id,
                    group_id=group_id,
                    item_name=f"Benchmark Item {i}-{run}",
                    column_values={}
                )
                item_ids.append(resp["data"]["create_item"]["id"])
            except monday.MondayError as e:
                print(f"Monday create error: {e}")
                continue
        create_time = time.perf_counter() - start
        latencies["create"].append(create_time / NUM_RECORDS)

        # READ phase — query all created items
        start = time.perf_counter()
        for item_id in item_ids:
            try:
                mon_client.items.fetch_items_by_id(item_id=item_id)
            except monday.MondayError as e:
                print(f"Monday read error for {item_id}: {e}")
                continue
        read_time = time.perf_counter() - start
        latencies["read"].append(read_time / NUM_RECORDS)

        # UPDATE phase
        start = time.perf_counter()
        for item_id in item_ids:
            try:
                mon_client.items.update_item(
                    item_id=int(item_id),
                    column_values='{"status": {"index": 1}}'
                )
            except monday.MondayError as e:
                print(f"Monday update error for {item_id}: {e}")
                continue
        update_time = time.perf_counter() - start
        latencies["update"].append(update_time / NUM_RECORDS)

        # DELETE phase
        start = time.perf_counter()
        for item_id in item_ids:
            try:
                mon_client.items.delete_item(item_id=int(item_id))
            except monday.MondayError as e:
                print(f"Monday delete error for {item_id}: {e}")
                continue
        delete_time = time.perf_counter() - start
        latencies["delete"].append(delete_time / NUM_RECORDS)

    return {k: statistics.median(v) for k, v in latencies.items()}


def benchmark_hubspot():
    """Create, read, update, delete NUM_RECORDS contacts on HubSpot."""
    latencies = {"create": [], "read": [], "update": [], "delete": []}

    for run in range(RUNS):
        contact_ids = []

        # CREATE phase
        start = time.perf_counter()
        for i in range(NUM_RECORDS):
            try:
                resp = hub_client.crm.contacts.basic_api.create(
                    SimplePublicObjectInput(
                        properties={
                            "email": f"bench{i}_{run}@example.com",
                            "firstname": f"Bench",
                            "lastname": f"User{i}"
                        }
                    )
                )
                contact_ids.append(resp.id)
            except Exception as e:
                print(f"HubSpot create error: {e}")
                continue
        create_time = time.perf_counter() - start
        latencies["create"].append(create_time / NUM_RECORDS)

        # READ phase
        start = time.perf_counter()
        for cid in contact_ids:
            try:
                hub_client.crm.contacts.basic_api.get_by_id(cid)
            except Exception as e:
                print(f"HubSpot read error for {cid}: {e}")
                continue
        read_time = time.perf_counter() - start
        latencies["read"].append(read_time / NUM_RECORDS)

        # UPDATE phase
        start = time.perf_counter()
        for cid in contact_ids:
            try:
                hub_client.crm.contacts.basic_api.update(
                    cid,
                    SimplePublicObjectInput(
                        properties={"hs_lead_status": "qualified"}
                    )
                )
            except Exception as e:
                print(f"HubSpot update error for {cid}: {e}")
                continue
        update_time = time.perf_counter() - start
        latencies["update"].append(update_time / NUM_RECORDS)

        # DELETE phase
        start = time.perf_counter()
        for cid in contact_ids:
            try:
                hub_client.crm.contacts.basic_api.archive(cid)
            except Exception as e:
                print(f"HubSpot archive error for {cid}: {e}")
                continue
        delete_time = time.perf_counter() - start
        latencies["delete"].append(delete_time / NUM_RECORDS)

    return {k: statistics.median(v) for k, v in latencies.items()}


if __name__ == "__main__":
    print("Running Monday.com benchmark...")
    mon_results = benchmark_monday()
    print(f"Monday.com per-record latency (seconds): {mon_results}")

    print("\nRunning HubSpot benchmark...")
    hub_results = benchmark_hubspot()
    print(f"HubSpot per-record latency (seconds): {hub_results}")

    print("\n--- Summary ---")
    for op in ["create", "read", "update", "delete"]:
        diff = ((hub_results[op] - mon_results[op]) / mon_results[op]) * 100
        print(f"{op.title()}: Monday={mon_results[op]:.4f}s, "
              f"HubSpot={hub_results[op]:.4f}s, "
              f"Delta={diff:+.1f}%")

/**
 * Migration script: Monday.com items → HubSpot contacts.
 * Handles pagination, rate limiting, retry with exponential backoff,
 * and dry-run mode for safe validation.
 *
 * Prerequisites:
 *   npm install @mondaycom/monday-sdk hubspot-api-client dotenv
 *   Node.js >= 18.0.0
 *
 * Usage:
 *   DRY_RUN=true node migrate.js
 *   node migrate.js
 */
require('dotenv').config();
const MondayClient = require('@mondaycom/monday-sdk');
const { HubSpot } = require('hubspot-api-client');

const monday = new MondayClient({ apiKey: process.env.MONDAY_API_KEY });
const hubspot = new HubSpot({ apiKey: process.env.HUBSPOT_API_KEY });

const BOARD_ID = parseInt(process.env.MONDAY_BOARD_ID, 10);
const DRY_RUN = process.env.DRY_RUN === 'true';
const PAGE_SIZE = 100;
const MAX_RETRIES = 5;
const BASE_DELAY_MS = 1000;

/**
 * Generic retry wrapper with exponential backoff.
 * Retries on 429 (rate limit) and 5xx (server errors).
 */
async function retry(fn, retries = MAX_RETRIES, delay = BASE_DELAY_MS) {
  for (let attempt = 1; attempt <= retries; attempt++) {
    try {
      return await fn();
    } catch (err) {
      const status = err.response?.status || err.statusCode || 0;
      const isRetryable = status === 429 || (status >= 500 && status < 600);
      if (!isRetryable || attempt === retries) throw err;
      const waitMs = delay * Math.pow(2, attempt - 1);
      console.warn(`Attempt ${attempt} failed (status ${status}). Retrying in ${waitMs}ms...`);
      await new Promise(resolve => setTimeout(resolve, waitMs));
    }
  }
}

/**
 * Fetch all items from a Monday.com board using cursor-based pagination.
 * Returns a flat array of item objects with column values.
 */
async function fetchAllMondayItems(boardId) {
  const items = [];
  let cursor = null;
  let page = 0;

  do {
    const query = `
      query ($boardId: Int!, $cursor: String, $limit: Int) {
        boards(ids: [$boardId]) {
          items_page(limit: $limit, cursor: $cursor) {
            cursor
            items {
              id
              name
              column_values {
                id
                title
                text
                type
              }
            }
          }
        }
      }
    `;
    const result = await retry(() =>
      monday.graphql({ query, variables: { boardId, cursor, limit: PAGE_SIZE } })
    );

    const pageItems = result.boards[0].items_page.items;
    items.push(...pageItems);
    cursor = result.boards[0].items_page.cursor;
    page++;
    console.log(`Fetched page ${page}: ${pageItems.length} items (total: ${items.length})`);
  } while (cursor);

  return items;
}

/**
 * Convert Monday.com item column values into HubSpot contact properties.
 * Maps common column types (email, phone, status, date) to HubSpot schema.
 */
function mapToHubSpotProperties(item) {
  const props = {
    firstname: item.name.split(' ')[0] || 'Unknown',
    lastname: item.name.split(' ').slice(1).join(' ') || item.id,
  };

  for (const col of item.column_values) {
    switch (col.title.toLowerCase()) {
      case 'email':
        if (col.text && col.text.includes('@')) props.email = col.text;
        break;
      case 'phone':
        if (col.text) props.phone = col.text;
        break;
      case 'company':
        if (col.text) props.company = col.text;
        break;
      case 'status':
        if (col.text) {
          // Map Monday statuses to HubSpot lifecycle stages
          const statusMap = {
            'new': 'subscriber',
            'in progress': 'mql',
            'done': 'sql',
          };
          props.hs_lead_status = col.text;
          props.lifecyclestage = statusMap[col.text.toLowerCase()] || 'lead';
        }
        break;
      case 'date':
        if (col.text) props.createdate = col.text;
        break;
      default:
        break;
    }
  }
  return props;
}

/**
 * Create or update a contact in HubSpot.
 * Uses email as the dedup key — upserts if email exists, creates otherwise.
 */
async function upsertHubSpotContact(properties) {
  if (!properties.email) {
    console.warn(`Skipping contact without email: ${properties.firstname} ${properties.lastname}`);
    return { status: 'skipped', reason: 'no_email' };
  }

  const searchUrl = `https://api.hubapi.com/crm/v3/objects/contacts/search`;
  const searchBody = {
    filterGroups: [{
      filters: [{ propertyName: 'email', operator: 'EQ', value: properties.email }]
    }]
  };

  try {
    const searchResult = await retry(() =>
      hubspot.crm.contacts.searchApi.doSearch(properties.email)
    );

    if (searchResult.total > 0) {
      const existingId = searchResult.results[0].id;
      if (DRY_RUN) {
        console.log(`[DRY RUN] Would update HubSpot contact ${existingId}: ${properties.email}`);
        return { status: 'would_update', id: existingId };
      }
      await hubspot.crm.contacts.basicApi.update(existingId, {
        properties: properties
      });
      return { status: 'updated', id: existingId };
    } else {
      if (DRY_RUN) {
        console.log(`[DRY RUN] Would create HubSpot contact: ${properties.email}`);
        return { status: 'would_create' };
      }
      const created = await hubspot.crm.contacts.basicApi.create({
        properties: properties
      });
      return { status: 'created', id: created.id };
    }
  } catch (err) {
    console.error(`Failed to upsert ${properties.email}: ${err.message}`);
    return { status: 'error', reason: err.message };
  }
}

/**
 * Main migration pipeline.
 * Fetches from Monday, maps to HubSpot schema, upserts with rate-limit awareness.
 */
async function main() {
  console.log(`=== Monday.com → HubSpot Migration ===`);
  console.log(`Board: ${BOARD_ID}, Dry Run: ${DRY_RUN}`);

  const items = await fetchAllMondayItems(BOARD_ID);
  console.log(`\nTotal items to migrate: ${items.length}`);

  let stats = { created: 0, updated: 0, skipped: 0, errors: 0 };

  for (let i = 0; i < items.length; i++) {
    const props = mapToHubSpotProperties(items[i]);
    const result = await upsertHubSpotContact(props);

    if (result.status === 'created' || result.status === 'would_create') stats.created++;
    else if (result.status === 'updated' || result.status === 'would_update') stats.updated++;
    else if (result.status === 'skipped') stats.skipped++;
    else stats.errors++;

    // Rate limit throttle: ~10 requests/second for HubSpot private apps
    if (i < items.length - 1) await new Promise(r => setTimeout(r, 150));

    if ((i + 1) % 100 === 0) {
      console.log(`Progress: ${i + 1}/${items.length} (${((i + 1) / items.length * 100).toFixed(1)}%)`);
    }
  }

  console.log(`\n=== Migration Complete ===`);
  console.log(`Created: ${stats.created} | Updated: ${stats.updated} | Skipped: ${stats.skipped} | Errors: ${stats.errors}`);
}

main().catch(err => {
  console.error('Fatal error:', err);
  process.exit(1);
});

/**
 * Webhook bridge: HubSpot → Monday.com bidirectional sync.
 * Deployed as AWS Lambda behind API Gateway.
 * Handles HubSpot contact creation/update events and mirrors
 * changes to Monday.com.
 *
 * Environment variables:
 *   MONDAY_API_KEY, MONDAY_BOARD_ID, MONDAY_GROUP_ID
 *   HUBSPOT_CLIENT_SECRET (for signature verification)
 */
const crypto = require('crypto');
const https = require('https');

const MONDAY_BOARD_ID = process.env.MONDAY_BOARD_ID;
const MONDAY_GROUP_ID = process.env.MONDAY_GROUP_ID;
const HUBSPOT_SECRET = process.env.HUBSPOT_CLIENT_SECRET;

/**
 * Verify HubSpot webhook signature to prevent spoofing.
 * HubSpot signs the payload with HMAC-SHA256.
 */
function verifyHubSpotSignature(body, signature) {
  const expected = crypto
    .createHmac('sha256', HUBSPOT_SECRET)
    .update(body)
    .digest('hex');
  return crypto.timingSafeEqual(Buffer.from(expected), Buffer.from(signature));
}

/**
 * Promisified HTTPS request for Monday.com GraphQL mutations.
 */
function mondayGraphQL(query, variables, apiKey) {
  return new Promise((resolve, reject) => {
    const payload = JSON.stringify({ query, variables });
    const options = {
      hostname: 'api.monday.com',
      path: '/v2',
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': apiKey,
        'Content-Length': Buffer.byteLength(payload)
      },
      timeout: 10000
    };

    const req = https.request(options, (res) => {
      let data = '';
      res.on('data', chunk => data += chunk);
      res.on('end', () => {
        try { resolve(JSON.parse(data)); } catch (e) { reject(e); }
      });
    });

    req.on('error', reject);
    req.on('timeout', () => { req.destroy(); reject(new Error('Request timeout')); });
    req.write(payload);
    req.end();
  });
}

/**
 * AWS Lambda handler for HubSpot webhook events.
 */
exports.handler = async (event) => {
  // Verify signature
  const signature = event.headers['x-hubspot-signature-v3'];
  if (!signature || !verifyHubSpotSignature(event.body, signature)) {
    console.error('Signature verification failed');
    return { statusCode: 403, body: 'Forbidden' };
  }

  const hubEvent = JSON.parse(event.body);

  // Handle subscription validation challenge
  if (hubEvent.challenge) {
    return { statusCode: 200, body: hubEvent.challenge };
  }

  let processed = 0;
  let errors = 0;

  for (const record of hubEvent) {
    try {
      const email = record.propertyValues?.email || '';
      const firstName = record.propertyValues?.firstname || '';
      const lastName = record.propertyValues?.lastname || '';
      const lifecycleStage = record.propertyValues?.lifecyclestage || 'lead';

      // Upsert into Monday.com
      const mutation = `
        mutation ($email: String!, $firstName: String!, $lastName: String!, $status: String!) {
          create_item(
            board_id: ${MONDAY_BOARD_ID},
            group_id: "${MONDAY_GROUP_ID}",
            item_name: $firstName,
            column_values: "{
              \"email6\": \"${email}\",
              \"text9__1\": \"${lastName}\",
              \"status8\": \"${lifecycleStage}\"
            }"
          ) { id }
        }
      `;

      await mondayGraphQL(mutation, {}, process.env.MONDAY_API_KEY);
      processed++;
    } catch (err) {
      console.error(`Failed to sync record: ${err.message}`);
      errors++;
    }
  }

  return {
    statusCode: 200,
    body: JSON.stringify({ processed, errors })
  };
};

# Fetch sprint data from multiple boards in one request
query SprintDashboard {
  board1: boards(ids: [111]) {
    items_page(limit: 100, sort: {columnId: "date4", direction: desc}) {
      items {
        name
        column_values(ids: ["status", "date4", "text"]) {
          title text
        }
      }
    }
  }
  board2: boards(ids: [222]) {
    items_page(limit: 100) {
      items {
        name
        column_values(ids: ["status", "priority"]) {
          title text
        }
      }
    }
  }
}

// HubSpot custom-coded action: enrich contact with Clearbit data
const axios = require('axios');

exports.main = async (event) => {
  const { email } = event.inputFields;

  try {
    const response = await axios.get(
      `https://person.clearbit.com/v2/people/find?email=${encodeURIComponent(email)}`,
      {
        headers: { 'Authorization': `Bearer ${process.env.CLEARBIT_KEY}` },
        timeout: 5000
      }
    );

    const data = response.data;
    return {
      outputFields: {
        company_name: data.employment?.name || 'Unknown',
        company_size: data.employment?.size || '',
        industry: data.employment?.industry || '',
        enrichment_score: data.score || 0
      }
    };
  } catch (error) {
    console.error(`Clearbit enrichment failed for ${email}:`, error.message);
    throw new Error('ENRICHMENT_FAILED');
  }
};

import redis
import hashlib
import json

r = redis.Redis(host='localhost', port=6379, db=0)
DEDUP_TTL_SECONDS = 172800  # 48 hours


def is_duplicate(platform: str, event_id: str) -> bool:
    """Check and mark event as processed. Returns True if duplicate."""
    key = f"webhook_dedup:{platform}:{hashlib.sha256(event_id.encode()).hexdigest()}"
    # SET NX = only set if not exists; returns True if key was new
    was_new = r.set(key, 1, nx=True, ex=DEDUP_TTL_SECONDS)
    return not was_new


# Usage in webhook handler:
def handle_monday_webhook(payload: dict) -> dict:
    event_id = payload.get('event_id', '')
    if is_duplicate('monday', event_id):
        return {'status': 'ignored', 'reason': 'duplicate'}
    # Process event...
    return {'status': 'processed'}


def handle_hubspot_webhook(payload: dict, signature: str) -> dict:
    # Verify signature first, then dedup
    event_id = payload.get('webhookId', '')
    if is_duplicate('hubspot', event_id):
        return {'status': 'ignored', 'reason': 'duplicate'}
    # Process event...
    return {'status': 'processed'}