www.skipq.

org
Course Curriculum
Prerequisites: Basic knowledge of Python and/or JavaScript/TypeScript programming
Course Project: A Full-Stack engineer graduating from this course will design, develop and deploy
production-grade web applications using MERN stack or related technologies. The engineer will set up an
Express application which will serve as your middleware API layer, set up a React application as the
frontend, CRUD operations on MongoDB, integrate SSO (Github and OAuth), create tables that will contain
paginated data as well as perform search on the paginated data, create charts and graphs using HighCharts
to display different metrics and data, and write unit test cases using Cypress.
The engineer will also run the application across multiple AWS Regions. They will use CI/CD to automate
multiple deployment stages (prod vs beta), write unit/integration tests to continuously deploy the
application without human intervention and automate metrics to rollback a deployment in case of service
degradation.

Sprint-wise Instruction Plan

Sprint Learning Objectives

Sprint 1 Project: Use AWS CDK to build a canary in a Lambda function. This canary runs in one AWS
Region and measures availability and latency when accessing a predefined, public web
application. Push the code to versioning control repo. Manage README files in markdown on
GitHub.
Concepts:
● Introduction to Cloud Computing and Infrastructure-as-Code (IaC)
● Introduction to AWS: Regions/AZs/Edge Services, Foundational services (EC2, S3,
CloudFront), Microservice architecture
● Learn AWS Services: IAM, Lambda
● Learn Tools: Shell and Scripting, Vim, GitHub
● Start writing code on AWS

Sprint 2 Project: Extend the canary Lambda function into a web crawler -- crawl a custom list (json file)
of websites from an S3 bucket, also including webpages that should be crawled on these
websites.
Run the crawler periodically on a 5 min cadence and write <availability, latency> metrics for
each website and each run to CloudWatch using CloudWatch’s API. Create a CloudWatch
Dashboard to monitor website health, and set up alarms when availability or latency falls below
prescribed thresholds. Every alarm is also published to SNS/SQS notifications with tags that can
be used to filter by metric type. Push the code to versioning control repo. Manage README
files and runbooks in markdown on GitHub.
Concepts:
● Introduction to the Art of Monitoring Web Applications
● Learn AWS Services: CloudWatch, SNS/SQS

1
 www.skipq.org

● Introduce scalability in web application

Sprint 3 Project: Create multi-stage pipeline having Beta/Gamma and Prod stage using CDK. Deploy the
project code in 1 Region. Each stage must have bakeTimes, code-review, and test blockers.
Write unit/integration tests for the web crawler. Emit CloudWatch metrics and alarms for
operational health of the web crawler, including memory and time-to-process each crawler run.
Automate rollback to the last build if metrics are in alarm. Manage README files and runbooks
in markdown on GitHub.
Concepts:
● Introduction to CI/CD
● Learn AWS services: CodePipeline for build and test, CodeDeploy for CD
● Integrate AWS CodePipeline with GitHub
● Learn automated testing using PyTest running
● Build a release process by writing merge-blocking automated tests for the canary on
CodePipeline
● Build operational CloudWatch metrics for web crawler
● Write rollback automation allowing rollback to last build
● Setup beta and prod environments in CodePipeline and deploy using CodeDeploy

Sprint 4 Project: Build an Express Application with CRUD API functionality defined for the web crawler to
create/read/update/delete the list of websites/webpages to crawl. First, move the JSON file
from S3 to a MongoDB database. Then implement CRUD REST commands on MongoDB entries.
Your Express application should run inside an EC2 instance with a public IP and should trigger
an AWS Lambda which interacts with the MongoDB database. Register your application with
AWS Route 53 using a fully qualified domain name. Write API documentation and commit to
GitHub. Manage README files and runbooks in markdown on GitHub.

Concepts:
● Learn key backend concepts: Express, NodeJS, MongoDB
● Set up Express application
● Set up MongoDB
● Write a RESTful interface for reading/writing web crawler output/input
● Persist web crawler results in MongoDB
● Learn how to use cloud Domain Name System (DNS) web service.

Sprint 5 Project: Build a frontend application using React.js and a Material UI design system for the
MongoDB CRUD API. Frontend application should has a text field where users can type in a URL
and then perform one of the following operations:
1/ Add a new URL to the DB (MongoDB). Return a “Already Exists” if the added URL is already
present in the DB.
2/ Delete a URL from the DB. Return a “Not Found” error if the URL is not present in the DB.
When implementing the above operations, ensure that you are checking that the value entered
in the text field is a valid URL.
3/ Search the DB for a particular URL. Return a “Not Found” error if the URL is not present in
the DB. If the URL is found then:
- Show a table with the URL and all its sub-URLs. Table should be paginated with only 5 entries
showing per page.

2
 www.skipq.org

- Plot the CloudWatch metrics for Latency and Availability for that URL in the past 1 week. Use
HighCharts.js library for plotting the time-series data. These graphs should remain visible as you
scroll through pages.
- If the URL has child links then plot the 10 child links using D3.js library’s Hierarchy graphs.
This graphs should remain visible as you scroll through pages.
Write at least 15 test cases using Cypress for the above functionality. Results of the test runs
should be committed to GitHub as a table that includes Test ID, description, timestamp,
pass/fail. A user guide for the frontend application should also be committed to GitHub.

Concepts:
● Learn how to create a frontend app with React
● Connect frontend React app with a backend database (MongoDB)
● Learn how to use graph libraries to visualize data: HighCharts, D3 Hierarchy.

Sprint 6 Project: Add authentication to your app through a login screen that uses AWS Cognito or
equivalent OAuth method (Auth0, Okta, or Frontegg). Authentication should allow users to
login using username/password, GitHub account, or Gmail account. Implement a
watcher/alerter functionality in the UI, where you can attach a watcher to any URL. If that
URL’s latency increases or availability decreases beyond a certain threshold then publish an
alert on a web-socket. Write a lambda function that continuously listens on this web socket and
pushes it to SNS (you can use the lambda you created previously).
Use threads to implement the watcher functionality–one thread per URL, rate limit the threads.
Lazy load the watcher functionality only when the user uses it.
Manage README files and runbooks in markdown on GitHub.

Concepts:
● Learn OAuth and its integration into a frontend app
● Learn real-time communication/notification through web-socket
● Learn advanced javascript concepts: lazy loading, threading