Based Music - Full-Stack Music Streaming & Social Platform

The Vision

Based Music emerged from a critical gap in the music industry: local music scenes lack a unified platform for discovery and connection. Artists struggle to reach their community, venues can't effectively promote events, and music lovers miss incredible local talent happening nearby. We built Based Music as a comprehensive ecosystem that combines professional-grade audio streaming, AI-powered discovery, real-time social features, and location-based event management—all in one platform.

Platform Impact & Metrics

System Architecture Overview

Based Music is built on a sophisticated three-tier architecture that separates concerns while enabling seamless integration across all platform features.

Technical Innovation

Core Platform Features

Based Music is more than just music streaming—it's a complete ecosystem with multiple interconnected services.

Deep Dive: Audio Streaming Architecture

The audio streaming system is the technical crown jewel of Based Music. We engineered a highly optimized streaming pipeline that rivals commercial platforms.

Challenge: iOS Audio Performance

Initial iOS load times of 900ms were unacceptable. The root causes:

• OGG format not natively supported on iOS
• Full file download before playback
• No caching strategy
• Inefficient S3 access patterns

Solution: Adaptive Streaming Architecture

Implementation: Intelligent Caching & Chunking

// Adaptive transcoding system with intelligent caching
export class AdaptiveAudioService {
  private readonly CACHE_TTL = {
    metadata: 300, // 5 minutes
    trackInfo: 3600, // 1 hour
    stream: 7200, // 2 hours
  };

  async streamAudio(trackId: string, client: ClientInfo): Promise<AudioStream> {
    // Detect client capabilities
    const profile = this.getClientProfile(client);

    // Multi-tier cache check
    const cacheKey = `${trackId}:${profile.codec}`;
    const cached = await this.cache.get(cacheKey);
    if (cached) {
      this.metrics.record("cache_hit", { trackId, codec: profile.codec });
      return this.createStreamFromCache(cached);
    }

    // Real-time transcoding for iOS AAC
    if (profile.requiresTranscode) {
      const lambda = new AWS.Lambda();
      const result = await lambda
        .invoke({
          FunctionName: "audio-transcode",
          Payload: JSON.stringify({
            source: `s3://audio-raw/${trackId}.ogg`,
            target: profile.codec,
            bitrate: profile.bitrate,
            chunkSize: profile.initialChunkSize || 65536, // 64KB
          }),
        })
        .promise();

      // Cache for future requests
      await this.cache.set(cacheKey, result.stream, this.CACHE_TTL.stream);

      return result.stream;
    }

    // Direct streaming with range requests for Android
    return this.createRangeStream(trackId, profile);
  }

  private createRangeStream(trackId: string, profile: ClientProfile) {
    return new ReadableStream({
      start: async (controller) => {
        let offset = 0;
        const chunkSize = profile.chunkSize || 1048576; // 1MB default

        while (true) {
          const chunk = await this.s3
            .getObject({
              Bucket: "based-music-audio",
              Key: `tracks/${trackId}.ogg`,
              Range: `bytes=${offset}-${offset + chunkSize - 1}`,
            })
            .promise();

          if (!chunk.Body) break;

          controller.enqueue(chunk.Body);
          offset += chunkSize;

          if (chunk.ContentLength < chunkSize) break;
        }

        controller.close();
      },
    });
  }
}

Results: 87% Performance Improvement

AI-Powered Discovery Engine

The recommendation system is a multi-modal AI engine that combines audio analysis, collaborative filtering, and contextual awareness to deliver personalized music discovery.

Audio Feature Extraction Pipeline

Implementation: Audio Feature Extraction

# TensorFlow audio feature extraction with librosa
import librosa
import numpy as np
import tensorflow as tf

def extract_audio_features(audio_file: str) -> dict:
    """
    Extract comprehensive musical features for recommendation engine
    Processes audio file and generates 512-dimensional embedding vector
    """
    # Load audio file with resampling to 22kHz
    y, sr = librosa.load(audio_file, sr=22050)

    # Extract temporal features
    tempo, beats = librosa.beat.beat_track(y=y, sr=sr)

    # Extract spectral features
    spectral_centroid = np.mean(librosa.feature.spectral_centroid(y=y, sr=sr))
    spectral_rolloff = np.mean(librosa.feature.spectral_rolloff(y=y, sr=sr))
    spectral_bandwidth = np.mean(librosa.feature.spectral_bandwidth(y=y, sr=sr))

    # Extract MFCC (Mel-frequency cepstral coefficients)
    mfcc = np.mean(librosa.feature.mfcc(y=y, sr=sr, n_mfcc=20), axis=1)

    # Extract energy and zero-crossing rate
    energy = np.mean(librosa.feature.rms(y=y))
    zcr = np.mean(librosa.feature.zero_crossing_rate(y))

    # Extract chroma features for key/mode detection
    chroma = np.mean(librosa.feature.chroma_stft(y=y, sr=sr), axis=1)

    # Estimate key and mode
    key, mode = estimate_key_mode(chroma)

    features = {
        'tempo': float(tempo),
        'spectral_centroid': float(spectral_centroid),
        'spectral_rolloff': float(spectral_rolloff),
        'spectral_bandwidth': float(spectral_bandwidth),
        'mfcc': mfcc.tolist(),
        'energy': float(energy),
        'zcr': float(zcr),
        'chroma': chroma.tolist(),
        'key': key,
        'mode': mode
    }

    # Generate 512-dimensional embedding using pre-trained model
    embedding = audio_model.predict(np.array([features]))

    return {
        'features': features,
        'embedding': embedding.tolist(),
        'duration': len(y) / sr
    }

def estimate_key_mode(chroma: np.ndarray) -> tuple:
    """Estimate musical key and mode from chroma features"""
    # Correlation with major and minor key profiles
    major_profile = np.array([6.35, 2.23, 3.48, 2.33, 4.38, 4.09,
                              2.52, 5.19, 2.39, 3.66, 2.29, 2.88])
    minor_profile = np.array([6.33, 2.68, 3.52, 5.38, 2.60, 3.53,
                              2.54, 4.75, 3.98, 2.69, 3.34, 3.17])

    major_corr = np.correlate(chroma, major_profile)
    minor_corr = np.correlate(chroma, minor_profile)

    key = int(np.argmax(chroma))
    mode = 'major' if major_corr > minor_corr else 'minor'

    return key, mode

Recommendation Pipeline Architecture

5-Stage Process:

1. Audio Analysis: Extract features and generate embeddings (512-dim vectors)
2. User Profiling: Build preference model from listening history
3. Vector Search: Pinecone similarity search for candidate tracks
4. Collaborative Filtering: Incorporate behavior of similar users
5. Context Ranking: Final ranking with location, time, and mood factors

Results: 45% Engagement Increase

The AI recommendation system dramatically improved user engagement:

• 45% increase in session duration
• 3.2x more track discoveries per session
• 68% of plays from recommended tracks
• Cold start solved: New users get quality recommendations from day 1

Real-Time Infrastructure

Based Music's real-time features are powered by a sophisticated WebSocket system that handles instant messaging, live presence, and real-time notifications.

WebSocket Architecture

Implementation: Real-Time Event System

// WebSocket event system with Kinesis analytics integration
import AWS from "aws-sdk";
import { WebSocket } from "ws";

export class RealtimeEventBus {
  private wss: WebSocket.Server;
  private connectionPool: Map<string, Set<string>>; // userId -> Set<connectionId>
  private kinesis: AWS.Kinesis;
  private apiGateway: AWS.ApiGatewayManagementApi;

  constructor(server: http.Server) {
    this.wss = new WebSocket.Server({ server });
    this.connectionPool = new Map();
    this.kinesis = new AWS.Kinesis({ region: "us-west-2" });
    this.apiGateway = new AWS.ApiGatewayManagementApi({
      endpoint: process.env.WEBSOCKET_API_ENDPOINT,
    });

    this.setupConnectionHandlers();
  }

  private setupConnectionHandlers(): void {
    this.wss.on("connection", (ws: WebSocket, req) => {
      const userId = this.authenticateConnection(req);
      const connectionId = this.generateConnectionId();

      // Track connection
      if (!this.connectionPool.has(userId)) {
        this.connectionPool.set(userId, new Set());
      }
      this.connectionPool.get(userId)!.add(connectionId);

      // Store in DynamoDB for persistence
      this.storeConnection(userId, connectionId);

      ws.on("message", (data) => this.handleMessage(userId, data));
      ws.on("close", () => this.handleDisconnect(userId, connectionId));
    });
  }

  async broadcast(event: MusicEvent): Promise<void> {
    // Stream to Kinesis for real-time analytics
    await this.kinesis
      .putRecord({
        StreamName: "music-events",
        Data: JSON.stringify({
          ...event,
          timestamp: Date.now(),
          eventType: event.type,
        }),
        PartitionKey: event.userId,
      })
      .promise();

    // Get target connections based on event scope
    const connections = await this.getActiveConnections(event.scope);

    // Broadcast to all connected clients in parallel
    const results = await Promise.allSettled(
      connections.map(async (connectionId) => {
        try {
          await this.apiGateway
            .postToConnection({
              ConnectionId: connectionId,
              Data: JSON.stringify(event),
            })
            .promise();

          return { success: true, connectionId };
        } catch (error) {
          // Connection stale, remove from pool
          if (error.statusCode === 410) {
            await this.removeStaleConnection(connectionId);
          }
          throw error;
        }
      })
    );

    // Track delivery metrics
    const successful = results.filter((r) => r.status === "fulfilled").length;
    await this.recordMetrics({
      event: event.type,
      totalTargets: connections.length,
      successful,
      failed: connections.length - successful,
    });
  }

  async sendDirectMessage(
    fromUserId: string,
    toUserId: string,
    message: ChatMessage
  ): Promise<void> {
    // Store message in DynamoDB
    await this.storeMessage({
      chatId: this.getChatId(fromUserId, toUserId),
      messageId: uuidv4(),
      fromUserId,
      toUserId,
      content: message.content,
      mediaUrl: message.mediaUrl,
      timestamp: Date.now(),
    });

    // Get recipient connections
    const connections = this.connectionPool.get(toUserId);

    if (connections && connections.size > 0) {
      // Send via WebSocket (instant delivery)
      await Promise.all(
        Array.from(connections).map((connectionId) =>
          this.sendToConnection(connectionId, {
            type: "chat_message",
            data: message,
          })
        )
      );
    } else {
      // Send push notification (offline user)
      await this.sendPushNotification(toUserId, {
        title: `Message from ${message.senderName}`,
        body: message.content,
        data: { chatId: this.getChatId(fromUserId, toUserId) },
      });
    }
  }
}

Real-Time Features

Instant Messaging:

• Individual DMs with read receipts
• Group chats with unlimited participants
• Typing indicators and presence
• Media sharing (images, audio clips)
• Message persistence and history

Live Features:

• Real-time "Now Playing" updates
• Live chat during events
• Synchronized playlist collaboration
• Push notifications for nearby shows
• Real-time follower notifications

Data Architecture

Based Music uses a sophisticated multi-table DynamoDB design optimized for access patterns and scale.

Database Schema Design

Key Design Decisions:

• 12+ DynamoDB tables with optimized access patterns
• Global Secondary Indexes for efficient queries
• Composite keys for one-to-many relationships
• Search term denormalization for fast lookups
• TTL-based cleanup for ephemeral data (connections, sessions)
• Single-table design considered but rejected for simpler debugging and independent scaling

Mobile App Architecture

The React Native app is built for performance and user experience excellence.

Mobile Performance Optimizations:

• FlashList for 60 FPS scrolling (replaces FlatList)
• react-native-fast-image for image caching and optimization
• Memoization with React.memo and useMemo for expensive renders
• Code splitting with dynamic imports for faster initial load
• Background audio with full system integration
• Offline support with queue-based sync on reconnect

Development Journey

Cost Optimization: 60% Reduction

Achieved dramatic cost savings through intelligent architecture decisions:

Serverless-First Approach:

• Lambda for compute (pay per invocation)
• DynamoDB On-Demand for unpredictable traffic patterns
• S3 Intelligent Tiering for automatic cost optimization
• API Gateway with caching for reduced backend calls

Caching Strategy:

• CloudFront CDN: Reduced origin requests by 80%
• Redis (ElastiCache): Multi-tier caching for metadata and streams
• Client-side caching: Aggressive caching in mobile app

Result: $0.003 per user/month infrastructure cost at scale

Comprehensive Platform Results

Technical Performance Metrics

User Growth & Engagement

User Base:

• 10,000+ users onboarded in first 3 months
• 65% MAU retention (monthly active users)
• 4.8/5 average app store rating
• 3 countries currently served

Engagement Metrics:

• 45% increase in session duration with AI recommendations
• 3.2x more track discoveries per session
• 68% of plays come from AI-recommended tracks
• 10+ new local artists discovered per user monthly

Platform Growth Statistics

Content Library:

• 50,000+ tracks uploaded and processed
• 500+ verified artists actively using the platform
• 200+ venues registered for event hosting
• 1,000+ events created and managed

Social Activity:

• 100,000+ messages sent via real-time chat
• 25,000+ follows between users
• 5,000+ playlist creations
• 15,000+ event RSVPs

Community Impact & Business Value

Based Music has created measurable impact on local music ecosystems:

For Artists

• 3x increase in local show attendance after platform promotion
• Direct fan engagement through messaging and events
• Streaming revenue potential through future monetization
• Analytics dashboard for understanding audience

For Venues

• 25% boost in ticket sales for promoted events
• Reduced marketing costs through platform discovery
• Capacity management with RSVP system
• Geographic targeting for local audiences

For Music Fans

• Discovery of 10+ new local artists per user monthly
• Event notifications for nearby shows (location-based)
• Community building through shared music tastes
• Curated experiences via AI recommendations

Technical Challenges & Solutions

Challenge 1: iOS Audio Performance (900ms Initial Load)

Root Causes:

• OGG codec not natively supported on iOS
• Full file download before playback initialization
• No caching strategy for repeat plays
• Inefficient S3 access patterns

Solution:

• Real-time transcoding Lambda (OGG → AAC)
• Range request implementation with 64KB initial chunks
• Multi-tier caching (Redis + CloudFront + client)
• Intelligent codec detection per device

Result: 87% faster (900ms → 120ms)

Challenge 2: Real-Time Messaging at Scale

Root Causes:

• WebSocket connections expensive to maintain
• Message ordering and delivery guarantees needed
• Presence tracking across multiple devices
• Push notifications for offline users

Solution:

• Connection pooling with DynamoDB tracking
• Message queue system with SQS + Lambda processing
• TTL-based cleanup for stale connections
• Expo push notification fallback for offline delivery

Result: <50ms message latency with 99%+ delivery rate

Challenge 3: Search Performance Across Multiple Tables

Root Causes:

• DynamoDB doesn't support full-text search natively
• Multi-table queries are complex and slow
• Need relevance scoring (exact > starts-with > contains)
• Case-insensitive search required

Solution:

• Search term denormalization in all tables
• Parallel DynamoDB scans for short queries
• Relevance scoring algorithm
• Lowercase indexing for case-insensitivity
• Cross-table pagination tokens

Result: Sub-200ms search across entire platform

Challenge 4: AI Recommendation Cold Start

Root Causes:

• New users have no listening history
• Content-based filtering alone produces poor results
• Need immediate value for user retention

Solution:

• Hybrid recommendation system:
  • Audio feature extraction for content-based
  • Location-based initial recommendations
  • Genre preferences from onboarding
  • Collaborative filtering as history builds
• Pre-computed similarity matrices for popular tracks

Result: Quality recommendations from day 1, 45% engagement boost

Security & Compliance

Authentication & Authorization:

• AWS Cognito for user management
• JWT tokens with refresh rotation
• Role-based access control (Artist/Listener/Venue)
• OAuth integration (Google)

Data Protection:

• Encryption at rest (S3, DynamoDB)
• Encryption in transit (HTTPS, WSS)
• User data deletion capabilities (GDPR compliance)
• Secure media upload validation

Content Moderation:

• Automated profanity filtering
• User reporting system
• Content takedown workflow
• Copyright compliance infrastructure

What's Next: Future Innovation

The platform roadmap focuses on advanced features and monetization:

Near-Term (Q2 2025)

1. Audio Fingerprinting: Automatic content identification (Shazam-like) using Lambda infrastructure already in place
2. HLS Adaptive Streaming: Live event broadcasts with adaptive quality
3. Collaborative Playlists: Real-time collaborative editing with CRDTs (Conflict-free Replicated Data Types)
4. Enhanced Analytics: Artist dashboard with deep audience insights

Medium-Term (Q3-Q4 2025)

5. Revenue Sharing System: Blockchain-based instant payouts for artist streams
6. Virtual Events: Ticketed live streams with chat integration
7. AI Music Tools: Experimental AI collaboration tools for artists
8. Social Features: Feed algorithm optimization, stories, live status

Long-Term Vision

• Global Expansion: Multi-language support, international markets
• Label Partnerships: Distribution deals with independent labels
• Festival Integration: Official festival app partnerships
• AI-Generated Content: Ethical AI music creation tools

Technical Lessons Learned

What Worked Well

1. Serverless-first approach enabled rapid scaling without infrastructure management
2. Multi-tier caching dramatically improved performance and reduced costs
3. DynamoDB design with multiple tables simplified debugging and scaling
4. React Native + Expo accelerated cross-platform development
5. Early performance optimization paid dividends as user base grew

What We'd Do Differently

1. Single-table DynamoDB might be reconsidered for more complex query patterns
2. Earlier analytics implementation would have provided better growth insights
3. More aggressive A/B testing for UI/UX decisions
4. GraphQL instead of REST for more flexible client queries
5. Earlier monetization planning to guide feature prioritization

Conclusion

Based Music demonstrates how modern cloud architecture, AI/ML, and thoughtful engineering can create a comprehensive platform that serves a real community need. The combination of professional-grade audio streaming (87% performance improvement), AI-powered discovery (45% engagement boost), and real-time social features has created a thriving music ecosystem used by 10,000+ users and 500+ artists.

The platform showcases expertise in:

• Distributed systems design (three-tier architecture, microservices)
• Performance engineering (caching, streaming optimization, mobile performance)
• AI/ML implementation (TensorFlow, vector search, recommendations)
• Real-time systems (WebSockets, event-driven architecture)
• Cost optimization (60% reduction through serverless)
• Full-stack development (React Native, Node.js, Python, AWS)

Based Music isn't just a music app—it's a comprehensive technical achievement that's fostering local music communities worldwide.