Jump to a Section

There's a ton of information further down this page. Click the section you want to jump to.

Research & Ideation

Phase One: ~ 1 week

You'll begin by generating three unique SaaS startup ideas. Then you'll perform subject-matter research, competitor research, legal research and more to determine which of the three ideas you should choose. Finally you'll narrow your ideas down to one, and write a short business plan.
Research & Ideation

Design & Tech Specs

Phase Two: ~ 2 weeks

You'll go through a multi-step UX and UI design process to flush out your ideas. You'll create storyboards, flowcharts, wireframes, user stories, full-color mockups and clickable prototypes for your entire application. Then you'll choose your tech stack, spec out your cloud infrastructure, and design your backend APIs.
Design & Tech Specs

Infrastructure & DevOps

Phase Three: ~ 2 weeks

Now it's time for you to spin up your servers, setup your database, and create CI / CD pipelines for your application. You'll also secure your workstation, setup password & key management, and begin to organize your tasks and paperwork more deliberately.
Infrastructure & DevOps

Backend Development

Phase Four: ~ 12 weeks

You'll build the full backend of your application, starting with scaffolding (like user-signup-flows and checkout-flows), and the progressing into more application-specific features. If you follow our example, you'll build and deploy 2 different RESTful APIs, and a realtime Websocket API.
Backend Development

Frontend Development

Phase Five: ~ 8 weeks

Now it's time to build the frontend web client for your application. You'l begin by building the flow for your users' primary device use-case (laptop, tablet or mobile), and then branch out to the other device categories. Your frontend will hook into the APIs you built in the backend section, and integrate build tools and pre-processors to get it all working properly.
Frontend Development

Launching & Iterating

Phase Six: ~ 4 weeks

Once your code is complete, you'll begin the launch process. First, your application needs to go through QA, Pentesting, Load Testing, and Speed Testing to ensure it's ready for launch. Then you need to setup your analytics and monitoring tools, invite beta users and solicit early-user feedback before going fully public.
Launching & Iterating

Marketing & SEO

Phase Seven: ~ 6 weeks

Now that your application is live, you need to drive traffic to it. We'll show you a lot of different techniques: from Adwords and Youtube marketing, to Facebook Ads, to Twitter, LinkedIn, Youtube and more. We'll also show you different SEO techniques, how to setup an affiliate program, and how to get early press-coverage for your launch.
Marketing & SEO

Conversion Rate Optimization

Phase Eight: ~ 7 weeks

Users are visiting your site now, but very few of them are likely becoming customers. That's the problem we'll aim to solve now. We'll go through several different abandonment-prevention techniques you can use to keep people on your site, social-proof techniques you can use to add legitimacy to your business, and split-testing techniques you can use to begin adjusting your UI and UX in methodical and data-driven ways.
Conversion Rate Optimization

User Retention & Engagement

Phase Nine: ~ 5 weeks

Getting users to convert is only half the picture. Now you've got to keep them as loyal customers. We'll show you how to reward your power-users, stop other users from "churning" or going "stale", and provide customer service when your users have issues they can't solve on their own.
User Retention & Engagement

Scaling & Automation

Phase Ten: ~ 5 weeks

By now, you're likely overwhelmed with the sheer amount of work you need to do every day to keep your business going. So it's time to begin automating your manual processes: from customer service, to content-review, to vendor payouts and more. If you've begun to get market traction, then it's also time to refactor your code for scale and build new automated systems that candle a massive throughput and peaky traffic.
Scaling & Automation


Sprinkled into Phases 1-10

Unfortunately, running a business requires doing a lot of things that aren't particularly fun. While we'll try to focus your attention on the 10 phases above, you'll intermittently need to stop and do administrative work: Hire lawyers, buy insurance, pay taxes, and fill out lots and lots of forms. Unfortunately it comes with the territory.

Our Tech Stack

Backend Languages and Systems

  • Node.js

    Our primary user-API and Admin API will both be built in Node.js. We'll have Node running in Docker containers and also as AWS Lambda functions.

  • Golang

    In the 2nd half of the course, we'll run complex split-tests on our users, and generate lots of data that needs to be ingested. We'll use Golang to build a robust endpoint to send all that data to.

  • Java

    Creating the news-feeds for our users will require massive, parallel map-reduce jobs to run on Hadoop. We'll use Java and AWS EMR to script these jobs.

  • Lua

    Our user API will have a Kong Gateway sitting in front of it. We'll use Lua to configure Kong, and integrate it tightly with our upstream CDN to synchronize user blacklisting and rate-limiting capabilities.

  • Erlang

    Before we launch, we'll build our own server-monitoring tools and dashboards. To monitor processes we'll build our own "agent" by adding a custom Erlang plugin to RabbitMQ.

  • Python

    The functionality of our application will rely heavily on user and content recommendations. Our recommendation engine will be built with Python, using Tensorflow.

  • PHP

    We'll be building two PHP sites, completely separate from our main application: The first is a simple "StatusPage" in Wordpress that we'll customize to integrate into our Uptime Monitoring tools. The 2nd is a knowledgebase built in MediaWiki. We'll use PHP to autopopulate that knowledgebase with data ingested from our Customer Service interactions.

  • Ruby

    We'll need a simple, reliable and lightweight API to receive incoming webhooks and send the incoming-data up to our SQS queues for processing. We'll use Ruby and Sinatra to make this happen.

  • R

    All of our split-testing data will end up in a massive data lakes. We'll pull that data down into R Studio and use R to run statistical analysis on it to determine how our split-tests went, and mine actionable insights from that information.

Databases, Datastores and Queues

  • MongoDB

    Much our user data will primarily be stored in MongoDB. Mongo's schema-less design gives us the flexibility to adjust our data structure and indexes on the fly, and supports complex geo-location based searches that will be useful when building our endpoints.

  • RethinkDB

    We'll use RethinkDB as the datastore for our websocket API. Its' native support for push-notifications and data updates make it perfect for a service that needs to keep users up-to-date without polling.

  • Neo4j

    Neo4j is a "graph database", and it will enable us to easily track relationships between our users (such as who is following who), our content categories and our content tags.

  • Cassandra

    Our Kong API Gateway needs a database attached to it, to store configuration information and meta data about our services. We'll use Cassandra for this, allowing us to store lots of flexible data without worrying about scale or schemas.

  • PostgreSQL

    We'll need a general purpose SQL database to power our customer knowledgebase. PostgreSQL integrates seamlessly with MediaWiki (the framework we'll be using), so it's the obvious choice.

  • DynamoDB

    Our user tokens and session information will need to go to a key-value store that is infinitely scalable without any performance degradation. DynamoDB fits this use-case perfectly. And as it's a database-as-a-service, we won't need to worry about management or administration.

  • ElasticSearch

    Robust searching functionality will be crucial to both our user-experience and our admin workflow. ElasticSearch will allow us to setup scalable full-text searches of many different kinds of information quickly and easily.

  • Redis

    The speed of our API will become a factor when we're scaling up and optimizing the user experience. We'll use Redis as a caching layer for some GET requests to make sure we can return responses and load data on the page as quickly as possible.

  • Memcached

    Our status page (built in Wordpress) will likely be slower than we want it to be. When an outage is happening, loading the status-page quickly is of utmost importance. So we'll use Memcached to speed up the loading process and show our users that critical information without delay.

  • Amazon S3

    We'll be using AWS S3 as for general-purpose media storage, and as a "data lake" for massive amounts of meta data and user information.

  • Big Query

    When we build our own split-testing system, we'll setup our data-ingestion endpoint to push all data into Big Query. This will allow us to scale up our dataset, and export it to R Studio easily.

  • Hadoop (HDFS)

    When building our map-reduce jobs on Amazon EMR, we'll use HDFS data as the basis for our queries.

Frontend Frameworks & Tools

  • Vue

    The bulk of our user experience will be built with Vue.js. Using this framework will allow us to move quickly, and build huge amounts of functionality without needing to write much boilerplate.

  • React

    Our Admin Dashboard will use the React framework. React's modular / component based design is a perfect fit for a dashboard that will have dozens of separate components and lot's of functionality.

  • Angular

    When we build our custom monitoring-dashboards, we'll be using a framework called Ionic which is built on top of Angular. These dashboards will be local applications (not websites) that stream live data in from the custom Erlang agents we'll have installed on each server in our system.

  • Foundation

    The Foundation framework (by Zurb) will give us enough structure to get going, but not too much style. We want our site to look unique (not like a cookie-cutter Bootstrap site), and using Foundation will give us the flexibility to customize the components and make our frontend look exactly like our original designs.

  • Bootstrap

    Our Admin dashboard will be built using Twitter's Bootstrap library. Since this is an internal tool, we don't need it to look unique. Bootstrap will give us the components we need to build our functionality, and we'll easily find a pre-built theme that matches what we need.

  • Material Design

    For our custom dashboards, we'll need basic design components without much scaffolding. As the majority of the dashboard functionality will be custom built, we don't need a large framework like Bootstrap or Zurb. For that reason we're choosing to use the Material Design system for this part of our build.

  • Web Assembly (WASM)

    After we launch, we'll begin refactoring the functionality the functionality on our main site, and choosing key components to speed up and optimize. We'll use Web Assembly whenever possible to make any complex or computationally-intensive processes as snappy as possible for our users.

  • WebSockets

    Much of our user experience will rely on basic API calls. But some things (like our messaging-flow and alert-notifications) will happen through a realtime websocket connection.

  • SASS

    Not to be confused with "SaaS" (Software as a Service), SASS is a css preprocessor we'll be using on the frontend. Writing SASS instead of CSS will allow us to do fancy things like creating reusable variables and nesting directives inside of each other.

Continuous Integration & Deployment (CI/CD)

  • Github

    The majority of our code will be stored on Github, though much of it will be reference repos stored on NPM. We'll use to Github organize not only our source, but our bugs and issues as well.

  • CircleCI

    There are a lot of CI/CD pipelines available, but we've found CircleCI to best fit out needs. When users commit code to Github, it will trigger CircleCI to test, build and ship that code where it needs to go. In some cases, they'll build the code in Docker containers, in others they'll zip the data up into packages for AWS Lambda.

  • Docker Hub

    Once our Docker containers are built, we'll need to store the images somewhere. Docker Hub is designed for that. We'll have our build tool push the newly create images to the hub and tag them according to their commit meta data.

Hosting and Cloud Infrastructure

  • Route 53

    Our DNS settings will be managed by Route 53 in some cases, and by CloudFlare in others. Route 53 has special functionality that lets us route zones to ELBs easily, so we'll use it when scaling up and setting-up our load balancers.

  • Elastic Load Balancers

    AWS ELBs will be an indispensable part of our scaling infrastructure. They'll allow us not only to route traffic to a cluster of servers, without worrying about throughput limitations.

  • EC2 Servers

    The workhorse of the AWS cloud, we'll use the EC2 servers to hold our docker containers, monitoring agents, and some database instances.

  • ElasticSearch Service

    As we need our ElasticSearch instances to scale effortlessly , we'll use Amazon's Elastic Search Serving ice rather than having to administer the datastores ourselves.

  • Relational Database Service (RDS)

    A few of our databases (like the PostgreSQL powering our knowledgebase, and the MySQL powering the statuspage) are a good fit for RDS. As it's fairly expensive, we'll use this service sparing, for our lower-throughput needs.

  • Simple Queue Service (SQS)

    Much of our "reactive" infrastructure will revolve around queues. Incoming webhook data will go to queues, background processes will consume from queues, etc. SQS will be our primary queuing mechanism as scales to massive throughput for little expense.

  • API Gateway

    Setting up a websocket API can be a pain. We'll use the AWS API Gateway to set one up within minutes, and plug it into AWS lambda so that our entire websocket API is serverless and scales easily.

  • Lambda

    We'll be using AWS Lambda in a number of ways, with a few different languages. Many of our background jobs, as well as our websocket-connection processors will be running as Lambda tasks.

  • EMR and Step Functions

    We'll be using the AWS Elastic Map Reduce and Step-Functions services to setup data ingestion and processing pipelines. We'll be running Map Reduce jobs to generate user feeds, and step-functions to trigger them.

  • Glacier

    Anything that can be backed up, will be. As backups don't need to be retrieved very often, they're a perfect fit for Amazon Glacier. We'll get all the functionality of cloud storage at a fraction of the cost.

  • Transcribe

    We'll use the Amazon Transcribe service (and other related services) to create automated captions and transcripts of the video content on our site.

  • Glue

    AWS Glue will allow us to perform ETL (Extract Transform Load) operations on some of our data lakes and object stores, to push them to other services and back them up to AWS Glacier.

Integrations & 3rd Party APIs

  • Stripe

    We'll use Stripe as our primary payment processor, and also use Stripe Connect to collect payments on behalf of sellers in the marketplace we're building.

  • Paypal

    We'll allow users to checkout via Paypal, and setup IPN notifications to process their orders. We'll also allow Paypal to be used as a pay-out method for sellers on our marketplace.

  • Coinbase

    Integrating with Coinbase Commerce will allow us to easily accept Bitcoin, LiteCoin, Ethereum and other digital currencies on our site.

  • Mailgun

    We'll use Mailgun in two ways: To send transaction emails to users (such as receipt and welcome emails), and to verify the validity of emails when users register on our site (using Mailgun's email validation API).

  • ConvertKit

    Our email-based drip and nurture-sequences will be powered by ConvertKit. This will allow us to customize our onboarding process, as well as our retention and conversion flows easily.

  • Vimeo

    As our new business will focus around video content, we need a video host and player who prices fairly irrespective of bandwidth usage, and who allows us to use an embedded chromeless player with domain-level restrictions. Vimeo fits the bill for this use-case, so we'll be integrating with them.

  • Cloudinary

    We'll be using Cloudinary to host our images and some of our video content. As they can transform and serve images on the fly, they're an indispensable service for our frontend.

  • IP Stack

    When building our geo-pricing API, we'll use ipstack to help determine user-location, and the Numbeo API to determine the cost of living in their area. This will help us determine the price(s) to show to them.

  • Twilio

    Our 2-Factor Auth flow will include a less-secure SMS based 2FA flow (for users who don't want to use a digital 2FA mechanism). This will be powered by Twilio, which we'll use to not only send the SMS messages, but verify that the phone numbers are not VOIP (using Twilio's Phone Number Verification API).

  • Facebook Messenger

    Near the end of the course, we'll begin automating processes, including customer service. We'll build our chatbot, using different machine-learning and Natural Language Processing tools, and we'll use Facebook Messenger as the bot's frontend.

  • Bill.com

    When it comes to issuing payouts to vendors on our marketplace, it's hard to find a better solution than bill.com. Using Bill will allow us to easily pay thousands of users programmatically via several different payout methods, with little overhead.

  • QuickBooks

    The Quickbooks platform makes accounting and bookkeeping fairly simple. We'll integrate with their web API to automatically send transaction data (payments and payouts) as well as vendor payments to our accounting dashboards. This will make tax-time much more simple for us in the long run.

Security Tools & Features

  • Vault

    Hashicorp's Vault software is a secure method for storing and retrieving any kind of sensitive information. Early in our course, we'll wipe and secure our workstations, and then implement a Vault-centric workflow to store and access sensitive data.

  • Secrets Manager

    Think of the AWS Secrets Manager as a cloud service similar to Vault. We'll use it secure the keys and auth credentials we need to store in the cloud, and it will be the central repository our applications interact with when they need to retrieve a sensitive token or credential.

  • Password Managers

    When securing your workstation, we'll show you several tools (1password, Dashlane, and LassPass) that you can use to secure the web passwords you'll be generating for a variety of services.

  • Guard Duty

    We'll be using AWS's Guard Duty service to help us monitor and secure our private cloud, and all the other AWS services we're using

  • Strong Crypto

    We'll be using strong cryptography to hash and encrypt sensitive user information, like passwords. We'll be showing you how to use Argon2 and Bcrypt so you can do the same on your site, for any sensitive info your users give you.

  • JSON Web Tokens

    For convenience, portability and security, we'll be using the JWT (JSON Web Tokens) as our primary method of transmitting authentication information between clients and servers. To prevent CSRF attacks, we'll use HttpOnly cookies in conjunction with JWT, and use the "double submit" method to verify requests.


    We'll be using two different kinds of Captcha mechanisms to help secure our site agains bot scraping and fake profiles. We'll use the standard reCAPTCHA v2 to secure our signup and login forms, and the newer reCAPTCHA v3 to run as a background process that alerts us to suspicious user behavior. This will let us take appropriate action on the frontend (like showing the user additional challenges, or blocking them entirely).

  • Pentesting & Bounty Programs

    Before we launch our site, we'll be using pentesting tools to scan for security issues, and hiring outside Pentesters to do the same. We'll also create a "Bug Bounty" program, and a Responsible Disclosure Policy to help mediate potentially malicious attacks, by rewarding the would-be attackers for finding vulnerabilities. We'll link to these programs prominently, include a hackers.txt file on our site root, and embed messages to hackers in the source of our public pages.

  • HaveIBeenPwned

    We'll integrate HaveIBeenPwnd notifications into our user management system. When we receive a HaveIBeenPwnd notification for one of our users, we'll automatically rotate their password and 2FA mechanism, alert them, and require them to reset it. We'll also integrate HaveIBeenPwned into our own workflow, and monitor the site for any exposure of our Admin credentials.

  • Mandatory 2-Factor Auth

    On our site, 2-factor authentication will be compulsory for all users, upon registration. We'll offer both a digital 2FA (so that users with an Authenticator App or Yubikey can use it), and SMS based 2FA for users who don't have such capabilities. Though SMS is a much weaker form of 2FA, we feel it's significantly better than nothing.

  • Firewall

    We'll be building a complex firewall at multiple levels in our application. This will help us guard against unwanted HTTP methods (such as are used in XST), brute force attacks, DDOS attacks and more. We'll be implementing this firewall on our CDN, our ELBs, our API Gateway and within our application.

  • Cyber Liability Insurance

    As a backup plan, we'll also be taking out a Cyber Liability Insurance plan, so that if an attack happens, our business won't be a total loss. We'll also pre-plan an SOP that we can follow in case of an attack and can the emails that we'll need to send out to users if that ever happened. While we hope to never need to use the insurance or the SOP, it's better to plan ahead than be caught without a plan.

Course curriculum

  • 1
    Week 1
    • Welcome to the SaaS Master Class
    • Trigger the Email Sequence
    • Ideation: Choose Three Ideas
    • Research: Get Informed
    • Research: Potential-Customer Profiles
    • Research: Know the Law
    • Ideation: Make a Choice
    • Ideation: Storyboards
    • Ideation: : Flow Charts
  • 2
    Week 2
    • Design: Wireframes
    • Ideation: Naming & Slogans
    • Ideation: Branding & Logos
    • Design: Full-Color Desktop Designs
    • Design: Full-Color Responsive Designs
    • Design: Clickable Prototypes
    • Ideation: : Admin Storyboards
  • 3
    Week 3
    • Ideation: : Admin Flow Charts
    • Design: Admin Wireframes
    • Tech Specs: Bridge the Gap
    • Tech Specs: API Documentation
    • Tech Specs: Background Worker Documentation
    • Tech Specs: Database PseudoSchema
    • Research: Find Your Tools
  • 4
    Week 4
    • Research: Find Your Hosts
    • Administration: Get Organized
    • Paperwork: Time to Incorporate
    • Paperwork: Get Your Permits
    • Administration: Get a Lawyer
    • Infrastructure: Secure Your Workstation
    • Infrastructure: Manage Passwords and Private Keys
  • 5
    Week 5
    • Infrastructure: Domains & Email Setup
    • Administration: Register Everything
    • Full Stack: Pre-Launch Page
    • Infrastructure: Version & Container Control
    • Infrastructure: Setup & Secure Your Servers
    • Infrastructure: CI / CD Setup
    • Infrastructure: SSL & ELB Setup
  • 6
    Week 6
    • Backend: Kong API Gateway
    • Backend: Hello World API
    • Frontend: Hello World Frontends
    • Infrastructure: Basic System Monitoring
    • Infrastructure: Database Setup & Configuration
    • Backend: API Routing & Configuration
    • Backend: Blacklist & Error Handlers
  • 7
    Week 7
    • Backend: API Logging & Rate Limiting
    • Backend: User Registration
    • Backend: Adding Email Confirmation
    • Backend: Adding Username Support
    • Backend: Detecting Bot Registrations
    • Backend: Adding 2-Factor Auth
    • Backend: User Login Flow
  • 8
    Week 8
    • Backend: User Logout Flow
    • Backend: Password Resets
    • Backend: Account & Profile Settings
    • Backend: Payment & Payout Settings
    • Backend: User Account Deletion
    • Backend: Shopping Cart Setup
    • Backend: Checkout With Stripe
  • 9
    Week 9
    • Backend: Checkout With Paypal
    • Backend: Checkout With Bitcoin
    • Backend: Subscription Payments
    • Backend: Account Credits
    • Backend: Order History & Invoices
    • Backend: User Messages
    • Backend: User Alerts
  • 10
    Week 10
    • Backend: Pushing Browser Notifications
    • Backend: Admin DB Schema & Docs
    • Backend: Admin API Routing & Configuration
    • Backend: Admin Error Handlers
    • Backend: Admin API Logging
    • Backend: Google Sign On for Admins
    • Backend: Launch & Error Switches
  • 11
    Week 11
    • Backend: Admin Listing All Users
    • Backend: Admin Banning, Purging and Dumping Users
    • Backend: Admin Deleting and Retrieving Users
    • Backend: Admin Forcing User Logouts
    • Backend: Admin Reserving Usernames
    • Backend: Admin Managing Privacy Policies
    • Backend: Admin Health & Activity Metrics
  • 12
    Week 12
    • Backend: Admin View All Orders
    • Backend: Admin Cancel & Refund Orders
    • Backend: Admin View & Edit Subscriptions
    • Backend: Admin Support Ticket Management
    • Backend: Admin Sending User Notifications
    • Backend: Admin Processing User Payouts
    • Backend: Admin Moderating Flagged Content
  • 13
    Week 13
    • Backend: Admin Disciplinary Actions
    • Backend: Admin Moderating Photos & Text
    • Backend: Admin Managing Products & Services
    • Backend: Admin GeoPricing Setup
    • Backend: Admin GeoPricing Setup
    • Backend: Admin Coupon Management
    • Backend: Admin Search
    • Backend: Admin Alerts
  • 14
    Week 14
    • Backend: Realtime Database Setup
    • Backend: Websocket API Setup
    • Backend: Websocket Authentication
    • Backend: Realtime Messages & Alerts
    • Backend: Following & Unfollowing
    • Backend: Viewing & Liking Content
    • Backend: Uploading & Submitting Videos
  • 15
    Week 15
    • Backend: User Feeds
    • Backend: Editing & Managing Videos
    • Backend: User Profiles
    • Backend: Public Video Page
    • Backend: Video Unlocking
    • Backend: Video Ratings
    • Backend: Video Comments
  • 16
    Week 16
    • Backend: Content Sharing
    • Backend: Recommended Content
    • Backend: Top Content
    • Backend: Latest Content
    • Backend: Trending Content
    • Backend: Recommended Users
    • Backend: Top Users
  • 17
    Week 17
    • Backend: Latest Users
    • Backend: Trending Users
    • Backend: Hashtags within Topics
    • Backend: Get Categorized Search Results
    • Backend: Admin Approve New Categories
    • Backend: Approve New Tags
    • Backend: Admin Approve Videos & Edits
  • 18
    Week 18
    • Backend: Admin View All Videos
    • Backend: Admin Moderate Video Comments
    • Backend: Admin Category Management
    • Backend: Admin Index Management
    • Frontend: Documentation & Wikis
    • Frontend: Build Tools
    • Frontend: Page Scaffolding
  • 19
    Week 19
    • Frontend: General-Purpose Libraries
    • Frontend: API Interaction Library
    • Frontend: Websocket Interaction Library
    • Frontend: Auth & Refresh Token Library
    • Frontend: Stylesheet Setup
    • Frontend: Basic Navigation
    • Frontend: Error Pages
  • 20
    Week 20
    • Frontend: Switch-Thrown Pages
    • Frontend: Basic Registration
    • Frontend: CAPTCHA Integration
    • Frontend: Browser Notification Setup
    • Frontend: Login / Logout Flow
    • Frontend: Password Reset Flow
    • Frontend: User Profile
  • 21
    Week 21
    • Frontend: Payment Settings
    • Frontend: Shopping Cart
    • Frontend: Checkout Flow - Stripe, Paypal & Bitcoin
    • Frontend: Subscription Checkout
    • Frontend: Order & Transaction History
    • Frontend: Message Center
    • Frontend: Alert Management
  • 22
    Week 22
    • Frontend: Responsiveness Tweaks
    • Frontend: Websocket Messages
    • Frontend: Admin Sign-in-with-Google
    • Frontend: Admin List Users
    • Frontend: Admin Delete and Retrieve Users
    • Frontend: Admin Dumping and Purging Users
    • Frontend: Admin Force User Logout
  • 23
    Week 23
    • Frontend: Admin Reserved-Usernames Management
    • Frontend: Admin Health & Activity Metrics
    • Frontend: Admin Manage Orders
    • Frontend: Admin Manage Subscriptions
    • Frontend: Admin Manage Support Tickets
    • Frontend: Admin Manage Payouts
    • Frontend: Admin Moderate Content
  • 24
    Week 24
    • Frontend: Admin Manage Products & Services
    • Frontend: Admin Search Functionality
    • Frontend: Admin Coupon Management
    • Frontend: Admin Styling Tweaks
    • Frontend: Following & Unfollowing
    • Frontend: Video Submission Process
    • Frontend: Manage All Videos
  • 25
    Week 25
    • Frontend: View & Unlock Video
    • Frontend: User News Feed
    • Frontend: User Profiles
    • Frontend: Video Comments
    • Frontend: Video Sharing
    • Frontend: Category Browsing
    • Frontend: Search Results
  • 26
    Week 26
    • Frontend: Styling Tweaks
    • Frontend: Admin Category Management
    • Frontend: Admin Content Moderation
    • Frontend: Admin Video Approval
    • Frontend: Admin Home Page Management
    • Frontend: Admin Styling Tweaks
    • Launching: Copytext & Pricing
  • 27
    Week 27
    • Launching: Canned Emails & Notification Copy
    • Launching: Status Page Management
    • Launching: Complex Health Checks
    • Launching: Auto-Redeployment Systems
    • Launching: Cross-Browser Testing on Desktop
    • Launching: Cross-Browser Testing on Mobile
    • Launching: QA Testing
  • 28
    Week 28
    • Launching: Demo User Management
    • Launching: Speed Testing
    • Launching: Load Testing
    • Launching: XST, XSS and MITM Checks
    • Launching: Penetration Testing & Bug Bounty Programs
    • Launching: Off-the-Shelf Monitoring Dashboards
    • Launching: Custom Monitoring Agent
  • 29
    Week 29
    • Launching: Custom Monitoring Dashboards
    • Launching: Preparing Your Code for Launch
    • Launching: Throwing the Switch
    • Launching: Verifying & Sanity-Checking All Systems
    • Launching: Garbage Traffic Testing
    • Launching: Inviting Friends & Family
    • Launching: Inviting Beta Users
  • 30
    Week 30
    • Launching: Automated & Manual Feedback
    • Launching: Monitoring Vulnerabilities
    • Launching: Basic SOP Setup
    • Launching: Take a Deep Breath
    • Marketing: Initial Blast
    • SEO: Basic Onsite SEO Techniques
    • SEO: Prerendering and Serving Bot Content
  • 31
    Week 31
    • SEO: Webmaster Tools Basics
    • SEO: Rich Snippets
    • SEO: Shareable Content
    • SEO: Internationalization
    • SEO: High Volume SEO Techniques
    • SEO: Basic Offsite SEO Techniques
    • Marketing: In-Depth Competitor Analysis
  • 32
    Week 32
    • Marketing: In-Depth Market Analysis
    • Marketing: Determining CPA
    • Marketing: Setting a Budget & Strategy
    • Marketing: Twitter Techniques
    • Marketing: Instagram Techniques
    • Marketing: Youtube Techniques
    • Marketing: Facebook Techniques
  • 33
    Week 33
    • Marketing: LinkedIn Techniques
    • Marketing: Pinterest Techniques
    • Marketing: Snapchat, Tiktok and Others
    • Marketing: Syndication & Automation Tools
    • Marketing: Influencer Marketing
    • Marketing: Blog Post Marketing
    • Marketing: Quora Techniques
  • 34
    Week 34
    • Marketing: Networking & Meetups
    • Marketing: Adwords Search
    • Marketing: Adwords Display Network
    • Marketing: Adwords Youtube
    • Marketing: Adwords Shopping
    • Marketing: Adwords API
    • Marketing: Retargeting
  • 35
    Week 35
    • Marketing: Conferences
    • Marketing: Tradeshows
    • Marketing: Affiliate Networks
    • Marketing: Building an Affiliate Program
    • Marketing: Podcasts
    • Marketing: Swag & Giveaways
    • Marketing: Flyers
  • 36
    Week 36
    • Public Relations: Overview
    • Conversions: Tracking Key Metrics
    • Conversions: Background Stat Recalculation
    • Conversions: Adding Metrics to Admin Dashboard
    • Conversions: Mapping User Flow
    • Conversions: Identifying User Choke Points
    • Conversions: Frontend Speed Improvements
  • 37
    Week 37
    • Conversions: Backend Speed Improvements
    • Conversions: Using Surveys
    • Conversions: Abandoned Cart Reminders
    • Conversions: Tracking Abandoned Pages
    • Conversions: Tracking Abandoned Signups
    • Conversions: Basic Split Testing
    • Conversions: Building a Split-Testing System
  • 38
    Week 38
    • Conversions :Customized Split Tests
    • Conversions: Multiple Parallel Split Tests
    • Conversions: Processing Split-Test Data
    • Conversions: Adding Machine-Learning to Split Testing
    • Conversions: Automated Split-Test Variables
    • Conversions: Using Campaign Landing Pages
    • Conversions: Using Lead Magnets
  • 39
    Week 39
    • Conversions: Newsletter & Email Marketing Basics
    • Conversions: Nurture Sequence Basics
    • Conversions: eBooks to Nurture Sequences
    • Conversions: Free Trials to Nurture Sequences
    • Conversions: Free Tiers to Nurture Sequences
    • Conversions: Lead Collections to Nurture Sequences
    • Conversions: The Long Sale
  • 40
    Week 40
    • Conversions: Price Optimization
    • Conversions: Refund Policy Optimization
    • Conversions: Customer Service Popups for Abandonment Prevention
    • Conversions: Hello Bars
    • Conversions: Exit-Intent Popups
    • Conversions: Social Proof Notifications
    • Conversions: Social Proof - User Groups
  • 41
    Week 41
    • Conversions: Social Proof - Review Sites
    • Conversions: Social Proof - Forum Sites
    • Conversions: Address Mapping
    • Conversions: Phone Number Prominence
    • Conversions: Security & Payment Option Prominence
    • Conversions: As Seen On / As Mentioned In
    • Conversions: Testimonials
  • 42
    Week 42
    • Conversions: Wikipedia Techniques
    • Conversions: Google Places & Yelp
    • Conversions: Acquiring Legitimate Reviews
    • Conversions: Explainer Video Process
    • Conversions: Explainer Video Process
    • Conversions: Explainer Video Cartoons
    • Conversions: Explainer Video Voiceovers
    • Conversions: Explainer Video Screencasts
  • 43
    Week 43
    • Conversions: Explainer Video Media Licences
    • Conversions: What not to do
    • Retention: Tracking Key Metrics
    • Retention: Background Workers to Recalculate Metrics
    • Retention: Adding Stats to Admin Dashboard
    • Retention: User Onboarding Tours & Videos
    • Retention: User Onboarding Sequences
  • 44
    Week 44
    • Retention: Re-Engagement Emails for Unused Services
    • Retention: Notifications & Emails for Used Services
    • Retention: Badge Rewards
    • Retention: Power User Identification
    • Retention: Loyalty Programs
    • Retention: Recommended Content Improvements
    • Retention: Top Content Improvements
  • 45
    Week 45
    • Retention: Latest Content Improvements
    • Retention: Trending Content Improvements
    • Retention: Recommended User Improvements
    • Retention: Top User Improvements
    • Retention: Latest User Improvements
    • Retention: Trending User Improvements
    • Retention: Tag-to-Tag Relationship Improvements
  • 46
    Week 46
    • Retention: User-to-Tag Relationship Improvements
    • Retention: User Categorization & Tagging
    • Retention: Proactive Techniques for Stale Users
    • Retention: Proactive Techniques for Failed Payments
    • Customer Service: Creating an SOP
    • Customer Service: Plugins Revisited
    • Customer Service: Facebook Messenger
  • 47
    Week 47
    • Customer Service: Knowledgebase Manual Setup
    • Customer Service: Organizing Support Messages
    • Customer Service: Organizing Support Emails
    • Customer Service: Handling Bug Reports
    • Customer Service: Secondary Refund & Gifting Policies
    • Customer Service: International Customer Support
    • Customer Service: Trolls and Problem Users
  • 48
    Week 48
    • Customer Service: Social Media for Customer Service
    • Scaling: Determining when to Scale
    • Scaling: Load Balancing Techniques
    • Scaling: Multiple Availability Zones (AZs)
    • Scaling: Multiple Regions
    • Scaling: Multiple Hosts
    • Scaling: Refactoring Services for Scale
  • 49
    Week 49
    • Scaling: Refactoring Services for Cost
    • Scaling: Scaling in a Reversible Way
    • Scaling: Autoscaling Systems
    • Automation: Alternative Re-Deployments
    • Automation: Automated Deployment Rollbacks
    • Automation: Automated Phone Line
    • Automation: DRM Scanner
  • 50
    Week 50
    • Automation: Building a Basic Chatbot
    • Automation: Preloading the Chatbot
    • Automation: Using Interactions to Train the Chatbot
    • Automation: Using Interactions to Build a Knowledgebase
    • Automation: Using ML to screen and approve images
    • Automation: Using ML to screen and approve text
    • Automation: Using ML to screen and approve categories
  • 51
    Week 51
    • Automation: Using ML to screen and approve tags
    • Automation: Using ML to screen and approve video content
    • Automation: Using ML to Automate Payouts
    • Automation: Automating QA with Selenium Tests
    • Automation: Automating QA with MTurk HITs
    • Automation: Automating Adwords
    • Automation: Automating Twitter Ads
  • 52
    Week 52
    • Automation: Automating Facebook & Instagram Ads
    • Automation: Automating Influencer Marketing
    • Automation: Automating Bookkeeping
    • Automation: Using ML to Refine Sitemaps
    • Administration: Outsourcing Your Remaining Tasks
    • Administration: So What's Next?
  • 53
    • Demo Day

The Course Prerequisites

In order to complete this course, you must know Javascript, and one full backend stack. During week three, you will decide the best way to build your application. You don't have to use the same stack as us.

I don't meet the prerequisites


  • What application will we build in the course?

    In the first week you'll come up with 3 startup ideas, and then do research to narrow them down to one. The startup you end up choosing to build will be unique. It's up to you to decide what idea to move forward with and what company to start.

  • I don't know all the technologies you're using. Do I need to know them all?

    No, absolutely not. During the course, you'll draw up tech-specs for your new business, and determine the best stack for the application you want to build. You decide what stack you build in. The tools we're using are well suited to our use-case(s), they won't necessarily apply to yours.

  • Some of the languages and databases seem redundant, why are you using so many different ones?

    They're definitely not redundant. Every piece of technology was chosen for its unique strengths. In the tech-stack section(s) above, you can read about our particular use-cases for each part of the stack.

  • I see the class started on June 3rd, is enrolling late possible?

    Yes, you can enroll anytime. We'll deliver one new lecture to your inbox each day. The course will take a year to complete, no matter when you start it. Don't worry about falling behind the other students, it's not a race.

  • What are the total costs of starting a company in this course?

    That's impossible to answer, unfortunately. Every company is different. I really depends on what you decide to build.

But wait, there's more!

Your pirple.com subscription also includes access to our other courses.

It's time to invest in yourself!

Pirple.com memberships are designed to give you the skills and knowledge you need to stay competitive as a Software Engineer.