SignalWire Developer-First Examples: Turning Features into Experiences 🔗

This companion document provides concrete examples of how to transform SignalWire's powerful features into developer-first experiences that drive adoption.

Example 1: Homepage Hero Transformation 🔗

Traditional Approach (What to Avoid) 🔗

Welcome to SignalWire's Programmable Unified Communications Platform

SignalWire revolutionizes business communications by providing a unified, 
programmable platform that eliminates vendor lock-in and reduces costs while 
enabling unprecedented innovation in voice, video, and messaging applications.

[Request Demo] [Contact Sales] [Download Whitepaper]

Developer-First Approach (What to Do) 🔗

# Build a Customer Service AI in 10 Lines of Code
import os
from signalwire_agents import AgentBase

agent = AgentBase(name="customer-service")
agent.prompt_add_section("role", "You're a helpful customer service agent.")
agent.prompt_add_section("instructions", 
                        bullets=["Search our knowledge base",
                                "Answer questions concisely",
                                "Be friendly and professional"])
agent.add_skill("web_search", {
    "api_key": os.getenv('GOOGLE_SEARCH_API_KEY'),
    "search_engine_id": os.getenv('GOOGLE_SEARCH_ENGINE_ID')
})
agent.add_skill("native_vector_search", {"index_file": "products.swsearch"})

agent.run()  # This single agent handles UNLIMITED concurrent calls

# The Magic of SignalWire:
# - Write once, deploy everywhere
# - This SAME code handles ALL of these:
#   • Phone calls (traditional PSTN)
#   • Website visitors (embedded widget)
#   • Mobile app users (iOS/Android)
#   • SIP/VoIP systems
#   • WhatsApp voice calls
# - Scales from 1 to 100,000+ simultaneous conversations
# - No infrastructure, no channel-specific code

[Run This Code Now] [Call a Live Demo: 1-800-DEMO] [Customize This Example]

Why This Works:

Example 2: Interactive Documentation 🔗

Traditional Approach Traditional Documentation 🔗

## Getting Started with SignalWire

### Prerequisites
Before you begin, ensure you have:

- A SignalWire account
- API credentials
- Python 3.8 or higher installed
- Basic understanding of REST APIs

### Installation
To install the SignalWire SDK, run:

```bash
pip install signalwire-agents

Configuration 🔗

Create a configuration file... [20 more steps]

### **Developer-First Approach** Developer-First Documentation
```python
# Start Here - Your First SignalWire Agent in 60 Seconds

# No signup required to test the code!
from signalwire_agents import AgentBase

# Run this code locally right now
agent = AgentBase(name="my-first-agent")
agent.prompt_add_section("role", "You're a helpful assistant")
agent.prompt_add_section("instructions", 
                        bullets=["Tell the current time when asked",
                                "Do math calculations",
                                "Be friendly"])
agent.add_skill("datetime")  # Your agent can now tell time
agent.add_skill("math")      # And do calculations

agent.run()  # Starts a local server at http://localhost:8080

# Test it locally (no account needed):
# curl http://localhost:8080/
# Returns SWML document showing your agent config

# To handle real phone calls:
# 1. Sign up for free SignalWire account (30 seconds)
# 2. Point a phone number to your agent URL
# 3. This same code now handles unlimited concurrent calls!

# Next: [Test with curl] [Get SignalWire Account] [Connect Phone Number]

Interactive Elements:

Example 3: The Scalability Story - Show Don't Tell 🔗

Traditional Approach Traditional Scalability Claims 🔗

"Enterprise-grade scalability"
"Handles millions of concurrent users"
"Auto-scaling infrastructure"
"99.99% uptime SLA"

Developer-First Approach Developer-First Scalability Demonstration 🔗

# This is the COMPLETE code for a production call center
from signalwire_agents import AgentBase
import os

# This exact code handles 1 call or 100,000 calls
agent = AgentBase(name="call-center")
agent.prompt_add_section("role", "You're a professional call center agent")
agent.prompt_add_section("instructions", 
                        bullets=["Handle customer inquiries",
                                "Check order status",
                                "Process returns"])
agent.add_skill("web_search", {
    "api_key": os.getenv('GOOGLE_SEARCH_API_KEY'),
    "search_engine_id": os.getenv('GOOGLE_SEARCH_ENGINE_ID')
})

if __name__ == "__main__":
    agent.run()  # That's it. Seriously.

# What just happened?
# 1. You wrote 10 lines of code
# 2. SignalWire provides the ENTIRE infrastructure:
#    - Automatic scaling to any call volume
#    - Geographic distribution
#    - Redundancy and failover
#    - Call queuing and routing
#    - No busy signals, ever
#
# 3. You pay only for what you use (16¢/minute)
# 
# Traditional approach would require:
# - Load balancers ($$$)
# - Multiple servers ($$$)
# - DevOps team ($$$$$)
# - Months of development
#
# With SignalWire: Deploy this file. Done.

[See Live Call Volume] [Load Test This Now] [Cost Calculator]

Example 4: The Omnichannel Story - One Agent, Every Channel 🔗

Traditional Approach Traditional Approach (Channel Fragmentation) 🔗

"Our omnichannel solution supports:"

- Phone (requires telephony integration)
- Web chat (separate web SDK)
- Mobile (iOS and Android SDKs)
- WhatsApp (additional API integration)
- SIP/VoIP (specialized configuration)

* Each channel requires different code
* Separate infrastructure for each
* Complex state management across channels

Developer-First Approach SignalWire's True Omnichannel (Write Once, Deploy Everywhere) 🔗

# This ONE agent handles EVERY channel automatically
from signalwire_agents import AgentBase

agent = AgentBase(name="omni-agent")
agent.prompt_add_section("role", "You're a helpful assistant")
agent.prompt_add_section("instructions", 
                        bullets=["Help customers across any channel",
                                "Maintain context throughout"])
agent.add_skill("web_search", {
    "api_key": os.getenv('GOOGLE_SEARCH_API_KEY'),
    "search_engine_id": os.getenv('GOOGLE_SEARCH_ENGINE_ID')
})

agent.run()  # That's it. Seriously.

# This SAME agent now works on:
# Phone: Connect any phone number
# Web: <script src="signalwire-widget.js" data-agent="omni-agent"></script>
# Mobile: SignalWireKit.connect(agent: "omni-agent")
# SIP: sip:omni-agent@your-domain.signalwire.com
# WhatsApp: Enable in dashboard, same agent responds

# Customer journey example:
# 1. Customer calls from phone, starts conversation
# 2. Hangs up, continues on website (context preserved)
# 3. Switches to mobile app (still has full history)
# 4. Agent knows entire conversation across all channels

# Traditional approach: 1000+ lines of integration code
# SignalWire approach: 10 lines, works everywhere

[Try Phone Demo] [Embed in Website] [Test Mobile SDK]

Example 5: Feature Discovery Through Code 🔗

Traditional Approach Traditional Feature List 🔗

SignalWire Features:
• Ultra-low latency AI (<800ms)
• Unified communications platform
• Multi-channel support
• Enterprise security (SOC2, HIPAA)
• Global scalability
• 99.99% uptime SLA

Developer-First Approach Developer-First Feature Showcase 🔗

# Experience SignalWire's Features Through Code

# 1. Ultra-Low Latency AI (Under 800ms guaranteed)
from signalwire_agents import AgentBase

agent = AgentBase(name="latency-demo")
agent.prompt_add_section("role", "Respond quickly to demonstrate low latency")
agent.run()
# SignalWire's native integration = fastest response times

# 2. Deploy Anywhere (Same code, multiple platforms)
# This EXACT code works on:
# - Your laptop (python demo.py)
# - AWS Lambda
# - Google Cloud Functions  
# - Azure Functions
# - Any web server
agent.run()  # Auto-detects environment!

# 3. Simple Skill Integration
agent.add_skill("web_search", {
    "api_key": os.getenv('GOOGLE_SEARCH_API_KEY'),
    "search_engine_id": os.getenv('GOOGLE_SEARCH_ENGINE_ID')
})     # Add Google search
agent.add_skill("datasphere")     # Add knowledge base  
agent.add_skill("weather_api")    # Add weather data
agent.add_skill("native_vector_search", {"index_file": "docs.swsearch"})

# 4. Infinite Scalability Built-In
# No config needed. This code handles:
# - 1 concurrent call
# - 10,000 concurrent calls
# - Automatic geographic distribution
# - Zero infrastructure management

# See it in action: [Live Demo] [Load Test] [View Metrics]

Example 4: Solution-Based Navigation 🔗

Traditional Approach Traditional Navigation 🔗

Products ▼

- Voice API
- Video API  
- Messaging API
- AI Agents
- SWML
- DataSphere

Solutions ▼

- Contact Centers
- Customer Service
- Healthcare
- Financial Services

Developer-First Approach Developer-First Navigation 🔗

What do you want to build? Start coding in < 2 minutes

┌─────────────────────────────────────────────────────────────┐
│ "I need an AI that answers customer calls"                  │
├─────────────────────────────────────────────────────────────┤
│ from signalwire_agents import Agent                         │
│                                                             │
│ agent = Agent()                                             │
│ agent.add_skill("customer_service")                        │
│ agent.connect_to_phone("+1-800-YOUR-NUM")                  │
│                                                             │
│ [Copy Code] [See Full Example] [Watch 3-min Tutorial]      │
└─────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│ "I want to add AI to my existing call center"              │
├─────────────────────────────────────────────────────────────┤
│ # Add AI to any call with one line                         │
│ swml.add_ai_agent(                                         │
│     trigger="press_3",                                      │
│     agent="customer_support",                              │
│     fallback="human_queue"                                 │
│ )                                                           │
│ [Try It] [Integration Guide] [ROI Calculator]              │
└─────────────────────────────────────────────────────────────┘

Example 5: Proof Through Performance Metrics 🔗

Traditional Approach Traditional Performance Claims 🔗

"Industry-leading performance"
"Enterprise-grade reliability"
"Blazing fast response times"
"Scales to millions of users"

Developer-First Approach Developer-First Performance Display 🔗

# Real-Time Performance Dashboard
# Live data from actual SignalWire production systems

import signalwire_agents as sw

# Test it yourself - these are live metrics
metrics = sw.get_live_metrics()

print(f"""
Current System Performance (Last 5 minutes)
================================================
AI Response Time:    {metrics.avg_latency}ms    [Test Your Location]
Uptime:              {metrics.uptime}%          [Status Page]
Active Calls:        {metrics.active_calls:,}   [Live Map]
API Requests/sec:    {metrics.rps:,}           [Load Test Tool]

# Run your own benchmark
my_latency = sw.benchmark_from_your_location()
print(f"Your latency: {my_latency}ms")
""")

# Compare with building it yourself
comparison = sw.compare_architectures(
    signalwire="Native AI integration",
    traditional="Twilio + OpenAI + LiveKit + Custom code"
)
comparison.show_latency_chart()     # Visual comparison
comparison.show_cost_analysis()     # TCO over 12 months
comparison.show_code_complexity()   # Lines of code needed

Example 6: Progressive Onboarding 🔗

Traditional Approach Traditional Onboarding 🔗

Step 1: Create Account
Step 2: Verify Email
Step 3: Add Payment Method
Step 4: Schedule Demo Call
Step 5: Wait for Approval
Step 6: Access Dashboard
Step 7: Read Documentation
Step 8: Start Building

Developer-First Approach Developer-First Onboarding 🔗

# Milestone-Based Learning Path
# Start building immediately, add account details when you're ready

# Level 1: Hello World (No signup required)
from signalwire_agents import DemoAgent
agent = DemoAgent()  # Pre-configured demo agent
print(agent.test("Hello!"))  # Instant gratification

# Level 2: Add Your First Skill (Still no signup)
agent.add_skill("datetime")
print(agent.test("What time is it?"))

# Level 3: Test with Real Phone Call (Optional signup)
# Ready to test with a real phone call? 
# Create a free account in 30 seconds: [Quick Signup]
agent.get_temp_phone_number()  # 10-min expiring number

# Level 4: Deploy Your First Agent
# Love what you built? Deploy it in one command:
agent.deploy()  # Auto-detects best deployment option

# Your Progress: [===.] 75% to Production

Example 7: Progressive Disclosure of Requirements 🔗

Traditional Approach Traditional Approach (Hidden Requirements) 🔗

"Try our platform free!"
[Sign Up Now]

*After 10-step signup process...*
"Now schedule a demo with our sales team..."
*After demo...*
"Your account is pending approval..."

Developer-First Approach Developer-First Approach (Clear Progression) 🔗

# Your Journey with SignalWire

# Stage 1: Explore Locally (No signup needed!)
from signalwire_agents import AgentBase

agent = AgentBase(name="test-agent")
agent.add_skill("datetime")
agent.run()  # Running at http://localhost:8080

# What you can do RIGHT NOW:
print("**Developer-First Approach** Run this code")
print("**Developer-First Approach** Test with: curl http://localhost:8080/")  
print("**Developer-First Approach** See the SWML response")
print("**Developer-First Approach** Modify and experiment")
print("**Developer-First Approach** Use swaig-test CLI tool")

# Stage 2: Connect to ALL Channels (Free account - 30 seconds)
print("Ready for real conversations? ONE agent handles:")
print("**Developer-First Approach** Phone calls - provision numbers instantly")
print("**Developer-First Approach** Websites - embed calling widget")  
print("**Developer-First Approach** Mobile apps - iOS/Android SDKs")
print("**Developer-First Approach** SIP/VoIP - enterprise phone systems")
print("**Developer-First Approach** WhatsApp - voice calls integration")
print("**Developer-First Approach** Unlimited concurrent conversations")
print("**Developer-First Approach** Unified analytics across all channels")

# Honest timeline:
# Minute 0-5: Run code locally, see SWML
# Minute 5-6: Sign up for free account  
# Minute 6-10: Connect phone number
# Minute 10+: Handling production calls!

[Run Locally First] [Then Sign Up When Ready]

Example 8: Error Messages as Teaching Moments 🔗

Traditional Approach Traditional Error Handling 🔗

Error 401: Unauthorized
Error 400: Bad Request
Error 500: Internal Server Error

Developer-First Approach Developer-First Error Messages 🔗

# SignalWire errors teach you how to succeed

try:
    agent.add_skill("web_search", {
    "api_key": os.getenv('GOOGLE_SEARCH_API_KEY'),
    "search_engine_id": os.getenv('GOOGLE_SEARCH_ENGINE_ID')
})
except SignalWireError as e:
    print(e.helpful_message)

# Output:
"""
**Traditional Approach** Missing API Key for web_search skill

To fix this:

1. Set your Google Search API key:
   export GOOGLE_SEARCH_API_KEY='your-key-here'

2. Or use our demo key for testing:
   agent.add_skill("web_search", {"api_key": "demo_key_123"})

3. Get your own key free at: https://developers.google.com/search

Full docs: signalwire.com/docs/skills/web-search
Need help? Join Discord: discord.gg/signalwire
"""

Example 8: Community-Driven Examples 🔗

Traditional Approach Traditional Examples 🔗

Official SignalWire Examples:

- Basic Voice Call
- Simple SMS Send
- Video Conference Setup

Developer-First Approach Developer-First Example Ecosystem 🔗

# Built by the SignalWire Community
# Real developers solving real problems

# Featured This Week:
┌─────────────────────────────────────────────────────────────┐
│ "HIPAA-Compliant Appointment Scheduler"                     │
│ By: @developer_sarah                                        │
│ 234 stars | 45 forks | 12 comments                        │
├─────────────────────────────────────────────────────────────┤
│ # Books medical appointments with full compliance          │
│ agent = MedicalScheduler()                                  │
│ agent.enable_hipaa_compliance()                            │
│ agent.add_calendar_integration("epic")                     │
│                                                             │
│ [View Code] [Deploy This] [Watch Demo] [Ask Sarah]         │
└─────────────────────────────────────────────────────────────┘

# Browse More:
[Trending] [Most Starred] [Recent] [Request Feature]

Measurement Dashboard for Marketing Teams 🔗

# Developer-First Marketing Metrics Dashboard
# Track what matters for developer adoption

from signalwire_analytics import DeveloperMetrics

metrics = DeveloperMetrics(period="last_7_days")

print(f"""
Developer Engagement Scorecard
===============================================

North Star Metric:
Time to First API Call: {metrics.time_to_first_call} 
Target: < 5 minutes | Status: {'PASS' if metrics.time_to_first_call < 5 else 'WARN'}

Funnel Metrics:
Homepage to Docs:        {metrics.homepage_to_docs}% (+12%)
Docs to First API Call:  {metrics.docs_to_api}% (+8%)
API Call to Prototype:   {metrics.api_to_prototype}% (+15%)
Prototype to Production: {metrics.prototype_to_prod}% (+5%)

Developer Satisfaction:
Active Developers:      {metrics.active_devs:,} (+23%)
GitHub Stars:          {metrics.github_stars:,} (+145)
Discord Members:       {metrics.discord_members:,} (+89)
Community PRs:         {metrics.community_prs} this week

Top Performing Content:

1. "Build AI Agent in 60 Seconds" - 12,453 views, 67% completion
2. "From Zero to Production" - 8,234 views, 72% completion  
3. "DataMap Deep Dive" - 5,123 views, 81% completion

[View Full Dashboard] [Export Report] [Set Up Alerts]
""")

Implementation Checklist for Marketing Teams 🔗

Week 1: Foundation 🔗

Week 2-4: Content Transformation 🔗

Month 2: Community Building 🔗

Success Criteria 🔗

Remember: Every feature description should include working code. Every benefit claim should be provable with a live demo. Every piece of content should help a developer build something real. That's the path to developer-first marketing excellence.