Task-Management-System-HTML-CSS-Javascript: Task-Management-System: The Interactivity That Never Touches JavaScript
A neo-brutalist dashboard built from CSS custom properties, radio buttons, and 2.6 KB of script. A case study in where CSS ends and JavaScript has to start.
- The List/Board switcher styles its selected tab with a hidden radio input and the adjacent sibling combinator, so the pink highlight runs on CSS alone.
- The architecturally significant file is main.css, a tokenized design system of custom properties, hard offset shadows, and a literal spacing scale.
- The 2.6 KB of JavaScript exists only to do the one thing CSS cannot observe: which DOM subtree the user is looking at.
- The missing persistence, auth, and focus management are the curriculum, not defects, in a project built to show exactly where the plain web stack runs out.
A Tab Switcher With No JavaScript
Switching between a list and a board usually means a click handler, a loop over sibling elements, and a class toggle on each. This repo does the visible half of that with two radio buttons and one rule.
.radio-input { appearance: none; position: absolute; }
.radio-buttons-container .radio-input:checked + .radio-label {
background-color: var(--pink);
}
The inputs are hidden with appearance: none and taken out of flow. The labels are the only thing the user sees. When a radio is selected, the :checked pseudo-class becomes true, and the adjacent sibling combinator (+) reaches the very next label and paints it pink. No script runs. The browser already tracks which radio is selected; CSS just reads that state.
<input type="radio" name="view" id="list" class="radio-input" value="list" checked>
<label for="list" class="radio-label">List</label>
<input type="radio" name="view" id="board" class="radio-input" value="board">
<label for="board" class="radio-label">Board</label>
This works because :checked is a piece of state that CSS can observe. The radio group guarantees exactly one selection, and the label is a sibling of the input, so a single combinator is enough to style the active tab. It is the same trick behind CSS-only accordions and toggle menus, and it is why the README can promise interactivity while staying honest about the script.
We will build a two-pages task management system. We will work intensively with HTML & CSS. And we are going to use Javascript as well to add some user interactions.
What CSS cannot do is swap the views themselves. The pink highlight lives next to the input, but the list and board containers are elsewhere in the DOM. No selector can reach across the tree and hide a distant element based on a sibling's state. That is the boundary, and it is exactly where the script picks up.
The Design System Is the Real Product
The trick above is not an isolated party piece. It sits inside a tokenized design system, and that system, not the task features, is what makes the repo worth reading.
The :root block of main.css defines typography, a named palette (--pink, --blue, --green, --beige), a literal spacing scale (--space-4 through --space-48), and hard offset shadow tokens like --pink-shadow: 6px 6px 0px var(--pink). A card never invents its own shadow; it borrows the token that matches its status column.
Naming tokens after their literal values (--space-16, not --space-md) is a deliberate trade. It is transparent for anyone learning the scale, since the name tells you the number. It also bakes the implementation into the name, so a real theme change would mean renaming tokens rather than only changing their values.
Components are built by stacking classes rather than by scoping styles to a component. A button carries its base, its size, and its color as separate classes: button regular-button blue-background. The utility layer (.flex, .justify-between, .items-center) follows the same one-property-per-class idea, written by hand. The aesthetic that holds it together is neo-brutalist: 2px black borders, zero-blur shadows, flat pastels, and status colors that carry from the list headers through the status dots to the card shadows.
⚙️ Display tasks in two different ways: list & board views
The board itself is a CSS Grid with a sensible fallback: grid-template-columns: repeat(3, minmax(266px, 1fr)) inside an overflow-x: auto container. On narrow screens the columns hold a minimum width and the board scrolls sideways instead of squashing the cards, and the scrollbar is hidden for both Firefox and WebKit without disabling the scroll.
What the 2.6 KB Actually Does
Only now does the script become interesting. It is not the engine of the UI. It is the trigger layer, and it is small enough to read in a sitting.
main.js caches its DOM references at the top, holds a single piece of state (let activeOverlay = null;), and attaches a listener per interaction. The view switcher listens for change and runs a switch on the selected value, toggling a .hide class between the two view containers. That is the entire reason the script exists: CSS can style the tab, but it cannot move the view.
The delete handler is the most instructive one, because it performs a multi-step UI transition with plain timers.
deleteTaskCTA.addEventListener("click", () => {
activeOverlay.classList.add("hide");
activeOverlay = null;
document.body.classList.remove("overflow-hidden");
notification.classList.add("show");
setTimeout(() => { notification.classList.remove("show"); }, 3000);
});
In one block it closes the dialog, unlocks page scroll, slides the toast in, and schedules it to leave after three seconds. The scroll lock itself is careful: body.overflow-hidden is applied only while an overlay is open, and the toast transition runs on top from -100% to 0, which is a clean CSS-only animation.
Two things are worth flagging. The setTimeout is never cleared, so triggering the toast twice within three seconds lets the first timer dismiss the second one early. And the delete does not remove the task from the DOM at all. The task stays visible while the toast reports success. Both are tutorial placeholders rather than hidden bugs, but they are the kind of detail that separates a demo from a product.
If you are using Visual Studio Code, use live server extension to run the project in the brower. Or similar extension in your editor of choise. Or even simpler, open the html page directly in your favorite browser😉
The Deliberate Incompleteness
Here is the part most write-ups would bury. The repo does not persist a task, authenticate anyone, or remove a deleted item from the page. It has no license, so default copyright applies and the two forks have no clear legal right to reuse the code. The gaps are not accidents to paper over. For a teaching artifact, they are the syllabus.
- No persistence. Tasks are hardcoded markup, so a refresh resets everything.
- No authentication. The login and signup forms have no action and no handler, and sign out does nothing.
- No real delete. The task element stays in the DOM after the confirmation toast.
- No focus management. Overlays do not trap keyboard focus or close on Escape.
- An accessibility regression: form * { outline: none; } strips focus outlines from every form control, with no :focus-visible replacement.
- No license file, which leaves reuse legally ambiguous.
The form * { outline: none; } line is the clearest example. It is a common shortcut in tutorials and a real problem in production, since keyboard users lose any visual cue about where focus is. The repo never adds a replacement, which is precisely the teaching moment: the shortcut is shown, and the consequence is left for the reader to notice.
⚙️ Display tasks in two different ways: list & board views
Read that scope literally and the whole project makes sense. It is a two-page UI with two ways to view tasks. It is not promising a backend, and it is honest about it by simply not having one.
Where This Sits in the Landscape
The temptation is to line this repo up against real task managers and call it a lesser version. That misses the point. It is a different species, and the last column of the table below is where that shows.
| Project | Backend | Persistence | Collaboration | Framework | Purpose |
|---|---|---|---|---|---|
| Task-Management-System (this repo) | None | None (hardcoded markup) | None | None (vanilla) | Teach responsive HTML, CSS, and JS |
| Super Productivity | Local plus integrations | Yes | No | Angular | Daily personal productivity |
| Wekan | Server plus database | Yes | Yes | Meteor | Team Kanban boards |
| Kanboard | Server plus database | Yes | Yes | PHP | Simple visual task boards |
| Vikunja | Go API plus database | Yes | Yes | Vue | API-oriented task management |
Every other row exists to store your work and share it with other people. This row exists to show you how the interface gets built. Judged as software, it loses on every axis. Judged as a lesson in how far three files can go, it wins on the one axis it entered.
That is the honest read of a five-star companion repo. Its value is not that it manages tasks. Its value is that it draws a line in the sand at exactly the point where a framework, a database, and an auth layer would have to begin.





