diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 0000000..87f4f75
Binary files /dev/null and b/.DS_Store differ
diff --git a/Assignments/Sample_Project.md b/Assignments/Sample_Project.md
new file mode 100644
index 0000000..d1c5a30
--- /dev/null
+++ b/Assignments/Sample_Project.md
@@ -0,0 +1,2 @@
+## Project Description
+## Project requirements
diff --git a/Assignments/Sample_Rubric.md b/Assignments/Sample_Rubric.md
new file mode 100644
index 0000000..e69de29
diff --git a/Lessons/Lesson1.md b/Lessons/Lesson1.md
new file mode 100644
index 0000000..87c4b51
--- /dev/null
+++ b/Lessons/Lesson1.md
@@ -0,0 +1,64 @@
+## Minute-by-Minute [OPTIONAL]
+
+| **Elapsed** | **Time** | **Activity** |
+| ----------- | --------- | ------------------------- |
+| 0:00 | 0:05 | Objectives |
+| 0:05 | 0:15 | Overview |
+| 0:20 | 0:45 | In Class Activity I |
+| 1:05 | 0:10 | BREAK |
+| 1:15 | 0:45 | In Class Activity II |
+| TOTAL | 2:00 | |
+
+# Why you should know this or industry application (optional) (5 min)
+
+Explain why students should care to learn the material presented in this class.
+
+## Class Learning Objectives/Competencies (5 min)
+
+1. Identify and describe
+1. Define
+1. Design
+1. Implement
+
+## Initial Exercise (15 min)
+
+- Funny comic
+- Prime the Pump (e.g. think and jot, think pair share, etc)
+- Productivity Tip/Tool
+- Review of current event (e.g. tech news relevant to your track/topic)
+- Quiz on homework or topic(s) of past class
+- Concept Test
+
+## Overview/TT I (20 min)
+
+- Why learn this?
+- Industry examples of usage
+- Best practices
+- Personal anecdote
+
+## In Class Activity I (30 min)
+
+- I do, We do, You do
+- Reading & Discussion Questions in small groups
+- Draw a picture/diagram
+- Complete Challenges solo or in pair
+- Q&A about tutorials
+- Pair up and code review
+- Pair program
+- Formative assessment
+- Form into groups
+- etc (get creative :D)
+
+## Overview/TT II (optional) (20 min)
+
+## In Class Activity II (optional) (30 min)
+
+## Wrap Up (5 min)
+
+- Continue working on your current tutorial
+- Complete reading
+- Complete challenges
+
+## Additional Resources
+
+1. Links to additional readings and videos
diff --git a/Lessons/Lesson2.md b/Lessons/Lesson2.md
new file mode 100644
index 0000000..aed068b
--- /dev/null
+++ b/Lessons/Lesson2.md
@@ -0,0 +1 @@
+COPY YOUR Lesson 1 format
diff --git a/README-old.md b/README-old.md
new file mode 100644
index 0000000..ab5ae52
--- /dev/null
+++ b/README-old.md
@@ -0,0 +1,154 @@
+# SEM-1.1-GraphQL
+
+Senior Seminar with GraphQL
+
+This is proposal for a possible class to run term 3 2019.
+
+Feel free to comment with any suggestions, words of encouragement, and expressions of interest.
+
+# GraphQL Class Proposal
+
+This is a proposal for a senior seminar. To run in term 3 2018.
+
+## Overview
+
+GraphQL is an open source data query and manipulation language for APIs, and runtime for fulling data requests.
+
+Graph QL is a language and a specification and can be used with a variety of server technologies.
+
+As a clientside language GraphQL allows a client to describe a request, including providing query parameters, and what it expects in return.
+
+As a server side specification GraphQL describes how a server should fullfill a query. The GraphQl spec can be implemented in any serverside technology for example SQL or Node.
+
+### Advantages
+
+Reduces a routes to a single endpoint. With REST you will need an endpoint for each of many different types of requests. With GraphQL you would use a **single endpoint for all requests**.
+
+Removes over and under fetching of data. With REST data returned from a request is usually a fixed dataset and includes a full range of data. Using GraphQL you can **specify exactly what you want returned**.
+
+With REST there is a need to define an end point for each type of request at the server. With GraphQL all requests are written at the client. This makes product iteration faster.
+
+- Develop applications faster since you can create new routes by just writing code on frontend.
+- Using a single endpoint simplifies your work.
+- Make more effecient applications by avoiding over fetching and under fetching data.
+
+## Core Concepts
+
+The GraphQL language uses a JS like syntax. Below are some examples of the code you would write in the GraphQL language.
+
+### SDL (Schema Definition Language)
+
+Strong Schemas make for more robust and reliable systems.
+
+```
+type Post {
+ title: String!
+ author: Person!
+}
+```
+
+### Query
+
+Queries written on the frontend make for faster more effecient development.
+
+```
+{
+ allPosts {
+ title
+ }
+}
+```
+
+Nested data can be requested in a query.
+
+```
+{
+ allPosts {
+ title
+ comments {
+ subject
+ }
+ }
+}
+```
+
+Queries can have parameters
+
+```
+{
+ allPosts(first: 2) {
+ title
+ }
+}
+```
+
+Mutations are for CRUD
+
+```
+mutation {
+ createPost(title: "Learn GraphQL", content: "...") {
+ title
+ content
+ }
+}
+```
+
+### Subscriptions
+
+GraphQL supports real time updates with Subscriptions.
+
+### Backend technologies
+
+GraphQL integrates with all of the technologies you are familiar with: React, Node, Elixir, Ruby, Python, and more.
+
+On the clientside GraphQL queries are written as strings and so work with any frontend technology.
+
+## Class Projects
+
+- Hackernews Tutorial
+- Contractor Project
+- Custom Project
+
+## Syllabus
+
+- Intro
+ - What is GraphQL?
+ - Benefits
+ - REST vs GraphQL
+ - Vocabulary
+ - GitHub GraphQL API Server
+ - https://developer.github.com/v4/
+- Getting started
+ - Writing a Query
+ - Formatting a query
+ - Passing arguments
+ - Required arguments
+- GraphQL Schemas
+ - Schemas
+ - Types
+ - Querying a Schema
+- Handling Data
+
+### Other possible topics
+
+- Queries and Mutations
+- Schemas and Types
+- Validation
+- Execution
+- Best Practices
+- Thinking in Graphs
+- Authorization
+- Pagination
+- Caching
+
+Class/homework
+
+- Working with GraphQL the language
+ - Use the online editor https://graphql.org/learn/
+- Working with GraphQL and an API
+ - Use this series of videos here: https://www.youtube.com/watch?v=lAJWHHUz8_8&list=PL0zVEGEvSaeEjIDdbK1KfR7V9XBCVAr0P
+- Build a GraphQL server with Python, Ruby, and JS
+ - https://www.youtube.com/watch?v=UBGzsb2UkeY
+- Build GraphQL Server with node and express mongo
+ - https://blog.apollographql.com/tutorial-building-a-graphql-server-cddaa023c035
+
diff --git a/README.md b/README.md
index d18f77d..65e197e 100644
--- a/README.md
+++ b/README.md
@@ -1,144 +1,164 @@
-# SEM-1.1-GraphQL
+# Title
+
+## Course Description
+
+Describe your course here. A short elevator pitch for the course. This will be listed as the course description in the course catalog.
+
+### Why you should know this (optional)
+
+Explain why students should care to learn the material presented in this class.
+
+## Course Specifics
+
+Weeks to Completion: 7
+Total Seat Hours: 37.5 hours
+Total Out-of-Class Hours: 75 hours
+Total Hours: 112.5 hours
+Units: 3 units
+Delivery Method: Residential
+Class Sessions: 14 classes, 7 labs
+
+## Prerequisites:
+
+- Prerequisite 1
+- Prerequisite 2
+
+## Learning Objectives (5-8)
+
+Students by the end of the course will be able to ...
+
+1. Identify & Describe
+1. Explain
+1. Compare & Contrast
+1. Design & Implement
+1. Master
-Senior Seminar with GraphQL
-
-This is proposal for a possible class to run term 3 2019.
-
-Feel free to comment with any suggestions, words of encouragement, and expressions of interest.
-
-# GraphQL Class Proposal
-
-This is a proposal for a senior seminar. To run in term 3 2018.
-
-## Overview
-
-GraphQL is an open source data query and manipulation language for APIs, and runtime for fulling data requests.
-
-Graph QL is a language and a specification and can be used with a variety of server technologies.
-
-As a clientside language GraphQL allows a client to describe a request, including providing query parameters, and what it expects in return.
-
-As a server side specification GraphQL describes how a server should fullfill a query. The GraphQl spec can be implemented in any serverside technology for example SQL or Node.
-
-### Advantages
-
-Reduces a routes to a single endpoint. With REST you will need an endpoint for each of many different types of requests. With GraphQL you would use a **single endpoint for all requests**.
-
-Removes over and under fetching of data. With REST data returned from a request is usually a fixed dataset and includes a full range of data. Using GraphQL you can **specify exactly what you want returned**.
-
-With REST there is a need to define an end point for each type of request at the server. With GraphQL all requests are written at the client. This makes product iteration faster.
-
-- Develop applications faster since you can create new routes by just writing code on frontend.
-- Using a single endpoint simplifies your work.
-- Make more effecient applications by avoiding over fetching and under fetching data.
-
-## Core Concepts
-
-The GraphQL language uses a JS like syntax. Below are some examples of the code you would write in the GraphQL language.
-
-### SDL (Schema Definition Language)
-
-Strong Schemas make for more robust and reliable systems.
-
-```
-type Post {
- title: String!
- author: Person!
-}
-```
-
-### Query
-
-Queries written on the frontend make for faster more effecient development.
-
-```
-{
- allPosts {
- title
- }
-}
-```
-
-Nested data can be requested in a query.
-
-```
-{
- allPosts {
- title
- comments {
- subject
- }
- }
-}
-```
-
-Queries can have parameters
-
-```
-{
- allPosts(first: 2) {
- title
- }
-}
-```
-
-Mutations are for CRUD
-
-```
-mutation {
- createPost(title: "Learn GraphQL", content: "...") {
- title
- content
- }
-}
-```
-
-### Subscriptions
-
-GraphQL supports real time updates with Subscriptions.
-
-### Backend technologies
-
-GraphQL integrates with all of the technologies you are familiar with: React, Node, Elixir, Ruby, Python, and more.
-
-On the clientside GraphQL queries are written as strings and so work with any frontend technology.
-
-## Class Projects
-
-- Hackernews Tutorial
-- Contractor Project
-- Custom Project
-
-## Syllabus
-
-- Intro
- - What is GraphQL?
- - Benefits
- - REST vs GraphQL
- - Vocabulary
- - GitHub GraphQL API Server
- - https://developer.github.com/v4/
-- Getting started
- - Writing a Query
- - Formatting a query
- - Passing arguments
- - Required arguments
-- GraphQL Schemas
- - Schemas
- - Types
- - Querying a Schema
-- Handling Data
-
-### Other possible topics
-
-- Queries and Mutations
-- Schemas and Types
-- Validation
-- Execution
-- Best Practices
-- Thinking in Graphs
-- Authorization
-- Pagination
-- Caching
-
-https://graphql.org/learn/
+
+
+## Schedule
+---
+### _INSTRUCTOR NOTE: PLEASE REMOVE THIS BEFORE SUBMITTING_
+If you teach **M/W** or **Tu/Th**, please pick from a template below and delete the other one
+
+---
+### M/W Template
+**Course Dates:** Monday, January 21 – Wednesday, March 6, 2019 (7 weeks)
+
+**Class Times:** Monday and Wednesday at 3:30–5:20pm (10 class sessions)
+
+| Class | Date | Topics |
+|:-----:|:----------------------:|:---------------------------------------:|
+| - | Monday, January 21 | **MLK Jr. Day** |
+| 1 | Wednesday, January 23 | [Lesson 1] |
+| 2 | Monday, January 28 | [Lesson 2] |
+| 3 | Wednesday, January 30 | [Lesson 3] |
+| 4 | Monday, February 4 | [Lesson 4] |
+| 5 | Wednesday, February 6 | [Lesson 5] |
+| 6 | Monday, February 11 | [Lesson 6] |
+| 7 | Wednesday, February 13 | [Lesson 7] |
+| - | Monday, February 18 | **President's Day (Observed)** |
+| 8 | **Tuesday, February 19** | [Lesson 8] |
+| 9 | Wednesday, February 20 | [Lesson 9] |
+| 10 | Monday, February 25 | [Lesson 10] |
+| 11 | Wednesday, February 27 | [Lesson 11] |
+| 12 | Monday, March 4 | Final Class (presentations, etc) |
+| 13 | Wednesday, March 6 | Final Exams/Presentations |
+
+### Tu/Th Template
+**Course Dates:** Tuesday, January 22 – Thursday, March 7, 2019 (7 weeks)
+
+**Class Times:** Tuesday and Thursday at 3:30–5:20pm (12 class sessions)
+
+| Class | Date | Topics |
+|:-----:|:----------------------:|:---------------------------------------:|
+| 1 | Tuesday, January 22 | [Lesson 1] |
+| 2 | Thursday, January 24 | [Lesson 2] |
+| 3 | Tuesday, January 29 | [Lesson 3] |
+| 4 | Thursday, January 31 | [Lesson 4] |
+| 5 | Tuesday, February 5 | [Lesson 5] |
+| 6 | Thursday, February 7 | [Lesson 6] |
+| 7 | Tuesday, February 12 | [Lesson 7] |
+| 8 | Thursday, February 14 | [Lesson 8] |
+| - | Tuesday, February 19 | **President's Day (Observed)** |
+| 9 | Thursday, February 21 | [Lesson 9] |
+| 10 | Tuesday, February 26 | [Lesson 10] |
+| 11 | Thursday, February 28 | [Lesson 11] |
+| 12 | Tuesday, March 5 | Final Class (presentations, etc) |
+| 13 | Thursday, March 7 | Final Exams/Presentations |
+
+[Lesson 1]: Lessons/Lesson1.md
+[Lesson 2]: Lessons/Lesson2.md
+[Lesson 3]: Lessons/Lesson3.md
+[Lesson 4]: Lessons/Lesson4.md
+[Lesson 5]: Lessons/Lesson5.md
+[Lesson 6]: Lessons/Lesson6.md
+[Lesson 7]: Lessons/Lesson7.md
+[Lesson 8]: Lessons/Lesson8.md
+[Lesson 9]: Lessons/Lesson9.md
+[Lesson 10]: Lessons/Lesson10.md
+[Lesson 11]: Lessons/Lesson11.md
+[Lesson 12]: Lessons/Lesson12.md
+
+## Class Assignments [Remove header if you like]
+- List (with links) of all course-level assignments (i.e. tutorials, challenge sets, contractor project, custom projects, etc)
+- Under each assignment link the rubric used to evaluate it or describe how it is evaluated.
+- Projects should be linked to a project page which has a description & requirements.
+
+### Tutorials
+[REWORD AS RELEVANT TO YOUR COURSE] Tutorials are to help you get started in a topic. They are graded on completion only.
+
+- [Do Cool Stuff Tutorial]()
+
+### Projects
+**All projects will require a minimum of 10 commits, and must take place throughout the entirety of the course**
+
+- **Good Example:** 40+ commits throughout the length of the course, looking for a healthy spattering of commits each week (such as 3-5 per day).
+- **Bad Example:** 10 commits on one day during the course and no others. Students who do this will be at severe risk of not passing the class.
+- **Unacceptable Example:** 2 commits the day before a project is due. Students who do this should not expect to pass the class.
+
+#### Why are we doing this?
+
+We want to encourage best practices that you will see working as a professional software engineer. Breaking up a project by doing a large amount of commits helps engineers in the following ways:
+
+- It's much easier to retrace your steps if you break your project/product/code up into smaller pieces
+- It helps with being able to comprehend the larger problem, and also will help with your debugging (i.e. finding exactly when you pushed that piece of broken code)
+- It allows for more streamlined, iterative communication in your team, as it's much easier to hand off a small change to someone (updating a function) than a huge one (changed the architecture of the project)
+
+Through this requirement, we hope to encourage you to think about projects with an iterative, modular mindset. Doing so will allow you to break projects down into smaller milestones that come together to make your fully-realized solution.
+
+[REWORD AS RELEVANT TO YOUR COURSE] Projects are a chance for you to build and ship code that is based on class concepts. Many are open ended allowing you to be creative and to have individual work for your portfolio.
+- [Sample Project](Sample_Project.md)
+ - [Sample Project Rubric](Sample_Rubric.md)
+
+### Other Class assignments
+
+## Evaluation
+[MAKE SPECIFIC TO YOUR COURSE SO IT IS SUPER CLEAR]
+To pass this course you must meet the following requirements:
+
+- Complete all required tutorials
+- Pass all projects according to the associated project rubric
+- Pass the final summative assessment >=75%
+- Actively participate in class and abide by the attendance policy
+- Make up all classwork from all absences
+
+## Attendance
+Just like any job, attendance at Make School is required and a key component of your success. Attendance is being onsite from 9:30 to 5:30 each day, attending all scheduled sessions including classes, huddles, coaching and school meetings, and working in the study labs when not in a scheduled session. Working onsite allows you to learn with your peers, have access to support from TAs, instructors and others, and is vital to your learning.
+
+Attendance requirements for scheduled sessions are:
+- No more than two no call no shows per term in any scheduled session.
+- No more than four excused absences per term in any scheduled session.
+
+Failure to meet these requirements will result in a PIP (Participation Improvement Plan). Failure to improve after the PIP is cause for not being allowed to continue at Make School.
+
+
+## Make School Course Policies
+
+[Academic Honesty](https://make.sc/academic-honesty)
+[Accommodations for Students](https://make.sc/accommodations-for-students)
+[Attendance Policy](https://make.sc/attendance-policy)
+[Diversity and Inclusion Policy](https://make.sc/diversity-and-inclusion-policy)
+[Grading System](https://make.sc/grading-system)
+
+[Title IX Policy](https://make.sc/title-ix-policy)
+[Program Learning Outcomes](https://make.sc/program-learning-outcomes)
diff --git a/notes.md b/notes.md
new file mode 100644
index 0000000..0fef85e
--- /dev/null
+++ b/notes.md
@@ -0,0 +1,29 @@
+Intro
+
+- Are the students already familiar with REST/HTTP? If so, I’d do the REST vs GraphQL part even before the benefits. If students are not yet familiar with REST, maybe leave the comparison out altogether? I think the comparison with REST can be a super helpful tool in explaining how GraphQL works, but if the students don’t know REST it would be somewhat pointless. (Although I’d assume most students are familiar with REST?!).
+- What are you planning to teach under “Vocabulary”? I don’t think I’d start with a section that tries to map out all terms/concepts upfront but rather introduce students to these concepts as they go and they need them (I’m thinking about things like schema directives, subscriptions, enum types, …). For the beginning I wouldn’t start with more than “schema”, “query” and “mutation” and the core concepts to be taught in the intro.
+- Great idea to include the GitHub API! Be aware that the API is sometimes not super intuitive to use (e.g. because it’s using the Relay-style pagination that traverses relations via the edges and node fields which is not very intuitive at first). Might be a good idea to think about a number of tasks upfront that the students should be accomplish when using the GitHub API. Otherwise it could be an idea to quickly spin up a Prisma GraphQL CRUD API that students can user to get familiar with queries and mutations.
+
+Getting Started
+
+- I think all the points in here can almost be included in the intro. I’d try to have a practical session at the end of the intro where the students explore writing GraphQL queries and mutations.
+- Talking about passing arguments to queries might be helpful in this section though.
+
+GraphQL schemas
+
+- For that topic, I highly recommend this article which I wrote roughly a year ago but which is pretty timeless because it really just talks about the foundation of GraphQL and no added pieces through any libraries. Writing the article took me several days but in the end I had a super good understanding of what GraphQL schemas actually are and how they work.
+- I think it’s super important for students to realise the connection between the schema and the available API operations. When talking about schemas, you should also always include a discussion about resolver functions so that students get the connection between the schema definition and implementation.
+- For the beginning, I’d recommend doing everything without a database and just store data in-memory.
+
+some suggestions for projects the students can do during the term.
+
+- Simple projects could be to implement build a GraphQL API that includes authentication and authorisation logic (backend)
+- Another idea could be to write a frontend application that talks to a GraphQL API (e.g. using Apollo Client)
+- Really advanced students could try implementing their own GraphQL client library for React (similar to Apollo Client, Urql or Relay)
+
+I hope that helps!
+
+Definitely let me know if you have any further questions, I’ll try to respond quicker next time! You can also reach me on the Make School Alumni Slack (or you can join our Prisma Slack where I’m always online). If you feel a longer discussion could be helpful we can also jump on a quick call :)
+
+Best wishes from Berlin,
+Nikolas
\ No newline at end of file
diff --git a/syllabus-guide.md b/syllabus-guide.md
new file mode 100644
index 0000000..78b0777
--- /dev/null
+++ b/syllabus-guide.md
@@ -0,0 +1,99 @@
+
+
+# Product College Course Template
+
+This guide applies to courses taught at the PC/Make School. Tutorials or other resources
+should either be created as tutorials (see below) or added to Product College labs.
+
+Courses are hosted at: [Product College Courses](https://github.com/Product-College-Courses)
+
+The course hosted on GitHub should be the source of information used by students
+during any term. Students can always refer to a course repo for the latest up to
+date information, links to resources, and other relevant information.
+
+The GitHub Repo will contain the syllabus and all of the course session outlines. It will
+also contain vocabulary, best practice, resources, and other information.
+
+Starter code, and resources that contain directories and files should be hosted at
+[Product College Labs](https://github.com/Product-College-Labs).
+
+## Create a new Course
+
+Create a new course on [Product College Courses](https://github.com/Product-College-Courses/).
+
+### Naming the course
+
+Courses should be named with catalog abbreviation and number followed by the description
+followed by the course name. For example, the course:
+
+> FEW 1.1 Advanced HTML CSS JavaScript
+
+would become:
+
+> FEW-1.1-Advanced-HTML-CSS-JavaScript
+
+### Intialize the Course with a README
+
+Intialize the course with a README.md. This will contain the course syllabus.
+
+### Initial the course with a License
+
+Choose the MIT license.
+
+## Use the Course Template
+
+Use the course [course-template](./course-template.md) as a starting point for your
+putting your course on the Product College Github.
+
+You can paste the contents of this template into your course README. What's important
+is the headings and outline. It's good for students if all courses follow the same
+structure.
+
+**Please follow this template! This is important for BPPE compliance.**
+
+Everything *not* marked *optional* should be included in the top level README in the
+Github repo.
+
+- [course-template](./course-template.md)
+
+### Use Markdown
+
+Write your class using Markdown. Follow the structure of the course template. Make
+sensible use of Headings, Lists, and other mark up.
+
+#### Tips
+
+Use Headings in order! Only one H1 heading per page. For example the page might start
+with an H1, the next heading will be an H2, if another sub topic appears that needs a
+heading use an H3. When the next new topic appears it is an H2.
+
+## Post to Product College Github
+
+Write your courses and post them to the product college Github.
+Courses should be posted to 'Product College Classes'.
+
+- https://github.com/Product-College-Courses
+
+### Organizing Examples and Resources
+
+If your class needs to link to large and complex sample/starter projects post these
+to 'Product College Labs'. Small sample files can be included in the main class
+repository.
+
+- https://github.com/Product-College-Labs
+
+# Product College Tutorials
+
+Tutorials can be lessons that you teach in class or other instructional material that
+you create for PC.
+
+When creating tutorials or other resources use the Summer Academy tutorial template.
+When completed submit it to the web team for inclusion in make School Web site.
+
+- https://github.com/MakeSchool-Tutorials/Tutorial-Template
+
+# Track your challenges with
+
+Alan's amazing google doc spreadsheet master tracker:
+
+- https://docs.google.com/spreadsheets/d/1FZJv2AolWFZRUwx0fWTIilXurwVmHnYz-RY9XxF-KPA/edit#gid=0