How to Set Up HubSpot for Remote Agency Client Pipeline

Remote agencies face unique challenges when managing client relationships. Your team spans multiple time zones, client interactions happen asynchronously, and maintaining visibility into deal progress requires deliberate system design. HubSpot provides the flexibility to build a pipeline that accommodates these realities, but the default configuration rarely fits a remote agency’s workflow out of the box.

This guide walks through configuring HubSpot specifically for remote agency operations, focusing on pipeline stages, properties, and automation that support asynchronous client management.

Building Your Client Pipeline Stages

The foundation of any HubSpot setup is the pipeline itself. For a remote agency, your stages should reflect how deals actually progress when team members work across time zones and communicate primarily through written channels.

A practical pipeline for remote agencies includes these stages:

1. New Inquiry — Initial lead capture, typically from website forms or cold outreach
2. Discovery Call Scheduled — Prospect has shown intent and a call is on the calendar
3. Proposal Sent — Written proposal delivered asynchronously
4. Proposal Review — Client is reviewing (this often takes longer remotely due to approval chains)
5. Contract Negotiation — Revisions, scope changes, and contract discussion
6. Closed Won — Deal secured
7. Closed Lost — Deal did not move forward

Each stage represents a clear handoff point, which matters when your team isn’t physically together to discuss deal status in real time. Avoid overcomplicating stages — the more granular you make them, the more maintenance required to keep deal stages accurate.

Configuring Properties for Remote Agency Context

Standard HubSpot properties work well, but remote agencies benefit from adding custom properties that capture context specific to distributed work.

Time Zone Property

Create a custom property for contacts called client_timezone. This enables your team to schedule calls at reasonable hours and sets expectations during proposal review periods. When a client in Tokyo is reviewing your proposal, knowing their timezone helps you understand why responses might come 8 hours after you send them.

// Example: Using HubSpot API to set client timezone via webhook
// This assumes you're capturing timezone from a form or enrichment tool
const hubspotClient = require('@hubspot/api-client');
const hubspot = new hubspotClient.Client({ accessToken: process.env.HUBSPOT_TOKEN });

async function updateClientTimezone(contactId, timezone) {
  try {
    await hubspot.crm.contacts.basicApi.update(contactId, {
      properties: {
        client_timezone: timezone
      }
    });
  } catch (e) {
    console.error('Failed to update timezone:', e.message);
  }
}

Async Communication Preferences

Add a property called preferred_async_channel with options like email, Slack, or project management tool. Some clients prefer everything in writing; others want quick Slack messages. Capturing this preference prevents misaligned communication expectations.

Last Contacted (Manual Override)

While HubSpot tracks automatic activity, remote agencies benefit from a manual “last meaningful contact” property. When your team member has a substantive async exchange with a client, they update this timestamp. It provides a quick visual indicator of relationship health without relying solely on email open rates.

Setting Up Deal Automation

Automation in HubSpot should reduce busywork while preserving human judgment on client relationships. For remote agencies, focus automation on notification and data capture rather than auto-advancing deals through stages.

Stage Change Notifications

Configure workflow triggers to notify the appropriate team member when deals move stages. In a remote context, you cannot lean over and ask “hey, did you see that proposal was opened?” Instead, build alerts:

1. Create a workflow with the trigger “Deal stage changed”
2. Add a branch condition: if owner is known
3. Send notification to the deal owner’s preferred channel (Slack, email)

// Example: Slack notification payload for deal stage change
const slackMessage = {
  channel: '#agency-deals',
  text: `Deal update: ${dealName}`,
  blocks: [
    {
      type: 'section',
      text: {
        type: 'mrkdwn',
        text: `*${dealName}* moved to *${newStage}*\nOwner: ${ownerName}\n<${dealUrl}|View in HubSpot>`
      }
    }
  ]
};

Auto-Creation of Tasks

When a deal enters “Proposal Sent” stage, automatically create a follow-up task for 5 business days later. Remote agencies often work with clients who need internal approval cycles, and a scheduled follow-up ensures nothing falls through the cracks during extended proposal review periods.

Integrating with Your Existing Tools

HubSpot’s value increases significantly when connected to your other systems. For remote agencies, the most valuable integrations typically include:

Slack — Real-time notifications keep distributed teams informed without checking HubSpot constantly. Configure which notifications matter (new deals, stage changes, closed deals) to avoid alert fatigue.

Calendar integration — Sync HubSpot with Google Calendar or Calendly. For remote agencies, seeing availability across time zones directly in HubSpot prevents scheduling mishaps.

Project management — While not a native HubSpot strength, connecting to tools like Asana or Linear through Zapier or native integrations allows you to link deals to projects. This creates a traceable connection between client acquisition and delivery work.

// Example: Simple Zapier-style webhook handler for deal-to-project linking
// This would run in your project management integration layer
app.post('/webhooks/hubspot-deal-created', (req, res) => {
  const { dealId, dealName, ownerEmail } = req.body;

  // Create corresponding project in your PM tool
  createProject({
    name: dealName,
    leadEmail: ownerEmail,
    source: 'hubspot',
    externalId: dealId
  });

  res.status(200).send('Project created');
});

Reporting for Distributed Teams

Remote agencies need different reporting approaches than co-located teams. Since you cannot walk around and ask about deal status, your pipeline reports must be self-explanatory.

Build a dashboard with these key metrics:

• Deals in each stage — Current pipeline health snapshot
• Average time in stage — Identifies bottlenecks in your remote workflow
• Deal velocity — Days from first inquiry to close
• Win rate by source — Which channels deliver qualified remote leads

Schedule a weekly pipeline review where team members update deal stages during their local business hours. With proper automation and clear property usage, this weekly sync becomes a strategic conversation rather than a status update scavenger hunt.

Advanced: Predictive Deal Scoring

Move beyond manual tracking with predictive scoring that flags which deals are likely to close.

Building a Simple Scoring Model

Create a HubSpot custom property that scores deal likelihood based on behavioral signals:

# HubSpot Deal Scoring Logic
def calculate_deal_score(deal):
    """
    Calculate probability of deal closing.
    Scores deals 1-10 based on signals.
    """
    score = 0
    signals = {}

    # Stage weight (0-3 points)
    stage_scores = {
        "New Inquiry": 0,
        "Discovery Call Scheduled": 1,
        "Proposal Sent": 2,
        "Proposal Review": 2,
        "Contract Negotiation": 3
    }
    score += stage_scores.get(deal['stage'], 0)
    signals['stage_score'] = stage_scores.get(deal['stage'], 0)

    # Engagement signal (0-3 points)
    # Count recent interactions
    if deal['days_since_last_activity'] < 3:
        score += 3
        signals['engagement'] = 'High (activity <3 days ago)'
    elif deal['days_since_last_activity'] < 7:
        score += 2
        signals['engagement'] = 'Medium (activity <7 days)'
    else:
        signals['engagement'] = 'Low (activity >7 days)'

    # Deal size (0-2 points)
    if deal['amount'] > 50000:
        score += 2
        signals['size'] = 'Large (>$50k)'
    elif deal['amount'] > 10000:
        score += 1
        signals['size'] = 'Medium ($10-50k)'

    # Contact engagement (0-2 points)
    if deal['contact_email_opens'] > 5:
        score += 2
        signals['contact_engagement'] = 'High (5+ opens)'
    elif deal['contact_email_opens'] > 0:
        score += 1
        signals['contact_engagement'] = 'Some opens'

    return {
        'total_score': min(score, 10),  # Cap at 10
        'signals': signals,
        'recommendation': (
            'Follow up urgently' if score >= 8 else
            'Follow up soon' if score >= 5 else
            'Monitor'
        )
    }

Store this score in a HubSpot custom property and update it automatically via workflow.

Prioritizing Follow-ups by Score

Use scoring to focus effort on high-probability deals:

Score 8-10: Follow up same day
- Personal email or Slack message
- Schedule call within 48 hours
- Prioritize for senior team member

Score 5-7: Follow up within 3 days
- Standard email or async message
- Check-in call if no response
- Can be handled by junior team member

Score 0-4: Monitor
- Monthly check-in
- Move to "nurture" track if engagement drops
- Revisit if new signals emerge

This approach ensures your limited follow-up time targets deals most likely to close.

Remote Agency-Specific Workflows

Proposal Review Automation

When proposals sit unsigned for extended periods, deals stall. Automate reminders:

1. Create workflow trigger: “Deal moved to Proposal Review stage”
2. Wait 3 business days
3. Check condition: Deal still in Proposal Review
4. Send email: “Checking in on the proposal—happy to answer questions or schedule a discussion”
5. Wait 5 more days
6. Create task: “Call [contact name] to discuss proposal”

This automation prevents proposals from being forgotten.

Multi-Contact Tracking

Remote deals often involve multiple stakeholders. Track all contacts on a deal:

1. Create deal associations to multiple contacts
2. Add property: “Primary decision maker” and “Technical stakeholder” and “Finance approval”
3. Track interactions with each contact separately
4. Note in deal activity when you’ve engaged each stakeholder

This prevents the surprise of “oh, we need finance approval from a different person” derailing deals late in the process.

Timezone-Aware Scheduling

When working across time zones, scheduling is critical. Add a “Optimal call time” property:

Contact properties:
- contact_timezone: [Select field with major timezones]
- contact_working_hours: Free text (e.g., "9 AM - 5 PM JST")
- best_communication_method: Email / Slack / Phone call

When scheduling calls, reference these properties to find mutually convenient times.

Use a tool like Calendly with timezone support to let clients book calls without back-and-forth.

Maintaining Pipeline Hygiene

A pipeline only works when data stays current. For remote agencies, this requires intentional habits:

Assign deal ownership clearly — every active deal needs an owner who bears responsibility for stage updates. Without clear ownership in a distributed team, deals stagnate in ambiguous stages.

Require stage change notes — when moving a deal forward, mandate a brief note explaining why. This context becomes invaluable when reviewing deals during weekly syncs or when ownership transfers between team members in different time zones.

Review stale deals monthly — build a workflow that flags deals unchanged for 14+ days. Remote agencies cannot rely on hallway conversations to surface neglected relationships.

Weekly Pipeline Review Cadence

Schedule 30-minute weekly pipeline reviews during a time when both US and Europe team members can attend:

Weekly Pipeline Review (30 minutes)

00:00-05:00 min: Review new deals (any new inquiries?)
05:00-15:00 min: Discuss deals in "Proposal Review" or "Contract Negotiation"
15:00-25:00 min: Identify at-risk deals (unchanged >10 days)
25:00-30:00 min: Assign follow-ups and next steps

Async follow-up: Post notes in Slack channel so team members in other zones stay informed

This rhythm keeps the pipeline visible and prevents deals from being forgotten.

Dashboard Metrics for Remote Leadership

Create HubSpot dashboards that show pipeline health at a glance:

Deal velocity dashboard:

• Average days in each stage (identifies bottlenecks)
• Deals closing per week (trend line showing if pipeline is accelerating)
• Deal size distribution (are you closing bigger deals over time?)

Team performance dashboard:

• Deals by owner (ensures even distribution)
• Close rate by team member (identifies top performers)
• Win/loss ratio by industry or deal source (shows which markets work)

These dashboards replace status update meetings—anyone can check pipeline health without asking questions.

Related Articles

• How to Set Up Basecamp for Remote Agency Client
• How to Set Up Client Onboarding Portal for Remote Agency
• How to Set Up Harvest for Remote Agency Client Time Tracking
• Example: GitHub Actions workflow for assessment tracking
• How to Set Up Shared Notion Workspace with Remote Agency

Built by theluckystrike — More at zovo.one