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.

6 min read • View on GitHub • More from AhlamKhalid

A wide cutaway of a hand-operated letterpress in a print shop, drawn in dense black crosshatch. Springs, levers, and inked rollers crowd the frame while a single small crank at the far right is the only human-operated part, and a freshly printed card with a thick black outline and a flat pastel block slides out. The machine stands for the HTML and CSS doing the visible work, and the lone crank stands for the tiny JavaScript layer that drives it.
A large ornate machine producing visible output, driven by one small input. That is the shape of this repo.
Key Takeaways

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.

AhlamKhalid, Repository owner · Task-Management-System README

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.

One click, two independent reactions. Disable the JS path and the highlight survives while the view swap dies, which isolates exactly what each language owns.

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.

An overhead close-up of a designer's desk drawn in black crosshatch: a steel ruler running diagonally, a neat row of small hand-cut paper swatches in flat pastel ink labeled with hand-lettered pixel values, and a fine-nib pen resting across the ruler. One swatch has been nudged out of line, leaving a faint smudge. The scene represents the literal naming of design tokens, where each swatch's label encodes its own implementation value.
Tokens named after their values read clearly in a tutorial. They also lock the names to the current pixels.

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

AhlamKhalid, Repository owner · Task-Management-System README

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😉

AhlamKhalid, Repository owner · Task-Management-System README

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.

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

README, AhlamKhalid/Task-Management-System · Task-Management-System README

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.

ProjectBackendPersistenceCollaborationFrameworkPurpose
Task-Management-System (this repo)NoneNone (hardcoded markup)NoneNone (vanilla)Teach responsive HTML, CSS, and JS
Super ProductivityLocal plus integrationsYesNoAngularDaily personal productivity
WekanServer plus databaseYesYesMeteorTeam Kanban boards
KanboardServer plus databaseYesYesPHPSimple visual task boards
VikunjaGo API plus databaseYesYesVueAPI-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.