- Dream Team Tasks
- Table of Contents
- What is the Dream Team?
- Submission Guidelines
- Task List
- TASK 00: Linux
- TASK 01: CLI & GIT
- TASK 02: The Open Source Conventions & Google Dorking
- TASK 03: The Developer's Keyboard – MonkeyType Challenge
- TASK 04: The Web Developer's Blueprint
- Development Cycle
- TASK 05: The Architect’s Vision – SRS Document
- TASK 06: Figma UI Challenge
- TASK 07: Frontend Development
- TASK 08: Backend
- TASK 09: Pytest and Unit Testing
- References & Acknowledgments
Dream Team is a student-led community founded by Vipin Pavithran and dedicated to transforming interested and ambitious students into problem solvers and leading professionals of tomorrow. The club fosters focused work, hands-on learning, and meaningful collaboration. Members engage in real-world projects, sharpen technical and communication skills through daily status updates, and actively participate in strategic discussions. Guided by experienced mentors and supported by Traboda Cyberlabs, the club provides a proven roadmap for converting student talent into impactful, real-world solutions. Here, members grow not only as professionals but also as effective teammates—ready to thrive in the evolving digital landscape.
-
Set up a private GitHub repository named
dreamteam-tasks. -
Create directories named
task-##(where##corresponds to the task number). All work, files, screenshots, code, documents, and deliverables for each task must be placed inside the correct corresponding directory. -
Add a
README.mdfile inside each task folder with a brief explanation of your approach, along with your personal review of the task.
Why Linux?
- Open, Secure & Collaborative: Linux is open-source, transparently built, and secured by a global community. This means vast community support is always available.
- The Ultimate Developer's Environment: It provides unparalleled control through the command line and native support for programming tools, making it one of the most efficient platforms to code on.
- A Foundation for Growth: Using Linux gives you a hands-on understanding of how an operating system works, building a stronger technical foundation for your career.
Read more about Linux here.
Installation and Dual-booting
It is generally recommended to use the latest LTS release of Ubuntu (24.04.3 at the time of writing).
If you are using macOS, you don’t need to install Linux—simply set up Homebrew as your package manager to continue with the tasks.
After completing the setup, attach a screenshot of your desktop (Linux or macOS) to confirm your system environment.
Recommended Duration: 2 days
By completing this task, you are taking your first step into a larger world of professional development.
First, we will explore the CLI by completing Bandit. The goal is to complete up to Level 20. Each level is a puzzle that will strengthen your skills in file permissions, text manipulation, searching, and connecting to remote servers.
Next, we will dive into Git, mastering commands that range from basic to advanced operations. Git exercises is a great platform to drill fundamental Git commands, building the muscle memory needed for fast and effective version control.
Additionally, Learn Git Branching provides an interactive way to visualize Git operations, helping you understand branching, merging, and rebasing—concepts crucial for collaboration on large projects.
Objectives:
- Complete Bandit up to Level 20.
- Complete all challenges on Git exercises and upload a screenshot of the congratulatory page to your repository.
- Use Learn Git Branching to practice visual branching, merging, and rebasing.
- Write a blog post detailing your solutions and learnings. You can publish it on Medium, GitHub Gist, or a personal website. Separate or combined write-ups for Bandit, Git exercises, and Learn Git Branching are acceptable.
Resources:
- Git Documentation
man git
Recommended Duration: 5 days
In this task, you will explore the conventions used in open-source projects, including coding styles, documentation standards, contribution guidelines, licensing, and community engagement. Additionally, you will learn about Google Dorking, a technique that leverages advanced Google search operators to uncover specific information online.
Objectives:
- Gain an understanding of different open-source licenses (MIT, GPL, Apache, etc.) and when to use each one.
- Explore typical contribution workflows, including forking, pull requests, and code reviews.
- Choose one well-known open-source project (such as Linux, React, or TensorFlow) and analyze its contribution guidelines, license, documentation structure, and community engagement.
- Learn about Google Dorking through the Google Dorking room on TryHackMe. Understand its applications and ethical considerations.
- Write a blog summarizing the conventions you learned about, comparing open-source licenses, explaining how to contribute effectively, and highlighting key takeaways from studying the chosen open-source project.
Resources:
Recommended Duration: 2 days
A developer's most fundamental tool is the keyboard. The ability to type quickly and accurately is not a trivial skill; it directly boosts productivity, reduces typos, and makes you more efficient when coding or working in the command line. This task is designed to help you build that foundational muscle memory.
Objective:
- Achieve a consistent typing speed of at least 45 WPM with a minimum 85% accuracy.
- Focus on gradual improvement and building a habit of consistent practice, not just reaching a single high score.
Daily Instructions & Deliverables:
- Create an Account: Sign up on MonkeyType to track your progress. Make sure your username is visible.
- Practice Daily: Spend time each day practicing, focusing on both speed and accuracy.
- Submit Proof of Practice:
- After each session, take a screenshot of your test result with your username clearly visible.
- Upload the screenshot to a dedicated folder named
task-03-monkeytypein your Git repository. - Name each file by date (e.g.,
2025-08-18.png).
Recommended Duration: Ongoing daily practice until objectives are met.
Using the div-it-up repository as your guide, this task will help you build a strong foundation in web development. You will focus on both mastering web development fundamentals and practicing a professional Git workflow for disciplined version control.
Objectives:
- Successfully complete the following two core assignments:
- 1-js-basics: Build a strong foundation by mastering the fundamentals of JavaScript.
- 3-typing-game: Apply your new skills to create a fun, interactive browser-based game.
Bonus Challenges (Optional):
- 2-terrarium
- 4-bank-project
Bonus projects are recommended only after perfecting and submitting the core assignments.
Deliverables:
- Add a README to your solution repository with a link to your fork of the
div-it-uprepository.
Recommended Duration: 4 days
Every application or website we see has a journey behind it, commonly known as the development cycle.
- The development cycle begins with creating a Software Requirements Specification (SRS) document, which outlines the project's requirements and goals. While creating a comprehensive SRS document is beyond the scope of this curriculum, you will create a much smaller version here.
- Next, detailed visual designs are developed using Figma, focusing on the look and feel (UI and UX) of the website.
- Following this, front-end and back-end development is carried out, with the front-end handling the user interface and the back-end managing data and server logic.
- Finally, both are integrated to ensure seamless interaction between the user interface and the underlying systems.
The following is a list of features that should be included in the website you create, along with important points to remember while working on such a project. After reading these, you can proceed with Task 05, where you will start working on this website by creating an SRS document!
Fable is a social platform for book enthusiasts where users can discover, review, and discuss books, as well as interact with a community of like-minded readers. It allows users to create reading lists, log books they’ve read, and share reviews. Additionally, it offers curated lists, book recommendations, and the ability to follow other users to see their activity. Visit the site: Fable
-
User Authentication: Sign-up, sign-in, and social media login.
-
Search Functionality: Search for books by title, author, genre, or publication date.
-
Review and Rating System: Users can write reviews, rate books, and edit or delete their reviews. Remember, other users can review the books you have added, just as you can rate the ones they have reviewed.
-
Reading List / Book List: Users can create and manage personalized book lists (e.g., “To Read,” “Favorites,” or “Currently Reading”).
-
Social Features: Follow other readers, view their activity, and comment on their reviews.
-
Recommendations: Suggest similar books based on user preferences or genre.
These features will help create a rich, interactive platform similar to Fable but tailored to your specific project.
While we don’t expect you to complete all these features, try your best!
-
Clean Code: Code should be well-structured, readable, and maintainable, following best practices like proper naming conventions, consistent formatting, and comprehensive docstrings.
-
Architecture and Design: The project should follow a well-defined architectural pattern that separates concerns, promotes modularity, and supports scalability. Research the most popular approaches and follow one.
-
Functionality and Completeness: All required features (e.g., user authentication, book addition, reviews) should be implemented and working as specified, covering both core and additional functionalities.
-
User Experience (UX) Design: The interface should provide a smooth, intuitive, and user-friendly experience. The flow of the app should be clear and consistent for users.
-
Responsible Use of AI Tools: While AI tools can assist with code generation, a significant portion of the project should showcase your understanding and problem-solving skills. Over-reliance on AI should be avoided, and manually written code should reflect thoughtful design and learning.
From here on, until the completion of the next four tasks (i.e., Tasks 05–08), all tasks will be related to the Fable-inspired project.
Every successful software project begins with a clear and shared vision. This task challenges you to create a Software Requirements Specification (SRS) document for the Fable-like website you are building. The SRS should clearly describe the project’s goals, key features, user needs, and basic design guidelines, providing a shared understanding for developers, designers, and stakeholders.
Fable is an app where users can interact and discuss the stories of books they’ve read, create lists of books, and search for titles in the bookstore.
Objective:
- Create a lean, clear, and modern SRS document that serves as a blueprint any developer, designer, or stakeholder can quickly understand.
- Upload the completed SRS document to your GitHub repository.
Resource:
- Draw inspiration and ideas from Fable.
Recommended Duration: 2 day
Functionality provides the skeleton of an application, but design gives it a soul. A great developer understands that how a product looks and feels is just as important as how it works. This task challenges you to step into the role of a UI designer, bridging the gap between a structural blueprint and a visually engaging, user-centric interface.
Objective:
- Create Figma designs for the UI/UX of the web app in Desktop View.
- After completion, upload the Figma design link to your task repository.
Recommended Duration: 3 days
The frontend of a website is the user's first impression and the core of their experience. It involves designing and building the user interface (UI), covering everything from the smallest button to the overall layout. A well-crafted frontend ensures a seamless and engaging user journey.
Next.js is a powerful React framework that enables developers to build fast, scalable, and SEO-friendly web applications.
Objectives:
- Create the frontend for the Fable-like web app you are developing using Next.js.
- Upon completion, upload all necessary files, excluding the
node_modulesfolder, to your repository.
Important Things to Note:
- Track Hardcoded Values: Maintain a list of all fields where you are using hardcoded values during frontend development. This will make it easy to replace them with live backend data later.
- Prepare for Integration: Design your frontend components to be flexible and ready for dynamic data. This ensures a smooth and efficient backend integration process.
Recommended Duration: 7 days
This task marks a significant step in your app’s development. You are now moving from the visual, user-facing part of the application to its backend—the powerful “engine room” that handles data and logic.
You will use Flask (a lightweight and flexible web framework) together with REST APIs to build a scalable and organized server-side foundation for your Fable-like app.
Objectives:
- Construct a Flask Backend: Use Flask to establish the core framework for your application’s server.
- Implement RESTful Endpoints: Create endpoints to handle user requests such as creating new entries, retrieving data, or updating user profiles.
- Manage Application Logic: Write the code that governs how data is processed, including authentication and database interactions.
Deliverables:
- Upload all backend files (excluding environment-specific or build artifacts) to your repository. This will serve as the server-side counterpart to your frontend.
Recommended Duration: 7 days
This task is designed to give you hands-on experience with Pytest and the principles of unit testing. You will not just be writing tests, but also using them as a diagnostic tool to find and fix bugs in a pre-existing codebase. This is a crucial skill for any developer, as it ensures your code is reliable, robust, and ready for future changes.
Objectives:
- Complete all the levels of the Pytest challenge provided in this repository.
- Write clear and effective test cases for the given codebase.
- Use tests as a diagnostic tool to identify and fix bugs.
- Ensure that all tests are passing before submission.
- Upload your solutions with proper names in your repository.
Recommended Duration: 3 days
This task list is inspired by various resources to create a comprehensive set of tasks. A significant portion, particularly those related to Git and Web Development, has been adapted from the following repository: