Deploying Nullboard

Introduction

Nullboard is a minimalist kanban board application that takes simplicity to the extreme. Unlike feature-heavy project management tools, Nullboard is a single HTML file with no external dependencies, databases, or backend servers required. It stores all data in the browser’s local storage, making it incredibly fast and completely private.

The application embodies the philosophy that the best tool is the one you actually use. With its clean interface and zero setup requirements, Nullboard lets you focus on organizing your tasks rather than configuring software.

Key highlights of Nullboard:

• Zero Dependencies: Single HTML file with everything included
• No Backend Required: Runs entirely in the browser
• Local Storage: Data stored securely in your browser
• Instant Loading: No API calls or database queries
• Drag and Drop: Intuitive card and list management
• Export/Import: JSON backup and restore functionality
• Markdown Support: Format card content with Markdown
• Multiple Boards: Create and switch between boards
• Keyboard Shortcuts: Efficient keyboard navigation
• Dark Mode: Built-in dark theme option
• Open Source: MIT licensed and fully transparent

This guide walks through deploying Nullboard on Klutch.sh using Docker, which provides a convenient way to host and share your kanban boards.

Why Deploy Nullboard on Klutch.sh

While Nullboard works locally, deploying it on Klutch.sh provides additional benefits:

Centralized Access: Access your boards from any device through a consistent URL.

Team Sharing: Share board access with team members by sharing the URL.

HTTPS by Default: Automatic SSL certificates ensure secure access.

Custom Domains: Use your own domain for your kanban board.

Always Available: Your board instance remains accessible 24/7.

Version Control: Track changes to your board configuration through GitHub.

Simple Hosting: No complex infrastructure to manage.

Prerequisites

Before deploying Nullboard on Klutch.sh, ensure you have:

• A Klutch.sh account
• A GitHub account with a repository for your configuration
• Basic familiarity with Docker concepts
• (Optional) A custom domain for your Nullboard instance

Understanding Nullboard Architecture

Nullboard’s architecture is beautifully simple:

Single HTML File: The entire application is contained in one HTML file with embedded CSS and JavaScript.

Browser Storage: Uses localStorage API for persisting board data.

No Server Logic: The server only serves static files.

JSON Export: Boards can be exported as JSON for backup or sharing.

Deploying Nullboard on Klutch.sh

Create Your GitHub Repository

Create a new GitHub repository for your Nullboard deployment.

Create the Dockerfile

Create a Dockerfile in your repository root:

FROM nginx:alpine

# Clone Nullboard
RUN apk add --no-cache git && \
    git clone https://github.com/apankrat/nullboard.git /tmp/nullboard && \
    cp /tmp/nullboard/nullboard.html /usr/share/nginx/html/index.html && \
    rm -rf /tmp/nullboard && \
    apk del git

# Create nginx configuration
RUN echo 'server { \
    listen 80; \
    server_name _; \
    root /usr/share/nginx/html; \
    index index.html; \
    location / { \
        try_files $uri $uri/ /index.html; \
    } \
}' > /etc/nginx/conf.d/default.conf

EXPOSE 80

Create a New Project on Klutch.sh

Navigate to the Klutch.sh dashboard and create a new project.

Create a New App

Within your project, create a new app and connect your GitHub repository.

Configure HTTP Traffic

In the deployment settings:

• Select HTTP as the traffic type
• Set the internal port to 80

Deploy Your Application

Click Deploy to start the build process. The lightweight nature of Nullboard means deployment is very fast.

Start Using Nullboard

Once deployed, access your Nullboard at https://your-app.klutch.sh. Your kanban board is ready to use immediately.

Using Nullboard

Creating Your First Board

Get started with a new board:

1. Click “Add a board” at the top
2. Name your board
3. Click the board name to select it

Managing Lists

Organize your workflow:

1. Click “Add a list” to create columns
2. Rename lists by clicking their titles
3. Drag lists to reorder them
4. Delete lists using the context menu

Working with Cards

Add and manage tasks:

1. Click ”+ add a note” at the bottom of a list
2. Enter card content (Markdown supported)
3. Drag cards between lists
4. Double-click to edit card content
5. Use checkboxes with [ ] syntax

Markdown Formatting

Format card content:

• Bold: **text**
• Italic: *text*
• Checkboxes: [ ] Unchecked or [x] Checked
• Links: [text](url)
• Code: `code`

Keyboard Shortcuts

Navigate efficiently:

Shortcut	Action
Ctrl+N	New note
Ctrl+E	Edit selected note
Delete	Delete selected note
Ctrl+S	Save (triggers export)
Tab	Cycle through notes

Exporting and Importing

Backup your boards:

1. Click the menu icon (three dots)
2. Select “Export” to download JSON
3. Use “Import” to restore from JSON
4. Share JSON files with team members

Data Considerations

Browser Storage

Important notes about data storage:

• Data is stored in browser localStorage
• Each user/browser has separate data
• Clearing browser data removes boards
• Regular exports are recommended

Sharing Boards

Since Nullboard uses localStorage:

1. Export your board as JSON
2. Share the JSON file with team members
3. Team members import the JSON
4. Changes must be manually synchronized

Persistent Storage Options

For shared boards, consider:

1. Regular JSON exports stored in shared location
2. Git repository for version-controlled boards
3. Shared cloud storage for JSON files

Production Best Practices

Backup Strategy

Protect your board data:

1. Regular Exports: Export boards to JSON frequently
2. Version Control: Store exports in a Git repository
3. Scheduled Backups: Set reminders for export routines
4. Multiple Copies: Keep backups in different locations

Security Considerations

• Use HTTPS (automatic on Klutch.sh)
• Be aware that localStorage is accessible to JavaScript
• For sensitive data, consider encryption
• Regularly rotate access if using shared boards

Performance

Nullboard is inherently fast:

• Minimal resource requirements
• No database queries
• Instant local storage operations
• Consider board size for very large projects

Troubleshooting Common Issues

Board Data Missing

• Check if correct browser is being used
• Verify localStorage isn’t disabled
• Look for exported JSON backups
• Check browser data wasn’t cleared

Export Not Working

• Ensure popup blockers are disabled
• Try different export format
• Check browser console for errors
• Verify sufficient disk space

Drag and Drop Not Working

• Refresh the page
• Check for JavaScript errors
• Try a different browser
• Disable conflicting extensions

Alternative Deployment Options

Self-Contained HTML

For truly portable usage:

1. Download nullboard.html directly
2. Open in any browser locally
3. No server or deployment needed
4. Perfect for personal use

With Backend Storage

For persistent shared storage:

1. Deploy with a simple API backend
2. Store JSON exports on server
3. Add authentication if needed
4. Sync between team members

Additional Resources

• Nullboard GitHub Repository
• Nullboard Live Demo
• Simple Kanban Server (backend example)

Conclusion

Deploying Nullboard on Klutch.sh provides a centrally accessible, minimalist kanban board that exemplifies the beauty of simplicity. While it may lack the features of enterprise project management tools, Nullboard’s zero-dependency design and instant responsiveness make it perfect for personal task management or small team workflows. The combination of Nullboard’s simplicity and Klutch.sh’s easy deployment creates a frictionless productivity solution.