Marcy Lab School Docs
  • Welcome
  • Student Guidelines & Policies
    • Student Handbook
    • AI Policy
    • Academic Calendar
  • Environment Setup
    • Local Environment Setup - Mac
    • Local Environment Setup - Windows
    • GitHub Setup
    • Postgres Setup
  • How-Tos
    • How To Code at Marcy: Code Style Guide
    • How to Do Short Response and Coding Assignments
    • How to Debug
    • How to PEDAC
    • How to Create A GitHub Organization and Scrumboard
    • How to Create Projects with Vite
    • How to Deploy on GitHub Pages
    • How to Deploy on Render
    • How to Test your API with Postman
  • Mod 0 - Command Line Interfaces, Git, and GitHub
    • Overview
    • 1. Command Line Interfaces
    • 2. Git & GitHub
    • 3. Git Pulling & Merging
    • 4. Git Branching & PRs
  • Mod 1 - JavaScript Fundamentals
    • Overview
    • 1. Intro to Programming
    • 2. Errors
    • 3. Node & Node Modules
    • 4. Variables, Functions & String Methods
    • 5. Control Flow, typeof, and Math
    • 6. Loops
    • 7. Arrays
    • 8. Objects
    • 9. Higher Order Functions: Callbacks
    • 10. Higher Order Functions: Array Methods
    • 11. Regex
  • Mod 2 - HTML, CSS & the DOM
    • Overview
    • 1. HTML
    • 2. CSS
    • 3. Accessibility (a11y)
    • 4. The Document Object Model (DOM) API
    • 5. Events
    • 6. Forms
    • 7. The Box Model and Positioning
    • 8. Flexbox
    • 9. Grid & Media Queries
    • 10. ESModules
    • 11. Vite
    • 12. LocalStorage
  • Mod 3 - Async & APIs
    • Overview
    • 1. Promises
    • 2. Fetch
    • 3. Building a Fetching App
    • 4. Async & Await
    • 5. A Generic Fetch Handler
  • Mod 4 - Project Week!
    • Important How Tos and Guides
      • How to Create a GitHub Organization and Scrum Board
      • How To Start a Project with Vite
      • How To Deploy a Project with GitHub Pages
    • Project Week Overview
    • Agile Methodologies
    • Deliverables & Milestones
    • Technical Requirements Checklist
    • Free API List
    • Collaborative GitHub
  • Mod 5 - Object-Oriented Programming
    • Overview
    • 1. Intro to OOP, Encapsulation, Factory Functions, and Closure
    • 2. Classes
    • 3. Private & Static
    • 4. UML Diagrams & Has Many/Belongs To Relationships
    • 5. Challenge: Implementing Has Many/Belongs To
    • 6. Inheritance
    • 7. Polymorphism
    • 8. Review and Practice
    • MDN: Object Prototypes
  • Mod 6 - Data Structures & Algorithms
    • Overview
    • Important How Tos and Guides
      • How to Debug
      • How to PEDAC
    • 1. Nodes & Linked Lists
    • 2. Singly & Doubly Linked Lists
    • 3. Stacks & Queues
    • 4. Recursion
    • 5. Trees
  • Mod 7 - React
    • Overview
    • Important How Tos and Guides
      • How to Create Projects with Vite
      • How to Deploy on GitHub Pages
    • 1. Intro to React
    • 2. Events, State, and Forms
    • 3. Fetching with useEffect
    • 4. React Router
    • 5. Building a Flashcards App
    • 6. React Context
    • 7. Global Context Pattern
  • Mod 8 - Backend
    • Overview
    • Important How Tos and Guides
      • How to Deploy on Render
      • How to Test your API with Postman
      • Postgres Setup
    • 1. Intro to Express
    • 2. Building a Static Web Server with Middleware
    • 3. Securing API Keys and Environment Variables
    • 4. RESTful CRUD API
    • 5. Model-View-Controller Architecture
    • 6. SQL and Databases
    • 7. JOIN (Association) SQL Queries
    • 8. Knex
    • 9. Your First Fullstack App!
    • 10. Migrations & Seeds
    • 11. Schema Design & Normalization
    • 12. Hashing Passwords with Bcrypt
    • 13. React Express Auth Template Overview
  • Mod 9 - Civic Tech Hackathon
    • Overview
    • Rubric
  • Mod 10 - Capstone
    • Overview
Powered by GitBook
On this page
  • 🧭 Overview
  • 🌈 What does Civic Tech Hackathon Represent in the Program Arc?
  • 🚀 How Will Civic Tech Hackathon feel?
  • 😌 What skills and mindsets lead to success?
  • 📆 Calendar, Rituals, and Support Meetings
  • 🕰️ Sample Schedule
  • 👥 Whole-Group Meetings
  • 🤝 Support Meetings
  • 🥲 Fridays and Weekends
  • 🏃 Sprints
  • ✅ Key Deliverables and Examples
  • Entity Relationship Diagram
  • Wireframe
  • Product Specifications Sheet
  • Polished GitHub Repository
  • Demo Day Presentation & Project Demo
  • 👀 What's Next
  1. Mod 9 - Civic Tech Hackathon

Overview

PreviousMod 9 - Civic Tech HackathonNextRubric

Last updated 1 month ago

Table of Contents

🧭 Overview

At the Marcy Lab School, training software engineers is just one of our ambitions. Our hope is that you become innovators and leaders.

Civic Tech Hackathon (CTH) is a three-week-long culmination of our Leadership & Development and Software Engineering curricula, resulting in more than just another technical project. CTH is an opportunity for you and your peers to come together to solve real-world problems facing your communities.

The final day of Civic Tech Hackathon will be Demo Day, where you will present your solution to an audience of friends, families, staff, mentors, volunteers, employers, funders, and members of the Marcy Lab School community at large!

🌈 What does Civic Tech Hackathon Represent in the Program Arc?

The Civic Tech Hackathon comes at the end of the third quarter of the Software Engineering Fellowship. In the Leadership & Development curriculum, you will have explored your personal and racial identities to better understand yourselves as individuals, community members, and technologists. You will have also spent time investigating how systems of power like racism, sexism, and classism can shape your own lives and the lives of your families and communities.

Simultaneously, by the close of Quarter 3, you will have built a strong foundation in JavaScript, problem-solving, and interface design. You will also have just finished the two most technically challenging technical units of the year: React and Backend. Throughout, you will have built projects to help you reinforce your learnings. The projects built during CTH will be your first full-stack projects!

CTH also represents a milestone moment for how you work. You began the year by working on your projects individually, before moving on to paired projects. During CTH, you will work in groups of 3 or 4, which will push you to higher levels of collaboration, communication, and project management than ever before.

During Civic Tech Hackathon, you will:

  • Draw from the content and skills developed in the Leadership & Development Curriculum to generate ideas you will build out in code

  • Utilize all the technical units of the curriculum

  • Test leadership skills developed in individual and group coaching

  • Practice teamwork, communication, and Agile project management

🚀 How Will Civic Tech Hackathon feel?

For you, we hope that the Civic Tech Hackathon will leave you feeling challenged, gratified, capable, and inspired.

  • Like college students studying for their final exams, your dedication to your project, combined with your discpline and work ethic, may result in some all nighters and long weekends as you strive to create the best product possible. We hope this leaves you feeling challenged and gratified.

  • Like members on a hackathon team, your planning, collaboration, and communication skills will be tested as you navigate a tight timeline with requirements to meet. We hope this leaves you feeling capable.

  • Like founders of a startup with dreams to change the world, your creativity and storytelling will be put the test as you build a product that meets a real need in your community. We hope this leaves you feeling inspired.

😌 What skills and mindsets lead to success?

Throughout the Software Engineering Fellowship, you have developed these skills and mindsets. Now it is time to put them to the test. To succeed during CTH, we believe you must demonstrate:

  • Collaboration: tap into your strengths and recognize the strengths of others to work effectively towards a common goal.

  • Compromise: sacrifice your own ambitions to ensure that deadlines are met.

  • Self-Efficacy: confidently take initiative to adapt and innovate to meet goals.

  • Professionalism: demonstrate strong work habits to act in the interests of the school and the greater Marcy community.

  • Communication: convey information, ideas, facts, and perspectives clearly and effectively in your speaking and writing

📆 Calendar, Rituals, and Support Meetings

🕰️ Sample Schedule

Below you can see a sample schedule for a typical week during Civic Tech Hackathon. As you can see, there is quite a lot of time for project work time!

Here are some key details to note:

  • Sprints will kick off on Thursdays

  • End-of-sprint demos and retrospectives on Wednesdays

  • Two code challenges per week

  • Daily mindful morning and stand up

  • Daily stand down

  • Two manager meetings per week

  • (Scrum Masters only) Scrum Master workshops

  • Lots of work time!

Below, you can learn more about each event.

👥 Whole-Group Meetings

These whole-group meetings will ensure you remain grounded and connected to your classmates! Share your wins, challenges, and the things you learn as you embark on this journey!

Mindful Morning

As usual, we will begin our days with meditation and journaling! In the second half of mindful morning, we will transition into stand up (see below).

Daily Stand Up and Stand Down

Check in with your team every morning and afternoon to align on team progress and priorities. Led by your scrum master, you will update your scrum board and share:

  • What progress you've made

  • What you plan on working on next

  • Questions / requests for support you have for the team

Code Challenge

Even during Civic Tech Hackathon, we will continue practicing our Code Challenge skills! However, Code Challenge will only occur on Tuesdays on Wednesdays.

Sprint Kickoffs

Start the sprint off strong by reviewing the milestones and deliverables for the current sprint. Led by your scrum master, meet with your team to update your scrum board and assign tickets.

Sprint Demos

Held weekly on the last day of each Sprint. Share the progress your team has made during the sprint and get feedback from your peers and instructors.

Sprint Retro

Held weekly after Sprint Demos, reflect on the successes (and missteps) of the previous sprint and make adjustments for the upcoming sprint. This is where you make progress as a team on how you work together to ensure that your sprint objectives are met.

🤝 Support Meetings

During each week-long sprint, you will have multiple touch points with your support staff whose aim is to ensure that you and your team are moving in the right direction and at the right pace.

Manager Meetings

Teams will meet twice per week with their instructional staff to share updates on their team's progress. Instructional staff can provide guidance and support on project planning, team communication, task distribution and prioritization, managing scope creep, and technical problem solving.

Scrum Master Group Coaching

This isn't shown on the calendar! With support and coaching from the instructional staff, scrum masters will gather once per week to discuss strategies for ensuring their team is remaining organized when it comes to completing their tasks and deliverables on time.

🥲 Fridays and Weekends

Should our team expect to work on Fridays, Saturdays, and Sundays? YES!

This is it! This is your final exam and your most important portfolio project to date. The time and effort you put into these three weeks may have a greater impact on your future career than any other three weeks in your entire life!

Collaborate with your team to find times over the weekends to communicate and get work done! By working on weekends you can get up to 6 days of extra work done over the course of these three weeks of CTH! That is almost an entire week of extra time, so take advantage of it!

🏃 Sprints

When building a fullstack project on a team over the course of multiple weeks, it is essential that everyone is aligned on what to prioritize.

Rather than aiming to build the entire application in one go, we've broken down CTH into 4 distinct sprints, each with their own objectives and priorities:

Sprint
Objectives / Priorities

0 - Planning

• Get final approval on the proposal. • Complete the Product Spec Sheet, ERD, and Mockups • Set up your GitHub organization, repository, and Scrumboard

1 - First Feature

• Database, Model, and Controllers work together to Read and Create a primary resource (post, event, etc...) • Adapters are built for key endpoints, frontend page routing is established, and key components are built (forms, buttons, content lists) • Integration testing of frontend and backend is complete.

2 - MVP Complete

• Fullstack functionality on two user-created resources. • Full CRUD on at least one user-created resource • Styling and page layout is beginning to take shape

3 - Polish + Present!

• Ironing out bugs for a full demo • Styling is polished and consistent • Presentations are practiced and ready to present • Project is Deployed

These are the high-level priorities of each sprint but it will be up to each group to determine how to divide the work to meet these objectives.

Here are some tips:

  • Divide your group into frontend and server/database. You can always switch after a sprint to gain exposure to the full stack.

  • Decide early what data will be transferred between the frontend and server. Then, work quickly to build adapters and endpoints to establish that connection.

  • In the first sprint, focus on substance, not style. This applies most to the frontend. Build your pages and routing first. Then the forms and data containers. Finally, hook them up to your adapters to just get them working.

✅ Key Deliverables and Examples

In addition to the fullstack web application that you build, you will need to complete these deliverables. Each of these deliverables will help ensure that every group completes their project on time and meets our standards of excellence.

Entity Relationship Diagram

A well designed Entity Relationship Diagram (ERD) can quickly communicate the data that is most important to your application. It will serve your team as a source-of-truth for any questions about the data needed to work with a particular type of resource.

Here are the requirements for an ERD:

  • Every entity/table has a clear and descriptive table name.

  • Clearly shows the relationship between entities (One-to-Many, One-to-One, etc.) and relationships must be in the right direction.

  • Join tables are shown when Many-to-Many relationships are needed.

  • Every table list all critical attribute/column names.

  • Primary Keys and Foreign Keys must be labeled and clearly distinguished from other attributes/columns.

  • Every attribute/column has a data type.

  • Diagram must be neatly structured with as few overlapping or intersecting lines as possible.

  • ERD reflects the same project and all features outlined in the project proposal.

Wireframe

The wireframe should clearly show the various frontend views of your application and how users can navigate between them. Like the endpoint, it will serve your team as a source-of-truth for the design, layout, and expected functionality of your frontend application.

Here are the requirements for a wireframe:

  • Wireframes must show a landing page, one or two pages for log-in and sign-up, plus an additional page for every other front-end client route in the application.

  • Wirefremes must have a navigation feature: either a menu, header, or sidebar.

  • Every page must be labeled with its client-side path (/profile, /, /newsfeed, /user/:id, etc.).

  • The only text that is visible is text which denotes action or hierarchy (headings and button labels, but body text is not needed)

  • Entire wireframe is neatly structured and visually accessible with no overlapping pages.

  • Mockup reflects the same project and all features outlined in the project proposal.

Product Specifications Sheet

A Product Specifications Sheet communicates the user stories for an application and the technical details required to implement them, such as:

  • The page and URL path for a feature

  • Essential frontend components (forms, buttons, links, etc...),

  • What follows a user interaction (submitting a form, clicking a button, etc...)

  • Backend endpoints used to create, read, update, or delete data.

If filled out thoroughly, a product spec sheet can quickly be translated into tickets for a scrum board.

Here are the requirements for a product spec sheet:

  • The What, Why, and Who sections clearly and concisely describe the application and audience.

  • "Must-Haves" product requirements are essential to meeting the needs of the intended audience

  • "Nice-to-Haves" can reasonably be excluded from the application while still meeting the needs of the intended audience

  • Technical requirements are decomposed for every "Must-Haves" product requirement.

  • Technical requirements include:

    • The name of the page that the feature is included on and the URL path for the page

    • A description of any essential frontend components that the user will interact with (forms, buttons, links, containers for data, etc...)

    • An explanation of what happens when a user interacts with a form / button / link

    • An explanation of any interactions with the backend including endpoints to fetch from and if authentication or authorization is required."

  • The ERD and Mockup are linked at the bottom

Polished GitHub Repository

The repository is the most important artifact for your technical audience. The code inside will demonstrate your technical prowess.

The README is the first impression of your application that your technical audience will experience so make sure that your README is clean, professional, and provides clear instructions for working with your application.

Here are the requirements for your GitHub Repository:

  • The README is complete with mission statement, team members, usage, and technologies used

  • The README includes links to the proposal and scrum board.

  • The repository has a scrum board linked under Projects. The scrum board has descriptive tickets, assignees, and clear organization.

  • The deployment link is added to the About section.

Demo Day Presentation & Project Demo

And finally, the presentation and project demo will serve as your elevator pitch! You will only have a few minutes to show off your work during Demo Day so make the most out of it!

Observe the professionalism and polish of the slides here! Each member has their moment to shine and share their contributions to the project. The demo video walks the user through the essential user-stories in a natural manner.

👀 What's Next

Example:

Example:

Head over to the to see more details about the requirements for your project and other minor deliverables.

Collective Product Spec Sheet
https://github.com/ENiA-collective/collective
Civic Tech Hackathon Rubric
🧭 Overview
🌈 What does Civic Tech Hackathon Represent in the Program Arc?
🚀 How Will Civic Tech Hackathon feel?
😌 What skills and mindsets lead to success?
📆 Calendar, Rituals, and Support Meetings
🕰️ Sample Schedule
👥 Whole-Group Meetings
🤝 Support Meetings
🥲 Fridays and Weekends
🏃 Sprints
✅ Key Deliverables and Examples
Entity Relationship Diagram
Wireframe
Product Specification Sheet
Polished GitHub Repository
Demo Day Presentation & Project Demo:
👀 What's Next
A sample of your week during Civic Tech Hackathon
The ERD can quickly communicate the data that is most important to your application.
The wireframe should clearly show the various frontend views of your application and how users can navigate between them.
The product spec sheet breaks down the technical details required to build a user story feature.
A clean README is the introduction to your application for technical audiences.