In Part 1 of this series, we discussed our approach to designing a minimal yet effective digital music e-commerce platform for Only Make Waves. We embraced the YAGNI (You Ain’t Gonna Need It) principle to build a lean, maintainable foundation. Now, in Part 2, we’ll explore how we scaled that foundation to handle high traffic, large file storage, seamless payments, and a global audience—while keeping performance and maintainability at the forefront.

Scaling the Backend for Performance

With the initial MVP in place, we faced new challenges: increasing concurrent traffic, optimizing database performance, and ensuring that music file delivery remained fast and reliable. Our backend, built with Ruby on Rails and PostgreSQL, required careful optimization to scale efficiently.

Database Optimization

1. Indexing Critical Queries

As the database grew, some queries started slowing down. We analyzed slow queries using pg_stat_statements and added indexes to optimize them:

CREATE INDEX index_songs_on_artist_id ON songs(artist_id);
CREATE INDEX index_purchases_on_user_id ON purchases(user_id);

2. Caching with Redis

We integrated Redis for caching frequently accessed data, reducing database load:

class SongController < ApplicationController
  def show
    song = Rails.cache.fetch("song_#{params[:id]}", expires_in: 12.hours) do
      Song.find(params[:id])
    end
    render json: song
  end
end

3. Read Replicas for Load Distribution

As our read-heavy traffic increased, we deployed PostgreSQL read replicas to offload queries:

class ApplicationRecord < ActiveRecord::Base
  connects_to database: { writing: :primary, reading: :replica }
end

Handling Large File Storage Efficiently

Streaming and selling music means handling large files efficiently. Instead of storing them in our database, we leveraged AWS S3 with CloudFront CDN for fast global delivery.

Uploading Files to S3

We used ActiveStorage to manage file uploads directly to S3, avoiding unnecessary server load:

class Song < ApplicationRecord
  has_one_attached :audio_file
end

To upload and retrieve files efficiently:

<%= form_with model: @song, local: true do |form| %>
  <%= form.file_field :audio_file %>
  <%= form.submit 'Upload' %>
<% end %>

Streaming Files Securely

To prevent unauthorized downloads, we used signed URLs from S3:

def generate_signed_url(song)
  obj = Aws::S3::Object.new(bucket_name: ENV['S3_BUCKET'], key: song.audio_file.key)
  obj.presigned_url(:get, expires_in: 3600) # 1-hour validity
end

Scaling the API for Global Access

To serve international customers, we ensured low latency API responses by deploying our backend on a multi-region architecture with AWS Elastic Load Balancer (ELB) and Amazon RDS Multi-AZ deployments.

Rate Limiting to Prevent Abuse

To prevent abuse and excessive API calls, we implemented Rate Limiting using Rack::Attack:

class Rack::Attack
  throttle('req/ip', limit: 100, period: 1.minute) do |req|
    req.ip
  end
end

Background Jobs for Heavy Tasks

Processing payments and delivering music files are resource-intensive tasks. We offloaded them using Sidekiq:

class PurchaseProcessorJob
  include Sidekiq::Worker

  def perform(purchase_id)
    purchase = Purchase.find(purchase_id)
    purchase.process!
    UserMailer.purchase_confirmation(purchase).deliver_now
  end
end

Improving the Checkout and Payment Flow

To ensure smooth transactions for customers, we integrated Stripe for handling payments and subscriptions.

Stripe::Charge.create(
  amount: (product.price * 100).to_i,
  currency: 'usd',
  source: params[:stripeToken],
  description: "Purchase of #{product.title}"
)

Secure Authentication and Fraud Prevention

To protect user accounts, we implemented 2FA (Two-Factor Authentication) using Devise + Twilio:

class Users::SessionsController < Devise::SessionsController
  before_action :check_otp, only: [:create]

  def check_otp
    if current_user&.otp_required_for_login?
      redirect_to verify_otp_path
    end
  end
end

Scaling Only Make Waves required a combination of backend optimizations, efficient storage strategies, global API distribution, and frontend performance improvements. By leveraging technologies like Redis, PostgreSQL replicas, S3, CloudFront, and Stripe, we ensured that the platform could handle increasing demand while maintaining a great user experience.

In Part 3, we’ll dive into the final phase of optimization—making it work, making it right, and making it fast.