DEV Community: Tom Dringer

The Developer Guide to Choosing an Online Kanban Board

Tom Dringer — Tue, 20 Oct 2026 14:44:53 +0000

Originally published at NerimaSoft

An online kanban board translates active technical tasks into distinct visual columns, allowing engineers to track work in progress from conception to deployment. By making operational capacity visible, a well-configured board surfaces delivery bottlenecks, enforces personal task limits, and eliminates context switching.

Most software teams struggle not with tracking work, but with the excessive bloat of their tracking tools. Heavyweight web applications often require complex configurations, mandatory cloud dependencies, and endless background scripts that drain system memory. When individual contributors spend more time updating card metadata than writing code, the system fails its core purpose.

Visual task management delivers its greatest value when it remains immediate and unobtrusive. Structuring personal workloads around lean, privacy-focused boards keeps the developer focused on code execution while maintaining a transparent record of daily momentum.

Key Takeaways

Visual task tracking works best when restricted to three core states: pending, active, and completed.

Storing data locally protects technical workflows from network downtime, cloud outages, and persistent third-party telemetry.

Enforcing strict work-in-progress (WIP) limits prevents task switching and surfaces production bottlenecks early.

An offline-first architecture with optional cloud synchronisation gives developers speed in the terminal alongside visual clarity in the browser.

Architecture Type	Primary Data Store	Offline Usability	Telemetry & Tracking	Setup Complexity
Traditional SaaS Board	Remote Cloud Database	Non-existent or read-only	Persistent cloud tracking	High (accounts, workspaces, permissions)
Flat-File Markdown	Local `.md` files	Complete local access	None	Low (manual text editing)
Offline-First SQLite + Web	Local SQLite database	Complete local execution	Zero credential exposure locally	Low (terminal package installation)

Architecture of an Effective Kanban Board Workflow

The Kanban method visualises how value moves through a system. In the 2022 State of Kanban survey, Kanban University, 2022 reported that 87% of respondents found the Kanban method more or much more effective than other work management methods they had previously used. This effectiveness stems from simplicity: tasks are represented as independent cards moving across vertical lanes that represent operational states.

Every functional board requires three structural columns to control daily development:

Backlog and Queue Management

Incoming tasks, bug reports, and refactoring items collect here. An unmanaged backlog quickly becomes a dumping ground for forgotten ideas. To prevent clutter, technical backlogs must undergo regular pruning to maintain a lean inventory of actionable tickets.

Work in Progress (WIP)

This lane represents active engineering effort. Limiting the number of simultaneous items in this column is the single most important rule of visual tracking. Restricting active development to one or two concurrent tasks forces developers to finish open pull requests before opening new branches.

Completed Review and Deployment

The final column holds work that meets the local definition of done. Moving a card here provides a clear audit trail of completed features and closed issues during release reviews.

Adoption of this workflow continues to accelerate across engineering departments. In fact, Kanban framework usage among surveyed Agile teams grew from 7% in 2020 to 56% in 2022 Digital.ai, 2022. Visual tracking provides a continuous delivery cadence without the rigid ceremony associated with sprint planning.

The Pitfalls of Centralised Cloud Task Trackers

Modern engineering environments often suffer from centralised task management overload. Cloud-only project software demands that every interaction pass through remote APIs, requiring persistent network connections for basic updates. For an engineer working in deep focus, waiting several seconds for a remote web board to refresh introduces an unneeded point of failure.

Centralised boards also present real operational and security concerns:

Third-Party Telemetry: Hosted services capture granular operational telemetry, recording active work hours, task descriptions, and repository references.
Credential Creep: Granting administrative access to external cloud providers creates unnecessary credential exposure and persistent cloud tracking across environments.
Latency Overheads: Electron-wrapped web apps consume gigabytes of workstation memory merely to render static task cards.
Network Dependency: Commuting or working in disconnected environments leaves developers completely locked out of their personal task lists.

Engineering and R&D teams comprised 48% of Agile practitioners in 2023, representing a 16% increase compared to 2022 Businessmap, 2024. Because software engineers make up nearly half of the agile user base, their tooling must reflect technical realities: speed, data privacy, and minimal system overhead.

Structuring Visual Tasks: Pure Kanban vs Hybrid Approaches

Engineering tasks rarely follow a single operational pattern. Depending on whether work arrives as continuous maintenance or planned milestone releases, developers adopt different structural frameworks for their boards.

Pure Kanban for Continuous Flow

Pure Kanban handles unpredictable, continuous work streams such as site reliability, bug triaging, and infrastructure maintenance. Items enter the queue dynamically and move across the board based strictly on available capacity. When an operational lane empties, the engineer pulls the next item from the top of the stack.

Hybrid Scrumban Workflows

Many developers choose a structured hybrid model. According to 2022 State of Agile survey data, 27 percent of respondents used Scrumban as a hybrid agile process combining Scrum with Kanban visual tools Coursera, 2026.

Scrumban applies visual swimlanes to structured work phases. Developers pull work onto an individual kanban board while maintaining structured retrospectives or release cycles. This approach gives independent contributors the autonomy to manage individual execution without the friction of rigid sprint estimations.

Implementing an Offline-First Personal Kanban Workflow

Developers achieve peak productivity when their visual task manager integrates directly into their terminal workflow. Instead of navigating heavy browser interfaces throughout the day, tasks can be managed locally through command-line utilities.

The foundation of an offline-first system begins on the local workstation. Tasku CLI is free and open-source task management software for developers that is installed using the command gem install tasku NerimaSoft, 2026. By operating from the shell, it keeps task capture within the developer's immediate coding environment.

A local-first system maintains speed through three operational tiers:

1. Local Database Authority

A reliable task system writes all updates directly to a local database rather than an external web server. Tasku Cloud serves as an opt-in companion web app that provides free cloud sync and task backup across devices while storing local SQLite database files as the primary source of truth Medium, 2026.

Storing data in local SQLite tables ensures that queries return in microseconds. Network disconnections never interrupt terminal commands, and private project details never leave your drive without your explicit instruction.

2. Fast Command-Line Task Capture

Context switching degrades engineering focus. When an edge case surfaces during a code commit, dropping into the terminal to type a command takes two seconds. Opening a browser tab, authenticating via single sign-on, and waiting for assets to load disrupts working memory.

3. Visual Browser Overview

While the terminal excels at individual task manipulation, spatial arrangement is superior for visualising the whole project backlog. A companion web board reads the synchronized database state to display tasks across visual columns.

This browser view allows developers to step back, assess their weekly workload, and review blocked items without cluttering their local environment. While team collaboration features for tasku.cloud are under construction for 2027, the companion web interface provides an immediate personal visual board for solo workflows today.

Frequently Asked Questions

What makes an offline-first kanban board different from traditional cloud tools?

An offline-first board writes all task data directly to a local database on your machine before attempting any remote updates. Traditional cloud tools require continuous network connections to read or save changes, leaving you stranded during network drops.

How do strict WIP limits improve software delivery speed?

Work-in-progress limits restrict the number of tasks an engineer can juggle simultaneously. By preventing context switching between different codebases, developers finish active pull requests faster and resolve pipeline blockers before starting new work.

Can I use a terminal task manager alongside a visual web interface?

Yes. Modern offline-first systems use local databases as the single source of truth, synchronising task states with companion web boards. You can create and close issues via your shell while viewing the overarching project layout inside a browser.

Is an online kanban board suitable for individual developer tracking?

Visual boards work exceptionally well for solo engineers. They provide a clear visual boundary between backlogged ideas and current work, preventing feature creep and keeping solo milestones manageable.

How does storing task data in SQLite protect technical privacy?

SQLite stores your entire task backlog in a single, local file on your own hard drive. Because your task metadata never resides on unencrypted multi-tenant cloud servers by default, internal project structures and confidential client names remain completely isolated.

The Offline-First Advantage

Managing technical work requires tools that match the cadence of modern engineering. Relying on centralised project management platforms forces developers into constant network dependencies, slow web interfaces, and unnecessary credential exposure. When boards lag or disrupt your terminal focus, task tracking stops serving your development process and becomes administrative overhead.

Switching to an offline-first model puts control back on your local machine. Storing your work state in an isolated SQLite database guarantees instant terminal responsiveness, total operational privacy, and full offline autonomy. When you need a wider view of your development queue, a companion web interface delivers the visual clarity of a traditional kanban board without sacrificing workstation speed.

This is a syndicated copy. The original lives at https://nerimasoft.co.uk/blog/online-kanban-boards/

Mado vs iTerm2 vs Kitty vs Warp vs Ghostty: Which macOS Terminal Is Right for You?

Tom Dringer — Mon, 28 Sep 2026 13:20:19 +0000

If you've spent any time in the macOS terminal community recently, you know the space is more competitive than it's ever been. For years iTerm2 was the default answer. Now there's a new wave of terminals each taking a different bet on what developers actually need. This article compares the main options honestly - including Mado, the terminal I built.

iTerm2

iTerm2 is the veteran. It's been around since 2011, it's free, it's open source, and it has basically every feature you could ask for accumulated over a decade. Split panes, profiles, triggers, smart selection, shell integration - it's all there. If you're already using it and happy, there's no compelling reason to switch. The downside is that it shows its age. The UI feels heavy, the settings panel is overwhelming, and there's no integrated workflow layer - it's purely a terminal emulator. You manage your own multiplexer (usually tmux), your own task tracking, your own everything. It does one thing well and delegates the rest.

🔗 https://iterm2.com

Kitty

Kitty is the performance terminal. GPU-accelerated, cross-platform (macOS, Linux, BSD), and genuinely fast. It pioneered the terminal graphics protocol that lets applications render images directly in the terminal, and its "kittens" extension system lets you add Python-based plugins. It's highly configurable but requires that configuration - there's no hand-holding. If you're comfortable writing config files and want maximum control and performance, Kitty is excellent. If you want something that works well out of the box, the learning curve is steep.

🔗 https://sw.kovidgoyal.net/kitty

Warp

Warp took a bold swing: reimagine the terminal from scratch around AI and team collaboration. Commands are "blocks" you can share, search, and reference. The AI integration is deep - it's not bolted on, it's the core product direction. It's impressive and it's free. The trade-off is that Warp is built on a custom GPU renderer (not native AppKit), and its pivot toward agentic coding workflows means if you just want a fast, clean terminal it can feel like more than you need. It's also cross-platform now, which means some of the macOS-native feel is lost.

🔗 https://warp.dev

Ghostty

Ghostty is the new entrant from Mitchell Hashimoto (founder of HashiCorp). It's native, GPU-accelerated, cross-platform, and fast. The philosophy is to be an excellent terminal emulator and nothing more - no opinions on your workflow, no AI layer, just a great foundation. It's open source and free. If you want the cleanest, most native-feeling terminal without any extras, Ghostty is a strong choice. The community is growing quickly. The trade-off is that it's deliberately minimal - you're still assembling your own workflow around it.

🔗 https://ghostty.org

Mado

Mado is built for developers who want everything in one window. It's a native macOS terminal multiplexer - split panes, keyboard-driven navigation, workspace switching - but with a sidebar plugin system that lets you run fully custom panels alongside your terminal. Clock, Pomodoro, world time, clipboard history, an RSS feed reader, a Tasku stats dashboard - all rendered as native pixel frames, no web views. The tight integration with https://github.com/tomdringer/tasku is the thing that makes it different: your tasks, projects, and priorities live in the sidebar, scoped to whichever workspace you're in. Switch workspace, the task list switches with you. It's free, open source, macOS only, and built in Rust with a Slint UI layer - no Electron, no browser engine.

🔗https://nerimasoft.co.uk/mado.html

Honourable mention: Supacode

Supacode is worth knowing about if your workflow is heavily AI-agent-driven. It's built specifically for running multiple coding agents (Claude Code, Codex, etc.) in parallel, each in isolated git worktrees. Not a general-purpose terminal, but if you're managing several agents simultaneously it's a clever tool.
🔗 https://supacode.sh

Summary

The right choice depends on your priorities. If you want raw performance and cross-platform, Kitty. If you want AI-first collaboration, Warp. If you want a minimal native foundation, Ghostty. If you want a complete, keyboard-driven workflow with task management baked in, Mado.

Have we missed anything on the list? Let us know.

I Love tmux. But I Switched to Something with Themes, Plugins, and a Config That Doesn't Fight Back.

Tom Dringer — Tue, 22 Sep 2026 17:35:10 +0000

This story originally appeared on Medium

Update: Mado is now available!

Install it with Homebrew:
brew tap tomdringer/tap
brew install --cask tomdringer/tap/mado
Source on Github

If you've spent any real time in the terminal, you've probably settled into a multiplexer. tmux is the obvious choice — it's
battle-tested, endlessly configurable, and runs everywhere. GNU Screen is still kicking for people who learned it a decade ago.
Zellij has earned a following with its friendlier defaults. These are all good tools. I'm not here to argue otherwise.

But there's a ceiling you hit with all of them. Not in functionality — they can all split panes, manage sessions, and keep your
work alive through a disconnected SSH session. The ceiling is comfort. The feeling that your terminal workspace is yours, rather
than a configuration file you're constantly losing the thread of.

That's the gap Mado is trying to fill.

A sidebar that actually does something

Most multiplexers give you panes. Mado gives you panes and a sidebar — but not the kind that just shows a file tree and calls it done. The sidebar runs independent plugins: small executables that draw their own UI and respond to keyboard and mouse input.

Out of the box you get a clock, a Pomodoro timer, a clipboard history manager, a Tasku stats monitor, Tasku workspaces, Tasku priorities, World time, task timer and an AI assistant panel. Each one lives in the sidebar while your terminal work carries on uninterrupted.

The plugin protocol is straightforward enough that you can write your own in whatever language you're comfortable with. Plugins receive events as JSON on stdin and render by writing pixel frames to stdout. That's the whole contract. There's no SDK to install, no framework to learn.

Your work, exactly where you left it

Switch projects in the Mado sidebar and your current layout is parked — all panes, their working directories, and scroll

positions saved automatically. Switch back later and everything is restored exactly as you left it. No manual session saving, no tmux-resurrect, no lost context. If you've ever come back to a terminal session and spent five minutes reconstructing which directory was open in which pane, you'll know immediately why this matters.

Configuration without the archaeology

Anyone who's spent an afternoon tracking down where tmux actually reads its config on a new machine knows the feeling. Mado

takes the opposite approach: one command, mado config, opens your configuration in $EDITOR. It's a single TOML file. Theme,
font, shell, plugins — all in one place, all in a format you can read without consulting a man page.

Custom themes work the same way. Drop a .toml file into ~/.config/mado/themes/, update your config file and it appears automatically. No restart, no rebuild.

Twenty-two themes, because comfort is visual too

This is the part that might sound frivolous until you've spent eight hours staring at a terminal that feels slightly wrong. Mado ships with twenty-two themes built on Tailwind's colour palettes — Slate, Indigo, Emerald, Rose, and nineteen others. Each theme coordinates the terminal colours, sidebar chrome, focus indicators, and toolbar into something that feels deliberate rather than assembled. One line in your config to change everything.

The point

tmux isn't going anywhere, and it shouldn't. It's the right tool for a lot of situations — servers, remote sessions, scripted

environments. Mado isn't trying to replace it. It's trying to answer a different question: what does a multiplexer look like when it's built for the machine you actually work on every day?

Mado is open source, macOS-only, and launches in public beta on October 1st. Linux and Windows support is on the roadmap.

Your Terminal Tasks, Everywhere: Introducing Tasku Cloud

Tom Dringer — Tue, 22 Sep 2026 17:08:26 +0000

Note: This story originally appeared on Medium.

If you've been using Tasku — the open-source CLI task manager — you already know the appeal. No dashboards, no browser tabs, no bloated SaaS. Just a clean terminal interface, SQLite under the hood, and your tasks exactly where you're already working.

But there's always been one catch: your tasks live on one machine.

Switch to your laptop, your tasks aren't there. Work with a team, and everyone's working in isolation. That's what Tasku Cloud fixes.

What is Tasku Cloud?

Tasku Cloud is the companion web app for Tasku. It backs up your tasks to the cloud, keeps them in sync across every device you work on, and — for teams — gives everyone a shared view of what's being worked on.

It's not a replacement for the CLI. It's a layer on top. Your local SQLite database is still the source of truth. Tasku Cloud is opt-in, and if you ever stop using it, your data is exactly where you left it.

Why you need it

Your tasks should follow you

You're on your desktop, you add a task. You pick up your laptop on the sofa, it's there. You open a browser at work, it's there. That's cloud sync — and it should just work.

Backups matter

SQLite is rock solid, but it lives in ~/.tasku/tasks.db. One bad rm -rf, one failed disk, and it's gone. Tasku Cloud backs everything up automatically so you never have to think about it.

Teams need a shared view

The Tasku CLI is brilliant for solo work, but the moment you're working with other people, you need more. Who's working on what? What's blocked? What's overdue? Tasku Cloud's Teams plan brings shared projects, task assignment, and an activity feed — without turning into Jira.

The same Tasku you know

One of the things that makes Tasku Cloud feel right is that it doesn't reinvent anything. The fields are the same ones you use in the CLI and in Mado: status, priority, due dates, projects, categories, tags. No mapping, no import/export dance. It just looks like Tasku — because it is.

Pricing

Tasku Cloud is free for individuals. Sign up, connect your tasks, and get cloud backup and sync with no credit card and no trial period.

The Teams plan (coming soon) adds everything you need for collaborative work:

Shared projects and tasks
Team member assignments
Activity feed

Simple per-seat pricing tiers, no feature gates on the things you actually need.

Get started

Head to tasku.cloud, create a free account, and have your tasks in the cloud in minutes. If you haven't tried the Tasku CLI yet, install it first:

gem install tasku

And if you're a macOS user, keep an eye on Mado — launching October 1st with Tasku built right into the sidebar.