HubSpot + Jira: Why the Native Integration Does Not Work for Deals

The native HubSpot and Jira integration exists — it is available in HubSpot Marketplace. But it solves the wrong problem. The integration was built for Customer Support: it links HubSpot Tickets with Jira Issues. The sales process — handing off a client after Closed Won to the implementation team via Jira — is not covered by the native integration. Companies install it, discover the gaps, and either work around it manually or move to a custom API-based integration.

What Breaks in the Native Integration

Deals do not integrate with Jira — only Tickets. The native integration links Jira Issues with HubSpot Tickets, not Deals. The client handoff process at Closed Won runs through a Deal — not a Ticket. To use the native integration, a Ticket must be manually created from the Deal, then wait for a Jira Issue to be created. This is an extra step that teams avoid — and the handoff becomes manual again.

Status synchronizes in only one direction. The official HubSpot documentation confirms: ticket status synchronizes only from Jira to HubSpot, not the other way around. When a manager closes a Deal as Closed Won, Jira is not automatically notified. When the dev team closes a task in Jira as Done, the HubSpot Deal is not updated — only if separate automation has been added.

Custom fields are not synchronized. The client’s tech stack, integration requirements, SLA, onboarding type — all of this is stored in custom Deal fields in HubSpot. When creating a Jira Issue through the native integration, these fields are not passed. The dev team receives a task without context and must ask for the data manually.

Jira Server and Data Center are not supported. The native integration only works with Jira Cloud. Companies on Jira Server or Data Center (self-hosted) get “Not supported” when trying to connect.

Attachments are not synchronized. Technical documentation, NDAs, spec files from HubSpot do not automatically appear in Jira.

What Is Actually Needed for the Client Handoff Process

A correct client handoff at Closed Won includes:

Creating a Jira Epic or Task with complete client data
Description: plan tier, tech stack, primary contact, SLA, timeline
Labels and Priority based on the tier (Enterprise -> Priority: High)
Notification to the responsible person in the dev/CS team
When Jira transitions to Done: updating HubSpot Deal Stage or creating an Activity

The native integration covers 0 of 5 items for a Deal-centric process.

The Right Approach: Custom Integration via API

HubSpot -> Jira on Closed Won:

# HubSpot Webhook: deal.propertyChange, hs_deal_stage_probability = 1.0 (Closed Won)
def on_deal_closed_won(deal_id: str):
    # 1. Get deal data
    deal = hubspot_get_deal(deal_id, properties=[
        'dealname', 'amount', 'hubspot_owner_id',
        'tech_stack',          # custom field
        'onboarding_type',     # custom field
        'implementation_sla'   # custom field
    ])
    contact = hubspot_get_deal_contact(deal_id)

    # 2. Create Jira Issue
    priority = 'High' if deal['amount'] > 10000 else 'Medium'
    issue_key = jira_create_issue(
        project_key='IMPL',
        summary=f'Onboarding: {deal["dealname"]}',
        description=build_jira_description(deal, contact),
        issue_type='Task',
        priority=priority,
        labels=[deal['onboarding_type'], 'closed-won'],
        custom_fields={
            'customfield_10200': deal_id,  # HubSpot Deal ID
            'customfield_10201': deal['implementation_sla']
        }
    )

    # 3. Update HubSpot Deal
    hubspot_update_deal(deal_id, {
        'jira_ticket': issue_key,
        'jira_ticket_url': f'https://company.atlassian.net/browse/{issue_key}'
    })

    # 4. Create Activity in HubSpot
    hubspot_create_note(
        deal_id,
        f'Jira task created: {issue_key}. Implementation team notified.'
    )

def build_jira_description(deal: dict, contact: dict) -> str:
    return (
        f'Client: {contact.get("firstname")} {contact.get("lastname")}\n'
        f'Email: {contact.get("email")}\n'
        f'Company: {deal.get("company_name", "")}\n'
        f'Plan: {deal.get("tier", "")}\n'
        f'Amount: ${deal.get("amount", 0)}\n'
        f'Tech Stack: {deal.get("tech_stack", "")}\n'
        f'SLA: {deal.get("implementation_sla", "")}\n'
        f'HubSpot Deal ID: {deal["id"]}'
    )

Jira -> HubSpot when Issue transitions to Done:

# Jira Webhook: issue_updated, status = Done
def on_jira_issue_done(issue_key: str, custom_fields: dict):
    deal_id = custom_fields.get('customfield_10200')  # HubSpot Deal ID
    if not deal_id:
        return

    # Update stage in HubSpot or create Activity
    hubspot_create_note(
        deal_id,
        f'Jira {issue_key}: implementation complete. Client ready for launch.'
    )

    # Move deal to the next stage (e.g., Customer Success)
    hubspot_update_deal(deal_id, {
        'dealstage': 'customer_success_stage_id',
        'jira_status': 'done'
    })

Why Not Zapier/Make?

Zapier and Make provide connectors for HubSpot and Jira, but:

Deals -> Jira: Zapier triggers on a Stage change in HubSpot. But populating the Jira task description with data from custom Deal fields requires 10+ steps in a Zap with transformations. In practice the Zap becomes brittle and breaks when a new custom field is added.
Jira -> HubSpot: there is no native trigger for “status changed to Done” — a Jira webhook via an intermediate HTTP step is required. This works but is difficult to debug.
Custom logic: priority based on deal amount, different Jira projects for different deal types, conditional routing — all of this requires code steps in Zapier (Code by Zapier), which is de facto custom development.

With 20+ handoffs per month, the Zapier Zap becomes a failure point, and the cost of Zapier Teams ($49–$799/mo) is comparable to building a dedicated solution for a full year.

Real-World Case

EU SaaS (HubSpot Sales Hub Pro + Jira Cloud, 15 Closed Won per month, 6-person implementation team):

Before: native HubSpot–Jira integration installed but used only for Support Tickets. For Deals — manual task creation in Jira, 20–30 min per handoff. Tech stack and SLA were often missing — the dev team had to ask over chat.
Zapier attempt: a 14-step Zap broke every 2 weeks when custom fields changed in HubSpot. 3 months of repairs.
After custom integration: Closed Won -> Jira Task in 45 seconds with a full description. Dev team receives a Slack notification via Jira. On Done — automatic Activity in the HubSpot Deal.

Who This Is Relevant For

Companies with HubSpot Sales Hub (Professional or Enterprise) and Jira Cloud
Process: Closed Won -> handoff to implementation / Customer Success team via Jira
10+ Closed Won per month — manual handoff is not cost-effective
Native integration is installed but does not solve the problem for Deals

Frequently Asked Questions

Does the native HubSpot + Jira integration work at all?

For Support Ticket -> Jira Issue — yes. That is its primary use case. For Sales Deal -> Jira Task on Closed Won — no, this is not natively supported. If your process revolves around Deals, the native integration will not help.

What permissions are needed for the HubSpot API?

For reading and updating Deals: crm.objects.deals.read and crm.objects.deals.write. For creating Notes/Activities: timeline.events.write. A Private App in HubSpot (Settings -> Integrations -> Private Apps) is the recommended approach for server-to-server integration.

How do you configure a HubSpot Webhook for Closed Won?

In HubSpot: Settings -> Notifications -> Webhooks (available with Sales Hub Professional+). Create a webhook for the event deal.propertyChange, filter dealstage = closedwon. The payload contains objectId (deal ID) — you then request the details via API.

What if Jira Server rather than Cloud?

The native HubSpot integration only works with Jira Cloud. For Jira Server — only a custom integration via the Jira Server REST API (v2). Authentication: Basic Auth or Personal Access Tokens (PAT). The API structure is the same as Jira Cloud.

How do you avoid duplicate tasks when the webhook fires again?

Store deal_id -> jira_issue_key in your database or in a custom HubSpot Deal field. Before creating a Jira Issue, check: if the jira_ticket field is already populated — update the existing task instead of creating a new one.

Summary

Native HubSpot + Jira integration: works for Tickets, not Deals
Status is one-directional (Jira -> HubSpot), custom fields are not synchronized
Jira Cloud only — Server/Data Center not supported
Zapier solution: fragile at 14+ steps, does not scale when fields change
Custom integration: HubSpot Private App webhook + Jira REST API v3, 1–2 weeks development

If you have HubSpot and Jira and client handoffs at Closed Won are still manual — describe the structure of your Deals and Jira projects. Exceltic.dev will set up two-way synchronization with a complete set of custom fields.

HubSpot + Jira: What the Native Integration Breaks When Handing Off Clients