Back to Documentation

Support

Complete guide to getting help with Vibe Trading, including support channels, escalation procedures, and self-service resources.

Overview

Vibe Trading provides comprehensive support through multiple channels to ensure you get the help you need quickly and effectively. This guide covers all available support options, response times, and how to get the most out of our support services.

Support Channels

Live Chat Support

Availability

  • 24/7 Coverage: Available around the clock
  • Response Time: Typically within 2 minutes
  • Languages: English, Spanish, French, German, Chinese

How to Access

  1. Platform Access: Click the chat icon in the bottom-right corner
  2. Mobile App: Tap the support button in the app menu
  3. Website: Use the live chat widget on any page

What Live Chat Can Help With

  • Account Issues: Login problems, verification questions
  • Trading Questions: Order placement, position management
  • Technical Issues: Platform bugs, performance problems
  • General Inquiries: Features, pricing, account types

Live Chat Best Practices

// Example of how to prepare for live chat
class LiveChatHelper {
  constructor() {
    this.preparationChecklist = [
      "account_id",
      "error_messages",
      "browser_info",
      "steps_to_reproduce",
      "screenshots",
    ];
  }

  prepareForChat(issue) {
    const chatData = {
      accountId: this.getAccountId(),
      issue: issue,
      browserInfo: this.getBrowserInfo(),
      errorMessages: this.getErrorMessages(),
      screenshots: this.captureScreenshots(),
      timestamp: new Date().toISOString(),
    };

    return chatData;
  }

  getBrowserInfo() {
    return {
      userAgent: navigator.userAgent,
      platform: navigator.platform,
      language: navigator.language,
      cookieEnabled: navigator.cookieEnabled,
    };
  }

  captureScreenshots() {
    // Capture relevant screenshots
    return {
      currentPage: this.captureCurrentPage(),
      errorDialog: this.captureErrorDialog(),
      consoleLogs: this.getConsoleLogs(),
    };
  }
}

Email Support

Email Addresses

Response Times

  • General Support: Within 4 hours
  • Technical Issues: Within 2 hours
  • Account Issues: Within 1 hour
  • Security Concerns: Within 30 minutes
  • Business Inquiries: Within 24 hours

Email Template

Subject: [Priority] Brief description of issue

Priority: High/Medium/Low
Account ID: acc_123456789
Issue Type: Technical/Account/Trading/General

Description:
[Detailed description of the issue]

Steps to Reproduce:

1. [Step 1]
2. [Step 2]
3. [Step 3]

Expected Result:
[What you expected to happen]

Actual Result:
[What actually happened]

Additional Information:

- Browser: [Browser name and version]
- Operating System: [OS name and version]
- Screenshots: [Attached if applicable]
- Error Messages: [Any error messages received]

Contact Information:

- Phone: [Your phone number]
- Best time to call: [Preferred time]

Phone Support

Phone Numbers

  • US/Canada: +1 (555) 123-4567
  • UK: +44 20 7946 0958
  • Germany: +49 30 2084 2000
  • Australia: +61 2 9374 4000

Availability

  • Monday-Friday: 6:00 AM - 10:00 PM EST
  • Saturday-Sunday: 8:00 AM - 8:00 PM EST
  • Holidays: Limited support available

What Phone Support Can Help With

  • Complex Issues: Multi-step problem resolution
  • Account Recovery: Password resets, account access
  • Trading Assistance: Complex trading scenarios
  • Escalation: Issues requiring immediate attention

Community Forum

Forum Access

Forum Categories

  • General Discussion: Platform updates, announcements
  • Trading Strategies: Share and discuss strategies
  • Technical Support: Community-driven technical help
  • Feature Requests: Suggest new features
  • Bug Reports: Report and track bugs
  • Developer Community: API and integration discussions

Forum Guidelines

# Community Forum Guidelines

## Posting Guidelines

- Be respectful and constructive
- Use descriptive titles
- Search before posting
- Provide relevant details
- Use appropriate categories

## Getting Help

1. Search existing threads
2. Check pinned posts
3. Post detailed questions
4. Respond to follow-ups
5. Mark solutions as resolved

## Helping Others

- Share your knowledge
- Provide accurate information
- Be patient with beginners
- Report inappropriate content
- Follow community guidelines

Support Tiers

Tier 1: Basic Support

Handled By: Support Specialists Response Time: 2-4 hours Issues Covered:

  • Account setup and verification
  • Basic trading questions
  • Platform navigation
  • General inquiries

Escalation Criteria:

  • Complex technical issues
  • Security concerns
  • Account disputes
  • Feature requests

Tier 2: Advanced Support

Handled By: Senior Support Specialists Response Time: 1-2 hours Issues Covered:

  • Complex trading scenarios
  • API integration issues
  • Performance problems
  • Account management

Escalation Criteria:

  • Critical system issues
  • Security incidents
  • Compliance issues
  • Business-critical problems

Tier 3: Expert Support

Handled By: Technical Experts and Engineers Response Time: 30 minutes - 1 hour Issues Covered:

  • Critical system failures
  • Security incidents
  • Complex technical problems
  • Platform bugs

Escalation Criteria:

  • System-wide outages
  • Data breaches
  • Regulatory issues
  • Executive escalation

Self-Service Resources

Knowledge Base

Documentation Sections

  • Getting Started: Account setup, first trades
  • Trading Guide: Order types, strategies
  • API Documentation: Complete API reference
  • Security Guide: Best practices, 2FA setup
  • Troubleshooting: Common issues and solutions

Search Functionality

class KnowledgeBaseSearch:
    def __init__(self):
        self.articles = self.load_articles()
        self.search_index = self.build_search_index()

    def search(self, query, category=None):
        results = []

        for article in self.articles:
            if category and article['category'] != category:
                continue

            score = self.calculate_relevance_score(query, article)
            if score > 0.3:  # Minimum relevance threshold
                results.append({
                    'article': article,
                    'score': score
                })

        # Sort by relevance score
        results.sort(key=lambda x: x['score'], reverse=True)
        return results[:10]  # Top 10 results

    def calculate_relevance_score(self, query, article):
        query_terms = query.lower().split()
        article_text = (article['title'] + ' ' + article['content']).lower()

        score = 0
        for term in query_terms:
            if term in article_text:
                score += 1

        return score / len(query_terms)

Video Tutorials

Tutorial Categories

  • Platform Overview: Getting started with Vibe Trading
  • Trading Basics: How to place orders, manage positions
  • Advanced Features: Custom strategies, API usage
  • Security: Setting up 2FA, securing your account
  • Troubleshooting: Common issues and solutions

Tutorial Access

  • Platform: Built-in video player
  • YouTube: Vibe Trading channel
  • Mobile App: Offline viewing capability
  • Transcripts: Available for all videos

Webinars

Webinar Schedule

  • Weekly: Every Tuesday at 2:00 PM EST
  • Monthly: Advanced topics on first Friday
  • Quarterly: Platform updates and new features
  • On-Demand: Recorded webinars available

Webinar Topics

  • Trading Strategies: AI signal interpretation
  • Risk Management: Position sizing, stop losses
  • API Integration: Building trading bots
  • Market Analysis: Understanding market conditions

Issue Reporting

Bug Reports

Bug Report Template

# Bug Report

## Summary

[Brief description of the bug]

## Environment

- Platform: Web/Mobile/API
- Browser: [Browser name and version]
- Operating System: [OS name and version]
- Account Type: [Account type]

## Steps to Reproduce

1. [Step 1]
2. [Step 2]
3. [Step 3]

## Expected Behavior

[What you expected to happen]

## Actual Behavior

[What actually happened]

## Screenshots/Logs

[Attach relevant screenshots or logs]

## Additional Information

[Any other relevant information]

Bug Tracking

class BugTracker:
    def __init__(self):
        self.bugs = []
        self.statuses = ['new', 'confirmed', 'in_progress', 'resolved', 'closed']

    def create_bug_report(self, bug_data):
        bug = {
            'id': self.generate_bug_id(),
            'title': bug_data['title'],
            'description': bug_data['description'],
            'priority': bug_data.get('priority', 'medium'),
            'status': 'new',
            'reporter': bug_data['reporter'],
            'created_at': datetime.utcnow().isoformat(),
            'steps_to_reproduce': bug_data['steps'],
            'environment': bug_data['environment']
        }

        self.bugs.append(bug)
        return bug['id']

    def update_bug_status(self, bug_id, new_status, notes=None):
        for bug in self.bugs:
            if bug['id'] == bug_id:
                bug['status'] = new_status
                if notes:
                    bug['notes'] = notes
                bug['updated_at'] = datetime.utcnow().isoformat()
                return True
        return False

    def get_bug_status(self, bug_id):
        for bug in self.bugs:
            if bug['id'] == bug_id:
                return {
                    'status': bug['status'],
                    'priority': bug['priority'],
                    'created_at': bug['created_at'],
                    'updated_at': bug.get('updated_at')
                }
        return None

Feature Requests

Feature Request Process

  1. Submit Request: Use the feature request form
  2. Community Voting: Community members vote on requests
  3. Review: Product team reviews top-voted features
  4. Roadmap: Approved features added to roadmap
  5. Development: Features developed and released

Feature Request Template

# Feature Request

## Feature Description

[Detailed description of the requested feature]

## Use Case

[How would this feature be used?]

## Benefits

[What benefits would this feature provide?]

## Priority

[High/Medium/Low]

## Additional Information

[Any other relevant information]

Escalation Procedures

When to Escalate

Immediate Escalation

  • Security Incidents: Suspected breaches, unauthorized access
  • System Outages: Platform unavailable, critical failures
  • Financial Issues: Missing funds, incorrect transactions
  • Compliance Issues: Regulatory violations, legal concerns

Standard Escalation

  • Complex Technical Issues: Problems requiring engineering
  • Account Disputes: Verification problems, account restrictions
  • Performance Issues: Slow platform, high latency
  • Feature Requests: New functionality requests

Escalation Process

Step 1: Initial Assessment

class EscalationManager:
    def __init__(self):
        self.escalation_criteria = {
            'security': ['breach', 'unauthorized', 'hack', 'phishing'],
            'financial': ['missing_funds', 'incorrect_transaction', 'withdrawal_issue'],
            'technical': ['system_down', 'critical_bug', 'data_loss'],
            'compliance': ['regulatory', 'legal', 'audit']
        }

    def assess_escalation_need(self, issue_description):
        issue_lower = issue_description.lower()

        for category, keywords in self.escalation_criteria.items():
            for keyword in keywords:
                if keyword in issue_lower:
                    return {
                        'escalate': True,
                        'category': category,
                        'priority': self.get_priority(category),
                        'reason': f"Contains keyword: {keyword}"
                    }

        return {'escalate': False, 'reason': 'No escalation criteria met'}

    def get_priority(self, category):
        priority_map = {
            'security': 'critical',
            'financial': 'high',
            'technical': 'high',
            'compliance': 'high'
        }
        return priority_map.get(category, 'medium')

Step 2: Escalation Execution

class EscalationExecutor:
    def __init__(self):
        self.escalation_channels = {
            'critical': ['phone', 'email', 'slack'],
            'high': ['email', 'slack'],
            'medium': ['email']
        }

    def execute_escalation(self, issue_id, priority, category):
        channels = self.escalation_channels.get(priority, ['email'])

        escalation_data = {
            'issue_id': issue_id,
            'priority': priority,
            'category': category,
            'channels': channels,
            'timestamp': datetime.utcnow().isoformat()
        }

        # Send escalation notifications
        for channel in channels:
            self.send_escalation_notification(channel, escalation_data)

        return escalation_data

    def send_escalation_notification(self, channel, data):
        if channel == 'phone':
            self.make_phone_call(data)
        elif channel == 'email':
            self.send_email(data)
        elif channel == 'slack':
            self.send_slack_message(data)

Support Metrics

Response Time Targets

Response Time Goals

  • Live Chat: < 2 minutes
  • Email Support: < 4 hours
  • Phone Support: < 1 minute
  • Community Forum: < 24 hours
  • Bug Reports: < 2 hours
  • Feature Requests: < 48 hours

Performance Tracking

class SupportMetrics:
    def __init__(self):
        self.metrics = {
            'response_times': [],
            'resolution_times': [],
            'satisfaction_scores': [],
            'escalation_rates': []
        }

    def track_response_time(self, channel, response_time):
        self.metrics['response_times'].append({
            'channel': channel,
            'response_time': response_time,
            'timestamp': datetime.utcnow().isoformat()
        })

    def track_resolution_time(self, issue_id, resolution_time):
        self.metrics['resolution_times'].append({
            'issue_id': issue_id,
            'resolution_time': resolution_time,
            'timestamp': datetime.utcnow().isoformat()
        })

    def get_performance_summary(self, period='monthly'):
        if period == 'monthly':
            cutoff_date = datetime.utcnow() - timedelta(days=30)
        elif period == 'weekly':
            cutoff_date = datetime.utcnow() - timedelta(days=7)
        else:
            cutoff_date = datetime.utcnow() - timedelta(days=1)

        recent_metrics = {
            'response_times': [m for m in self.metrics['response_times']
                              if datetime.fromisoformat(m['timestamp']) > cutoff_date],
            'resolution_times': [m for m in self.metrics['resolution_times']
                                if datetime.fromisoformat(m['timestamp']) > cutoff_date]
        }

        summary = {
            'average_response_time': self.calculate_average_response_time(recent_metrics['response_times']),
            'average_resolution_time': self.calculate_average_resolution_time(recent_metrics['resolution_times']),
            'total_tickets': len(recent_metrics['response_times']),
            'resolution_rate': self.calculate_resolution_rate(recent_metrics)
        }

        return summary

Best Practices

Getting Effective Support

Before Contacting Support

  1. Check Documentation: Review relevant documentation
  2. Search Knowledge Base: Look for existing solutions
  3. Try Basic Troubleshooting: Restart browser, clear cache
  4. Gather Information: Collect relevant details and screenshots
  5. Prepare Description: Write clear, detailed problem description

During Support Interaction

  1. Be Specific: Provide exact error messages and steps
  2. Stay Patient: Support agents are working to help you
  3. Follow Instructions: Complete requested troubleshooting steps
  4. Ask Questions: Clarify anything you don't understand
  5. Provide Feedback: Let us know if solutions work

After Support Resolution

  1. Test Solution: Verify the issue is resolved
  2. Provide Feedback: Rate your support experience
  3. Document Solution: Note the solution for future reference
  4. Share Knowledge: Help others with similar issues
  5. Follow Up: Contact support if issues return

Support Quality Assurance

Quality Metrics

  • First Contact Resolution: Percentage resolved on first contact
  • Customer Satisfaction: Ratings and feedback scores
  • Response Time: Time to initial response
  • Resolution Time: Time to complete resolution
  • Escalation Rate: Percentage of escalated issues

Continuous Improvement

  • Regular Training: Ongoing support agent training
  • Process Optimization: Streamline support processes
  • Tool Enhancement: Improve support tools and systems
  • Feedback Integration: Incorporate customer feedback
  • Performance Monitoring: Track and improve metrics

Need more help? Check out our FAQ or explore our Knowledge Base.