100 Best JavaScript Projects for High School Students

JavaScript is the fastest language to see results in because anything you build runs immediately in a browser with no setup. That instant feedback loop makes it one of the best languages for learning through projects rather than tutorials.

It's also the only language that runs natively in every browser, which means your projects are genuinely shareable. You can send someone a link rather than asking them to install anything. We've broken 100 project ideas into 10 categories, from your first interactive page through to machine learning running in the browser.

Tip: A coding project becomes much more compelling for college applications and competitions when you develop it into structured research. Veritas AI pairs students with mentors to take project ideas from concept to completion. See how it works here!

Key Takeaways

• Pick a category that matches your level: Categories 1 and 3 need only basic JavaScript, while Categories 6, 7, and 10 assume you're comfortable with asynchronous code and npm.

• Deploy everything you build: free hosting on GitHub Pages, Netlify, or Vercel turns a local project into a link you can actually share with anyone.

• Strong deliverables matter: aim for three artifacts, meaning working code, a public repository with a clear README, and a live demo link.

• Learn the DOM before reaching for frameworks: understanding how JavaScript manipulates a page directly makes React considerably easier when you get there.

• Asynchronous code is the intermediate barrier: promises, async and await, and fetch appear in nearly every project past Category 3, so it's worth learning properly once.

Common tools you'll encounter across these projects: a code editor such as VS Code, browser developer tools (debugging and inspection), Node.js and npm (running JavaScript outside the browser), React (component-based interfaces), Express (web servers), Chart.js or D3 (data visualization), and TensorFlow.js (machine learning in the browser). All are free.

#1: DOM Manipulation and Interactive Pages

These projects teach you how JavaScript actually changes what appears on screen, which is the foundation for everything else. Start here if you know the basic syntax but haven't built anything visual yet.

1. Build a digital clock that displays live time with a toggle between 12-hour and 24-hour formats. Use setInterval to update the display and the Date object to handle time. This small project clearly introduces how JavaScript updates a page continuously without a refresh.

2. Create a to-do list where users can add, complete, edit, and delete tasks that persist between visits. Store tasks in localStorage and render the list dynamically from an array rather than hard-coding elements. This is the classic first project because it covers create, read, update, and delete operations in one place.

3. Build a tip calculator that splits a bill across people and updates results as the user types. Attach input event listeners and recalculate on every keystroke rather than waiting for a submit button. Live updating teaches you the difference between events that fire once and events that fire continuously.

4. Create an accordion FAQ section where clicking a question smoothly expands its answer. Toggle CSS classes rather than manipulating styles directly in JavaScript. This project teaches the useful habit of letting CSS handle animation while JavaScript handles only state.

5. Build a password strength checker that gives live feedback as the user types. Use regular expressions to test for length, character variety, and common weak patterns. Regular expressions are worth learning early, and this gives you a practical reason to start.

6. Create an image carousel with automatic rotation, manual navigation, and pause-on-hover. Manage an index variable and combine setInterval with mouse event listeners. Handling the interaction between automatic rotation and manual control is the genuinely interesting part.

7. Build a multi-step form with validation at each stage and a visible progress indicator. Validate each section before allowing the user to move forward, and preserve entered data when they navigate back. Form validation is unglamorous work that appears in nearly every real application.

8. Create a dark mode toggle that remembers the user's choice and respects their system setting. Combine CSS custom properties with localStorage and the prefers-color-scheme media query. Respecting system preferences is a small detail that signals real attention to users.

9. Build a drag-and-drop kanban board with columns for task stages and persistent ordering. Implement the HTML Drag and Drop API and save the board state to localStorage. Drag interactions contain many edge cases, which makes this a genuine step up from earlier projects.

10. Create a keyboard-navigable modal dialog that traps focus and closes on Escape. Manage focus programmatically and handle keyboard events properly for accessibility. Accessibility work is rarely taught to beginners and stands out clearly when you demonstrate it.

#2: Browser Games

Games force you to manage state, timing, and input simultaneously, and they're satisfying because you can tell immediately whether they work. Most of these use the Canvas API rather than a game library.

1. Build a memory card matching game with a move counter and a timer. Shuffle an array of card pairs and track which cards are currently flipped and which have been matched. Array shuffling and state tracking make this an ideal first game project.

2. Create a quiz game with multiple-choice questions, a score counter, and a results screen. Store questions as an array of objects and render each one dynamically as the player progresses. This project teaches you to separate your data from your display logic, which pays off in every later project.

3. Build the classic Snake game with a growing body, collision detection, and rising speed. Render to a Canvas element and use requestAnimationFrame for the game loop rather than setInterval. This is where most students first meet the concept of a frame-based game loop.

4. Create tic-tac-toe with an unbeatable computer opponent using the minimax algorithm. Implement recursive game-tree search that evaluates every possible future board state. Recursion pays off visibly here, which makes it a good place to finally understand how it works.

5. Build a typing speed test that measures words per minute and accuracy against a passage. Compare user input against the target text character by character and calculate metrics live as they type. Real-time string comparison is a nice exercise that produces immediately meaningful output.

6. Create a Breakout clone with destructible bricks, power-ups, and multiple levels. Handle collision detection between many objects at once and manage progression between levels. Managing collections of game entities scales complexity considerably compared with simpler games.

7. Build a 2048 clone with smooth tile animations and correct merge behavior. Represent the grid as a two-dimensional array and implement the sliding and merging logic for each direction. Getting merges exactly right in every direction is trickier than it initially appears.

8. Create a platformer with gravity, jump physics, moving platforms, and level loading. Implement a physics update loop, camera scrolling, and a level format you design yourself. This combines nearly every skill in the category into one substantial project.

9. Build a multiplayer tic-tac-toe or connect four playable across two browsers in real time. Use WebSockets through a small Node.js server to synchronize game state between clients. Real-time synchronization introduces problems single-player games never raise.

10. Create a top-down roguelike with procedurally generated dungeons and turn-based combat. Implement procedural generation with a room-and-corridor algorithm and design your own combat rules. Procedural generation produces a different game every run, which is genuinely rewarding to build.

#3: Browser Tools and Utilities

Utilities solve small problems you actually have, which makes them satisfying to build and easy to demonstrate. Most are finishable in a weekend, which helps if you want a quick win.

1. Build a unit converter handling length, weight, temperature, and volume with instant conversion. Structure your conversion factors as a nested object and route all calculations through one function. Organizing the data well means adding new units later becomes trivial.

2. Create a random password generator with adjustable length and character type options. Use the Crypto API for secure randomness rather than Math.random, which is predictable. Understanding the difference early is genuinely useful.

3. Build a markdown previewer that renders formatted output as the user types. Parse markdown syntax with your own regular expressions before reaching for a library like Marked. Writing a basic parser yourself first teaches far more than importing a finished one.

4. Create a pomodoro timer with work and break intervals, notifications, and session tracking. Combine setInterval with the Notification API and store completed sessions in localStorage. Handling browser tab visibility correctly is the subtle challenge that makes this harder than it looks.

5. Build a color palette generator that produces harmonious schemes from a base color. Implement conversions between HSL and hex, then apply color theory rules for complementary and analogous schemes. The color mathematics is a small, satisfying problem with visually obvious results.

6. Create a QR code generator that encodes text or URLs and lets users download the image. Use a library to generate the code, then use the Canvas API to export it as a downloadable file. This is a good first exercise in working with third-party libraries.

7. Build an expense splitter that calculates who owes what after a group trip. Model the debts as a graph, then implement a settlement algorithm that minimizes transactions. The optimization step turns a simple calculator into a real algorithm problem.

8. Create an image compressor that resizes and reduces file size entirely in the browser. Use the Canvas API to redraw images at reduced dimensions and export at adjustable quality. Processing files without ever uploading them is a nice privacy property worth explaining in your write-up.

9. Build a diff tool that highlights differences between two blocks of text. Implement the longest common subsequence algorithm and render additions and deletions distinctly. This is the algorithm behind version control diffs, which makes it genuinely worth understanding.

10. Create a spreadsheet with formula support, cell references, and automatic recalculation. Build a dependency graph between cells and recalculate in topological order when values change. Detecting circular references is the challenge that makes this project genuinely difficult.

#4: Data Visualization

Visualization sits at the intersection of code and communication, and it produces immediately impressive output. These make strong portfolio pieces precisely because the result is visual.

1. Build a bar chart displaying data from a small dataset with hover tooltips. Use Chart.js to render the chart and configure its interaction options. Starting with a library before attempting D3 is the sensible progression rather than jumping straight to the hardest option.

2. Create a live-updating line chart that plots values as they change over time. Append new data points on an interval and decide how many historical points to retain. Choosing what to discard is a small but genuinely real design decision.

3. Build a dashboard displaying several related charts with shared filtering. Maintain a single state object and re-render every chart when a filter changes. This teaches you to keep one source of truth rather than duplicating state across components.

4. Create an interactive map that plots data points geographically with clickable markers. Use Leaflet with a tile provider and bind informative popups to each marker. Working with coordinate systems is a useful skill that transfers to many other domains.

5. Build a scatter plot with zoom, pan, and brushing to select subsets of points. Use D3 scales and its zoom behavior to handle the transformations correctly. D3 is harder than Chart.js but gives you control that higher-level libraries cannot.

6. Create an animated bar chart race showing how rankings change over time. Interpolate positions between time steps using D3 transitions so bars move smoothly. The animation makes trends visible in a way that a static chart simply cannot.

7. Build a network graph visualizing connections between entities with a force-directed layout. Implement D3's force simulation and handle node dragging and collision detection. Force-directed layouts are among the most visually striking things you can build in a browser.

8. Create a treemap displaying hierarchical data with proportionally sized nested rectangles. Use D3's hierarchy and treemap layout functions on nested data. Representing hierarchy by area rather than position is a genuinely different way of thinking about data.

9. Build a data storytelling page where charts update as the reader scrolls. Use the Intersection Observer API to trigger chart transitions at specific scroll positions. This technique appears throughout modern data journalism and is surprisingly approachable.

10. Create a real-time visualization of a live data stream with smooth transitions. Connect to a WebSocket feed and update the chart incrementally rather than re-rendering everything. Maintaining smooth animation under continuous updates is the real performance challenge here.

#5: Working With APIs

Fetching data you don't control is most of real-world web development. These projects also produce visible results fast, since live data makes an application feel immediately real.

1. Build a weather app that shows current conditions and a forecast for a searched city. Call a public weather API with fetch, then handle both successful responses and invalid city names. Error handling matters considerably more than the successful path in API work.

2. Create a random quote generator with a share button and the ability to save favorites. Combine an API call with localStorage to save items. This small project connects two separate skills cleanly, with little added complexity.

3. Build a GitHub profile viewer displaying a user's repositories, languages, and activity. Query the GitHub API and render repository data sorted by stars or recent activity. Working with a well-documented API is a good way to learn to read API documentation properly.

4. Create a movie search app with filtering by genre, year, and rating. Query a film database API and implement debounced search so you don't fire a request on every keystroke. Debouncing is essential whenever user input triggers network requests.

5. Build a recipe finder that suggests dishes based on ingredients the user already has. Handle multi-parameter API queries and rank results by how many of the available ingredients match. The ranking logic is where you add something beyond a thin search wrapper.

6. Create a news aggregator pulling headlines from multiple sources into one unified feed. Normalize differently shaped API responses into a single internal format before displaying them. Reconciling inconsistent data sources is a common engineering problem.

7. Build a currency converter with live rates and a historical rate chart. Cache responses to avoid unnecessary requests and chart historical data with a visualization library. Caching raises the useful question of when stored data becomes too stale to trust.

8. Create a public transit board showing live arrival times for nearby stops. Combine the Geolocation API with a transit agency's feed and handle missing data gracefully. Real transit data is messy in instructive ways that clean tutorial APIs never are.

9. Build a dashboard combining several APIs into one personalized morning briefing. Coordinate parallel requests with Promise.all, and handle cases where one source fails while others succeed. Deciding what to display on partial failure is a genuine design decision.

10. Create an app that calls a language model API to summarize text the user pastes. Handle streaming responses and manage your API key through a small backend proxy rather than exposing it in the browser. Learning why keys must never live in frontend code is the most valuable part of this project.

#6: React Applications

React is the most widely used frontend framework, and learning it opens up most modern web development. Build a few plain DOM projects first, since React makes far more sense once you understand what it's abstracting away.

1. Build a counter and toggle app to learn component state and event handling. Use the useState hook and pass event handlers down as props to child components. This is deliberately small, and its only purpose is making state management finally click.

2. Create a to-do application with status filtering and persistent storage. Manage the list in state and use useEffect to synchronize it with localStorage. Rebuilding a familiar project in React shows you exactly what the framework changes and what it doesn't.

3. Build a component library with reusable buttons, cards, modals, and form inputs. Design flexible props and clearly document each component's interface. Thinking carefully about reuse is a genuine step toward writing professional-quality code.

4. Create a multi-page site with client-side routing and shared navigation. Use React Router to handle navigation without full-page reloads. Understanding client-side routing explains how single-page applications actually work under the hood.

5. Build a shopping cart with quantity adjustment, running totals, and a checkout summary. Lift state to a shared parent component or use the Context API for cart data. This is where prop drilling becomes painful enough to genuinely motivate better state patterns.

6. Create a form-heavy application with validation, error messages, and submission handling. Use a library like React Hook Form or manage controlled inputs yourself to compare the approaches. Forms are where React's data flow is most commonly misunderstood.

7. Build a real-time chat interface that displays messages as they arrive. Connect to a WebSocket and manage message state with useReducer rather than useState. Reducers become clearly worthwhile once your state updates get complex enough.

8. Create an app with user authentication, protected routes, and session persistence. Integrate a service like Firebase Auth and guard routes based on login state. Authentication is a standard requirement that most student projects skip entirely.

9. Build a data-heavy interface with pagination, sorting, and server-side filtering. Coordinate URL parameters with fetched state and handle loading and error conditions properly. Keeping the URL synchronized with the interface is a detail that separates polished apps from prototypes.

10. Create a collaborative editor where multiple users see each other's changes live. Implement operational transformation or use a CRDT library alongside WebSockets. Concurrent editing is a genuinely hard problem that's worth attempting at least once.

#7: Node.js and Backend

Node lets you write JavaScript outside the browser, which means you can build servers, tools, and scripts using a language you already know. These projects complete your understanding of how web applications actually work end-to-end.

1. Build a command-line tool that renames or organizes files in a folder by pattern. Use the fs module to read directories, and add a preview mode before committing any changes. Command-line tools are the gentlest possible introduction to Node.

2. Create a script that scrapes a web page and extracts structured data. Fetch the page and parse it with Cheerio, which gives you jQuery-style selectors on the server. Check the site's terms of service and robots file before scraping anything.

3. Build a REST API with endpoints to create, read, update, and delete records. Use Express to define routes and structure sensible response formats with correct status codes. Building the server side completes your picture of the client-server relationship from both directions.

4. Create a URL shortener that generates short codes and redirects to original links. Store the mappings in a database and handle collisions when generating new codes. This compact project touches routing, storage, and redirects all at once.

5. Build a Discord or Slack bot that responds to commands and posts scheduled updates. Use the platform's official library and handle command parsing along with rate limits. Bots are unusually satisfying because people other than you actually end up using them.

6. Create an authentication system with registration, login, and password hashing. Hash passwords with bcrypt and manage sessions using JSON Web Tokens. Never store plain-text passwords; it's the single most important security lesson in this category.

7. Build a file upload service with type validation, size limits, and thumbnail generation. Handle multipart form data with Multer and process images with Sharp. Proper upload validation is a real security concern, not an optional nicety.

8. Create a scheduled job runner that fetches data periodically and emails a summary. Combine a cron library with an email service, and handle failures without silent breakage. Building something that runs unattended changes how carefully you think about error handling.

9. Build a WebSocket server supporting rooms, presence, and message broadcasting. Use Socket.IO to manage connections and synchronize state across many clients. Handling disconnections and reconnections cleanly is considerably harder than establishing the initial connection.

10. Create a rate-limited API gateway that proxies requests and caches responses. Implement token bucket rate limiting and an in-memory or Redis cache layer. These infrastructure concepts are rarely covered in student projects, which makes them stand out.

#8: Chrome Extensions

Extensions are underrated as projects because they solve problems in tools you already use daily, and very few students build them. They also demonstrate that you can work within an unfamiliar platform's constraints.

1. Build an extension displaying a custom new tab page with a clock and quick links. Configure the manifest to override the new tab page and store links in extension storage. This is the standard first extension and teaches you the manifest structure that everything else depends on.

2. Create a word counter that reports reading statistics for any page you visit. Inject a content script that reads the page text and displays results in the popup. Content scripts are the core concept behind most genuinely useful extensions.

3. Build a site blocker that prevents access to distracting sites during set hours. Use the declarative net request API and store both the block list and the schedule. This solves a problem you probably actually have, which helps with motivation.

4. Create a highlighter that saves selected text from any page into a personal notes list. Capture selection events and persist each highlight along with its source URL. Restoring highlights when you revisit a page is the genuinely interesting challenge.

5. Build a price tracker that monitors product pages and alerts you when prices drop. Parse prices from the page and use a background script to check periodically. Different sites structure their prices differently, which makes reliable parsing genuinely tricky.

6. Create a reading-time estimator that shows how long an article will take. Count words in the main content area and divide by an average reading rate. The real problem is identifying the article text rather than navigation and ads.

7. Build an accessibility checker that flags missing alt text and poor color contrast. Traverse the DOM, checking images and computing contrast ratios against WCAG thresholds. This teaches you accessibility standards while producing something genuinely useful to other developers.

8. Create a tab manager that groups, searches, and saves sessions of open tabs. Use the tabs API to read and manipulate open tabs and store saved sessions persistently. Anyone who habitually keeps too many tabs open will actually want to use this.

9. Build an extension that summarizes the current page using a language model API. Extract the main content, then send it to an API through a backend that securely stores your key. Content extraction is harder than the API call itself.

10. Create a productivity dashboard tracking time spent per site with weekly reports. Track active tab changes in a background script and aggregate the data over time. Accurately measuring active rather than merely open time is the subtle challenge in this project.

#9: Canvas, Animation, and Creative Coding

Creative coding produces visually striking results, which makes these excellent portfolio pieces. They also teach you about performance, since animation makes inefficiency immediately visible on screen.

1. Build a particle system where particles respond to mouse movement. Draw to a Canvas element and update every particle's position each frame with requestAnimationFrame. Watching hundreds of objects animate smoothly is genuinely satisfying and easy to demonstrate.

2. Create a generative art piece that produces a different composition each time it loads. Combine randomness with geometric rules that constrain the output within pleasing bounds. Balancing randomness against structure is essentially the entire art of generative work.

3. Build a digital drawing app with brush sizes, colors, an eraser, and undo. Track mouse and touch paths on a Canvas and maintain a stack of previous states. Undo is where the stack data structure becomes obviously useful rather than abstract.

4. Create a fractal renderer that draws the Mandelbrot set with zoom and color mapping. Implement complex number iteration and map iteration counts to a color gradient. Deep zooms make an excellent demonstration of mathematical structure that's invisible at normal scale.

5. Build an audio visualizer that reacts to music playing in the browser. Use the Web Audio API's analyzer node to extract frequency data and render it to Canvas. Connecting sound to visuals is one of the most rewarding things you can build in a browser.

6. Create Conway's Game of Life with adjustable speed and preset starting patterns. Implement the neighbor-counting rules on a grid and render each successive generation. Watching complexity emerge from four simple rules is genuinely striking every time.

7. Build a physics sandbox with gravity, bouncing, and collisions between shapes. Implement collision detection and response yourself before reaching for a library like Matter.js. Building the physics manually first teaches considerably more than importing a finished engine.

8. Create a 3D scene with rotating objects, lighting, and camera controls. Use Three.js to set up a scene, camera, and renderer with orbit controls for navigation. Three.js opens up an entire category of impressive projects that look far harder than they are.

9. Build a maze generator that animates the generation algorithm as it runs. Implement recursive backtracking and render each step, not just the finished maze. Animating the algorithm makes it far easier to understand than reading the code alone.

10. Create a flocking simulation where agents exhibit emergent group behavior. Implement separation, alignment, and cohesion rules for each individual agent. Three simple rules producing lifelike flocking is a striking demonstration of emergence from local behavior.

#10: Machine Learning in the Browser

TensorFlow.js runs machine learning models directly in the browser, which means you can build AI projects with no backend and no installation. This category is the most directly relevant if you're interested in AI.

1. Build an image classifier that identifies objects using a pretrained model. Load MobileNet through TensorFlow.js and classify images the user uploads. Using a pretrained model first shows you what's possible before you attempt any training of your own.

2. Create a webcam-based pose detector that tracks body position in real time. Use the PoseNet or MoveNet model along with getUserMedia for camera access. Seeing a skeleton track your own movement live is an unusually effective demonstration.

3. Build a sentiment analyzer that rates text as positive or negative. Use a pretrained text model and handle tokenization before running inference. Text models require preprocessing that image models don't, which is worth understanding properly.

4. Create a hand gesture recognizer that triggers actions when you make specific signs. Combine the handpose model with your own logic for classifying finger positions. Mapping detected landmarks to meaningful gestures is where your own work actually happens.

5. Build a digit recognizer where users draw a number, and the model identifies it. Train a small convolutional network on MNIST and connect it to a Canvas drawing input. Training your own model rather than loading one is a meaningful step up in difficulty.

6. Create a teachable image classifier that learns new categories from user examples. Apply transfer learning by retraining only the final layer of a pretrained model. Transfer learning is how most practical machine learning actually gets done in production.

7. Build a real-time style transfer app that applies artistic styles to webcam video. Load a style transfer model and manage the performance cost of running inference on every frame. Keeping frame rates usable is the real engineering challenge, not the model itself.

8. Create a recommendation system suggesting items based on user ratings. Implement collaborative filtering using matrix operations in TensorFlow.js. This is the algorithm behind most recommendation features you encounter online.

9. Build a model detecting whether a face is wearing glasses, trained on your own data. Collect and label a dataset yourself, then train a classifier and evaluate honestly on held-out examples. Assembling your own dataset teaches you how much data quality genuinely matters.

10. Create a neural network visualizer showing activations as data flows through layers. Render layer activations to Canvas as a small model runs inference. Making the internals visible is one of the best ways to understand what networks are actually doing.

How Should You Choose a Project?

Three questions narrow this down quickly.

Does the project use a skill you haven't tried yet, or does it deepen one you're shaky on?

Both are valid reasons, but knowing which you're doing changes how you approach it.

Can you describe what finished looks like in one sentence?

Projects without a clear endpoint tend to sprawl until you abandon them. A game with a win condition and a working score display is finished, while "a game" is not.

Is the project one step above your current level rather than three?

Learning happens when you work slightly beyond what you can already do; working far beyond it usually means copying solutions rather than developing judgment.

What Makes a JavaScript Project Worth Showing?

Working code is the baseline, not the achievement. What makes a project memorable is whether someone can actually see it running.

Deploy everything, since a live link is worth far more than a repository nobody will clone. GitHub Pages, Netlify, and Vercel all host static sites for free, and deployment takes minutes once you've done it once.

Handle the states most students ignore. What does your app show while data loads, when a request fails, or when a list is empty? Handling those cases is a small amount of work that makes a project feel finished, not abandoned.

Write a README explaining what the project does, the decisions you made, and what you'd improve with more time. That last section signals self-awareness, which reads considerably better than pretending the project is perfect.

Frequently Asked Questions About JavaScript Projects

1. What is a good first JavaScript project for a beginner?

A to-do list or a digital clock, since both teach DOM manipulation and event handling without requiring frameworks or a backend. Finish one small project completely rather than abandoning something ambitious halfway through.

2. Should I learn React before building projects?

No. Build several projects with plain JavaScript first, since React makes far more sense once you understand what it's abstracting away. Jumping straight to a framework often leaves real gaps in the fundamentals.

3. How long should a JavaScript project take?

Beginner projects typically take a few days to a week. Intermediate projects run one to three weeks, and advanced projects involving real-time features or machine learning can take a month or more.

4. Do I need a backend for my JavaScript projects?

Not for most of them, since browser storage and public APIs cover a great deal. You need a backend when you're storing data for multiple users, hiding API keys, or coordinating real-time state between clients.

5. Where can I host my JavaScript projects for free?

GitHub Pages, Netlify, and Vercel all host static sites at no cost, and the latter two also support serverless functions if you need light backend logic.

6. Do JavaScript projects help with college applications?

A deployed project you can explain in detail is far more useful than a list of tutorials you completed. Admissions readers and interviewers respond to specifics: what you built, what broke, and how you worked around it.

If you're looking to build unique projects in the field of AI/ML, consider applying to Veritas AI!

Veritas AI was founded by Harvard graduate students, and through its programs, you can learn the fundamentals of AI and computer science while collaborating on real-world projects. You can also work 1-1 with mentors from universities like Harvard, Stanford, MIT, and more to create unique, personalized projects. In the past year, we have had over 1000 students learn data science and AI with us. You can apply here!