Deploying Bludit

Bludit is a simple, fast, and flexible flat-file CMS (Content Management System) designed for creating blogs and websites without the complexity of traditional database-driven systems. Built with PHP and utilizing JSON for content storage, Bludit provides an elegant solution for bloggers, small businesses, and content creators who need a lightweight, easy-to-use platform. Whether you’re launching a personal blog, building a business website, or creating a documentation site, Bludit offers the simplicity and speed you need with complete control over your content.

Why Bludit?

Bludit stands out as the premier choice for simple, fast, and flexible content management with exceptional features:

• No Database Required: Content stored as JSON files, no database setup needed
• Flat-File Architecture: Simple file structure for easy backup and migration
• Lightning Fast: Minimal overhead for maximum performance
• Easy Installation: Quick setup in minutes without complex configuration
• Markdown Support: Create content with Markdown or HTML
• Theme System: Beautiful themes with easy customization
• Plugin System: Extend functionality with community plugins
• User Friendly: Intuitive admin interface for content management
• Multi-Language Support: Write and manage content in multiple languages
• SEO Friendly: Built-in SEO features for better search visibility
• Static Pages: Create both blog posts and static pages
• Drafts and Scheduling: Schedule posts for future publication
• Categories and Tags: Organize content with categories and tags
• Media Management: Easy image and file upload management
• Mobile Responsive: All themes include mobile responsiveness
• Backup Friendly: Easy backup and restore of JSON content files
• Open Source: MIT licensed with transparent codebase
• Community Plugins: Extend with SEO plugins, analytics, forms, and more
• Custom Domain Support: Full support for custom domains
• API Available: Programmatic access to content

Bludit is ideal for bloggers seeking simplicity, small business websites, documentation sites, personal portfolios, and anyone preferring flat-file storage over databases. With persistent storage on Klutch.sh, your blog content is permanently secure and accessible.

Prerequisites

Before deploying Bludit, ensure you have:

• A Klutch.sh account
• A GitHub repository with your Bludit deployment configuration
• Basic familiarity with Docker and Git
• A custom domain name (recommended for production)
• Sufficient storage for blog content and media (typically 5-20GB)
• Understanding of PHP and web server basics

Important Considerations

Content Storage

Bludit stores content as JSON files. Ensure:

• Regular backups of content directory
• Proper file permissions are maintained
• Storage volumes are sized appropriately
• Database backups for any plugin data
• Access control for sensitive content

PHP Environment

Bludit requires specific PHP modules:

• mbstring module for UTF-8 support
• gd module for image processing
• dom module for DOM manipulation
• json module for JSON file handling
• All modules included in standard Docker image

Deploying Bludit

1. Create a New Project

   Log in to your Klutch.sh dashboard and create a new project for your Bludit deployment.

2. Prepare Your Repository

   Create a GitHub repository with the following structure for your Bludit deployment:

   bludit-deploy/
   ├─ Dockerfile
   ├─ .env.example
   ├─ docker-entrypoint.sh
   ├─ .gitignore
   └─ README.md

   Here’s a Dockerfile for Bludit:

   FROM php:8.2-apache
   
   # Install system dependencies
   RUN apt-get update && apt-get install -y \
       git \
       curl \
       libpng-dev \
       libjpeg62-turbo-dev \
       libfreetype6-dev \
       libxml2-dev \
       libzip-dev \
       zip \
       unzip \
       && rm -rf /var/lib/apt/lists/*
   
   # Install PHP extensions
   RUN docker-php-ext-configure gd --with-freetype --with-jpeg && \
       docker-php-ext-install -j$(nproc) \
       gd \
       mbstring \
       dom \
       json \
       zip
   
   # Enable Apache rewrite module
   RUN a2enmod rewrite
   
   # Set working directory
   WORKDIR /var/www/html
   
   # Clone Bludit repository
   RUN git clone https://github.com/bludit/bludit.git . && \
       git checkout master
   
   # Create necessary directories
   RUN mkdir -p /var/www/html/bl-content/pages \
       /var/www/html/bl-content/posts \
       /var/www/html/bl-content/databases \
       /var/www/html/bl-content/uploads \
       /var/www/data \
       /var/www/logs && \
       chmod -R 755 /var/www/html && \
       chown -R www-data:www-data /var/www/html
   
   # Copy Apache configuration
   COPY apache-config.conf /etc/apache2/sites-available/000-default.conf
   RUN a2ensite 000-default
   
   # Copy entrypoint script
   COPY docker-entrypoint.sh /
   RUN chmod +x /docker-entrypoint.sh
   
   # Expose port
   EXPOSE 80
   
   # Health check
   HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
     CMD curl -f http://localhost/ || exit 1
   
   # Run entrypoint
   ENTRYPOINT ["/docker-entrypoint.sh"]
   CMD ["apache2-foreground"]

   Create an apache-config.conf file:

   <VirtualHost *:80>
       ServerAdmin admin@localhost
       DocumentRoot /var/www/html
   
       ErrorLog /var/www/logs/error.log
       CustomLog /var/www/logs/access.log combined
   
       <Directory /var/www/html>
           Options Indexes FollowSymLinks
           AllowOverride All
           Require all granted
       </Directory>
   
       <IfModule mod_rewrite.c>
           RewriteEngine On
           RewriteBase /
           RewriteCond %{REQUEST_FILENAME} !-f
           RewriteCond %{REQUEST_FILENAME} !-d
           RewriteRule ^(.*)$ index.php?url=$1 [QSA,L]
       </IfModule>
   </VirtualHost>

   Create a docker-entrypoint.sh file:

   #!/bin/bash
   
   set -e
   
   # Create necessary directories
   mkdir -p /var/www/html/bl-content/pages \
            /var/www/html/bl-content/posts \
            /var/www/html/bl-content/databases \
            /var/www/html/bl-content/uploads \
            /var/www/data \
            /var/www/logs
   
   # Set proper permissions
   chmod -R 755 /var/www/html
   chown -R www-data:www-data /var/www/html
   chown -R www-data:www-data /var/www/data
   chown -R www-data:www-data /var/www/logs
   
   # Wait for any dependencies
   echo "Bludit is starting..."
   
   if [ "$1" = "apache2-foreground" ]; then
     # Start Apache
     exec apache2-foreground
   else
     exec "$@"
   fi

   Create a .env.example file:

   # Bludit Configuration
   APP_NAME=Bludit Blog
   APP_DESCRIPTION=My Personal Blog
   APP_URL=https://blog.yourdomain.com
   APP_LANGUAGE=en
   APP_TIMEZONE=UTC
   
   # Admin User
   ADMIN_USER=admin
   ADMIN_PASSWORD=secure_password_here
   ADMIN_EMAIL=admin@yourdomain.com
   
   # Blog Settings
   POSTS_PER_PAGE=5
   ITEMS_PER_PAGE=10
   SHOW_HOME_PAGE=true
   PERMALINK_STRUCTURE=/:slug/
   
   # Security
   ENABLE_COMMENTS=false
   ALLOW_ANONYMOUS_COMMENTS=false
   
   # SEO Settings
   ENABLE_SEO=true
   HOMEPAGE_TITLE=Welcome to My Blog
   HOMEPAGE_DESCRIPTION=My personal blog and thoughts
   
   # Plugins
   ENABLE_PLUGINS=true
   DEFAULT_THEME=londinium
   
   # Logging
   LOG_LEVEL=info

   Commit and push to your GitHub repository:

   git init
   git add .
   git commit -m "Initial Bludit deployment"
   git remote add origin https://github.com/yourusername/bludit-deploy.git
   git push -u origin main

3. Create a New App

   In the Klutch.sh dashboard:

   • Click “Create New App”
   • Select your GitHub repository containing the Dockerfile
   • Choose the branch (typically main or master)
   • Klutch.sh will automatically detect the Dockerfile in the root directory

4. Configure Environment Variables

   Set up these essential environment variables in your Klutch.sh dashboard:

   Variable	Description	Example
   APP_NAME	Blog/website name	My Blog
   APP_DESCRIPTION	Site description	My thoughts and ideas
   APP_URL	Your blog domain	https://blog.yourdomain.com
   APP_LANGUAGE	Default language	en
   APP_TIMEZONE	Site timezone	UTC
   ADMIN_USER	Admin username	admin
   ADMIN_PASSWORD	Admin password	secure_password
   ADMIN_EMAIL	Admin email address	admin@yourdomain.com
   POSTS_PER_PAGE	Posts per page	5
   ENABLE_SEO	Enable SEO features	true
   ENABLE_COMMENTS	Allow post comments	false
   DEFAULT_THEME	Active theme name	londinium
   ENABLE_PLUGINS	Enable plugin system	true
   LOG_LEVEL	Logging verbosity	info

   Generating Secure Admin Password

   Generate admin password: openssl rand -hex 16 or use a strong 16+ character password

5. Configure Persistent Storage

   Bludit requires persistent storage for blog content and media files. Add persistent volumes:

   Mount Path	Description	Recommended Size
   /var/www/html/bl-content	Blog posts, pages, and content	20GB
   /var/www/data	Application data and backups	10GB
   /var/www/logs	Apache and application logs	5GB

   In the Klutch.sh dashboard:

   • Navigate to your app settings
   • Go to the “Volumes” section
   • Click “Add Volume” for each mount path
   • Set mount paths and sizes as specified above

6. Set Network Configuration

   Configure your app’s network settings:

   • Select traffic type: HTTP (Bludit uses standard web ports)
   • Recommended internal port: 80 (as specified in Dockerfile)
   • Klutch.sh will automatically handle HTTPS termination via reverse proxy
   • Ensure ports 80 and 443 are accessible from your domain

7. Configure Custom Domain

   Bludit works best with a custom domain for professional blogging:

   • Navigate to your app’s “Domains” section in Klutch.sh
   • Click “Add Custom Domain”
   • Enter your domain (e.g., blog.yourdomain.com)
   • Configure DNS with a CNAME record to point to your Klutch.sh app
   • Update APP_URL environment variable to match your domain
   • Klutch.sh will automatically provision SSL certificates

   Domain for Your Blog

   Use a dedicated subdomain like blog.yourdomain.com or just yourdomain.com for your main blog.

8. Deploy Your App

   • Review all settings and environment variables
   • Verify all persistent volumes are properly configured
   • Click “Deploy”
   • Klutch.sh will build the Docker image and start your Bludit instance
   • Wait for the deployment to complete (typically 5-10 minutes)
   • Access your Bludit instance at your configured domain
   • Log in with admin credentials to begin creating content

Initial Setup and Configuration

After deployment completes, access your Bludit instance to complete setup.

Accessing Bludit

Navigate to your domain: https://blog.yourdomain.com

Log in to the admin panel using admin credentials you configured.

Admin Panel Access

Access administration features:

1. Click “Login” or visit /admin/ path
2. Enter admin username and password
3. You’re now in the Bludit admin dashboard
4. Configure site settings and create content

Creating Your First Blog Post

Start publishing content:

1. In admin panel, click “New Post”
2. Enter post title
3. Write content in Markdown or HTML
4. Add featured image (optional)
5. Set category/tags
6. Enable/disable comments
7. Publish immediately or schedule for later
8. Save and publish

Configuring Blog Settings

Customize your blog appearance and behavior:

1. Navigate to “Settings” in admin panel
2. Configure:
   • Site title and description
   • Site language and timezone
   • Posts per page
   • Permalink structure
   • Homepage content
3. Save settings
4. Check “Advanced Settings” for more options

Managing Pages vs Posts

Understand content types:

• Blog Posts: Time-stamped content with categories/tags, appears in feed
• Static Pages: Timeless content like About, Contact, Privacy Policy
• Create pages for essential static content
• Use posts for blog-style time-based content

Selecting and Customizing Themes

Personalize your blog appearance:

1. Navigate to “Themes” section
2. Browse available themes
3. Click to activate a theme
4. Customize theme settings:
   • Site colors and fonts
   • Header and footer content
   • Widget positioning
   • Layout options
5. Preview changes before publishing

Setting Up Blog Categories

Organize posts by topic:

1. Go to “Categories” in admin
2. Create categories for different topics:
   • Technology
   • Travel
   • Personal
   • Tutorial
3. Assign posts to categories
4. Categories appear in navigation and archives

Environment Variable Examples

Basic Configuration

APP_NAME=My Blog
APP_DESCRIPTION=My personal blog
APP_URL=https://blog.yourdomain.com
APP_LANGUAGE=en
ADMIN_USER=admin
ADMIN_PASSWORD=secure_password
ADMIN_EMAIL=admin@yourdomain.com

Complete Production Configuration

# Application Settings
APP_NAME=My Professional Blog
APP_DESCRIPTION=A blog about technology and web development
APP_URL=https://blog.yourdomain.com
APP_LANGUAGE=en
APP_TIMEZONE=America/New_York

# Admin User Configuration
ADMIN_USER=admin
ADMIN_PASSWORD=very_secure_password_32_characters
ADMIN_EMAIL=admin@yourdomain.com

# Blog Settings
POSTS_PER_PAGE=5
ITEMS_PER_PAGE=15
SHOW_HOME_PAGE=true
PERMALINK_STRUCTURE=/:category/:slug/

# Content Settings
ENABLE_COMMENTS=false
ALLOW_ANONYMOUS_COMMENTS=false
MODERATE_COMMENTS=true

# SEO Configuration
ENABLE_SEO=true
HOMEPAGE_TITLE=Welcome to My Technology Blog
HOMEPAGE_DESCRIPTION=Insights on web development, programming, and technology trends
GENERATE_SITEMAP=true

# Theme and Plugins
DEFAULT_THEME=londinium
ENABLE_PLUGINS=true
ENABLE_THEME_CUSTOMIZATION=true

# Security
ENABLE_HTTPS_ONLY=true
COOKIE_SECURE=true
COOKIE_HTTPONLY=true

# Logging
LOG_LEVEL=info
LOG_TO_FILE=true

# Cache Settings
ENABLE_CACHE=true
CACHE_TTL=3600

Sample Code and Getting Started

PHP - Bludit Plugin Development

<?php
// Example Bludit Plugin - Custom Analytics

class CustomAnalytics {

    public static function init() {
        // Plugin initialization
        Global $plugins;
        $plugins['customAnalytics'] = __CLASS__;
    }

    public function beforeSiteLoad() {
        // Code executed before site loads
    }

    public function afterPageLoad() {
        // Code executed after page loads
        $this->trackPageView();
    }

    private function trackPageView() {
        // Track page view logic
        $pageTitle = $GLOBALS['page']->title();
        $pageURL = $GLOBALS['page']->permalink();

        // Store analytics data
        $analyticsFile = '/var/www/data/analytics.json';

        if (!file_exists($analyticsFile)) {
            file_put_contents($analyticsFile, json_encode([]));
        }

        $analytics = json_decode(file_get_contents($analyticsFile), true);

        if (!isset($analytics[$pageURL])) {
            $analytics[$pageURL] = [
                'title' => $pageTitle,
                'views' => 0,
                'first_view' => date('Y-m-d H:i:s')
            ];
        }

        $analytics[$pageURL]['views']++;
        $analytics[$pageURL]['last_view'] = date('Y-m-d H:i:s');

        file_put_contents($analyticsFile, json_encode($analytics, JSON_PRETTY_PRINT));
    }

    public function form() {
        return '';
    }

    public function save($values) {
        return true;
    }
}

// Initialize plugin
CustomAnalytics::init();

JavaScript - Frontend Interaction

// Bludit Custom Theme - Enhanced Navigation

class BluditNavigation {
  constructor() {
    this.menu = document.querySelector('.site-navigation');
    this.hamburger = document.querySelector('.hamburger');
    this.mobileMenu = document.querySelector('.mobile-menu');
    this.init();
  }

  init() {
    if (this.hamburger) {
      this.hamburger.addEventListener('click', () => this.toggleMenu());
    }

    // Highlight current page
    this.highlightCurrentPage();

    // Add smooth scroll behavior
    this.addSmoothScroll();
  }

  toggleMenu() {
    if (this.mobileMenu) {
      this.mobileMenu.classList.toggle('active');
      this.hamburger.classList.toggle('active');
    }
  }

  highlightCurrentPage() {
    const currentURL = window.location.pathname;
    const links = this.menu?.querySelectorAll('a');

    if (links) {
      links.forEach(link => {
        if (link.href === currentURL || currentURL.includes(link.href)) {
          link.classList.add('active');
          link.setAttribute('aria-current', 'page');
        }
      });
    }
  }

  addSmoothScroll() {
    document.querySelectorAll('a[href^="#"]').forEach(anchor => {
      anchor.addEventListener('click', (e) => {
        e.preventDefault();
        const target = document.querySelector(anchor.getAttribute('href'));

        if (target) {
          target.scrollIntoView({
            behavior: 'smooth',
            block: 'start'
          });
        }
      });
    });
  }

  // Search functionality
  setupSearch() {
    const searchForm = document.querySelector('.search-form');

    if (searchForm) {
      searchForm.addEventListener('submit', (e) => {
        e.preventDefault();
        const query = searchForm.querySelector('input[name="query"]').value;
        this.performSearch(query);
      });
    }
  }

  performSearch(query) {
    // Implement search logic
    console.log('Searching for:', query);
    // Redirect to search results page
    window.location.href = `/search/?q=${encodeURIComponent(query)}`;
  }
}

// Initialize when DOM is ready
document.addEventListener('DOMContentLoaded', () => {
  new BluditNavigation();
});

cURL - API Integration Examples

# Get Bludit site information
curl -X GET https://blog.yourdomain.com/api/v1/pages \
  -H "Content-Type: application/json"

# Get all posts
curl -X GET https://blog.yourdomain.com/api/v1/posts \
  -H "Content-Type: application/json"

# Get specific post
curl -X GET https://blog.yourdomain.com/api/v1/posts/{slug} \
  -H "Content-Type: application/json"

# Get all pages
curl -X GET https://blog.yourdomain.com/api/v1/pages \
  -H "Content-Type: application/json"

# Get site configuration (requires authentication)
curl -X GET https://blog.yourdomain.com/api/v1/site \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN"

# Create new post (requires authentication)
curl -X POST https://blog.yourdomain.com/api/v1/posts \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{
    "title": "My New Blog Post",
    "content": "This is the post content in Markdown",
    "category": "technology",
    "tags": ["tech", "blog"],
    "published": true
  }'

# Update post (requires authentication)
curl -X PUT https://blog.yourdomain.com/api/v1/posts/{slug} \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{
    "title": "Updated Title",
    "content": "Updated content"
  }'

# Delete post (requires authentication)
curl -X DELETE https://blog.yourdomain.com/api/v1/posts/{slug} \
  -H "Authorization: Bearer YOUR_API_TOKEN"

Bash - Content Backup Script

#!/bin/bash

# Bludit Content Backup Script
BACKUP_DIR="/backups/bludit"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
RETENTION_DAYS=30

# Create backup directory
mkdir -p $BACKUP_DIR

echo "Starting Bludit backup..."

# Backup blog content (posts and pages)
echo "Backing up blog content..."
tar -czf $BACKUP_DIR/bludit_content_$TIMESTAMP.tar.gz \
  /var/www/html/bl-content/posts \
  /var/www/html/bl-content/pages \
  /var/www/html/bl-content/databases

# Backup uploaded media
echo "Backing up media files..."
tar -czf $BACKUP_DIR/bludit_media_$TIMESTAMP.tar.gz \
  /var/www/html/bl-content/uploads

# Backup theme and plugin configuration
echo "Backing up theme and plugin configs..."
tar -czf $BACKUP_DIR/bludit_config_$TIMESTAMP.tar.gz \
  /var/www/html/bl-content/databases

# Backup logs
echo "Backing up logs..."
tar -czf $BACKUP_DIR/bludit_logs_$TIMESTAMP.tar.gz \
  /var/www/logs

# Cleanup old backups
echo "Cleaning up old backups..."
find $BACKUP_DIR -name "bludit_*" -mtime +$RETENTION_DAYS -delete

# Backup summary
echo "Backup completed: $TIMESTAMP"
echo "Backup files:"
ls -lh $BACKUP_DIR | tail -10

# Optional: Upload to cloud storage (S3 example)
# aws s3 cp $BACKUP_DIR/bludit_content_$TIMESTAMP.tar.gz s3://your-bucket/backups/
# aws s3 cp $BACKUP_DIR/bludit_media_$TIMESTAMP.tar.gz s3://your-bucket/backups/
# aws s3 cp $BACKUP_DIR/bludit_config_$TIMESTAMP.tar.gz s3://your-bucket/backups/

Blog Content Management

Writing Blog Posts Effectively

Create engaging content:

1. Clear Titles: Use descriptive, SEO-friendly titles
2. Introduction: Hook readers with strong opening paragraph
3. Structure: Use headings, paragraphs, lists for readability
4. Images: Add featured images and inline images
5. Links: Link to related posts and external resources
6. Categories: Assign to relevant categories
7. Tags: Use consistent tags for filtering
8. Meta Description: Write engaging meta descriptions

Markdown Formatting Guide

# Main Heading (H1)
## Secondary Heading (H2)
### Tertiary Heading (H3)

This is a paragraph with **bold text** and *italic text*.

- Bullet point 1
- Bullet point 2
  - Nested bullet point

1. Numbered item
2. Another item

<a href="https://example.com" target="_blank" rel="noopener noreferrer">Link text</a>

![Alt text for image](image-url.jpg)

> This is a blockquote
> It can span multiple lines

\`\`\`
Code block
\`\`\`

| Column 1 | Column 2 |
|----------|----------|
| Data 1   | Data 2   |

Publishing Schedule

Manage publication timing:

1. Write post in draft status
2. Set publication date and time
3. Bludit automatically publishes at scheduled time
4. Schedule multiple posts in advance
5. Review scheduled posts in calendar view

Search Engine Optimization

SEO Best Practices

Optimize for search engines:

1. Titles: Use keywords in post titles (50-60 characters)
2. Meta Descriptions: Write compelling descriptions (150-160 characters)
3. Headers: Use H2 and H3 headers for structure
4. Keywords: Include target keywords naturally throughout content
5. Links: Link to related posts and authoritative sources
6. Images: Use descriptive alt text for all images
7. URL Slugs: Keep URLs short and keyword-relevant
8. Categories: Organize content in logical categories
9. Sitemap: Enable automatic sitemap generation
10. Robots.txt: Configure crawling rules

Enabling SEO Features

Configure SEO settings:

1. Navigate to “Settings” → “SEO”
2. Enable SEO features
3. Configure:
   • Site title and description
   • Homepage title and description
   • Permalink structure
   • Sitemap generation
4. Install SEO plugins if available
5. Test with SEO tools

Theme Customization

Theme Selection

Choose from available themes:

1. Navigate to “Themes” in admin
2. Browse theme gallery
3. Preview themes
4. Activate preferred theme
5. Customize theme colors and fonts

Custom Theme Development

Create custom themes:

1. Create theme directory in /bl-themes/
2. Create required files:
   • metadata.json - Theme information
   • index.php - Main template
   • css/ - Stylesheets
   • js/ - JavaScript files
3. Use Bludit template tags for content
4. Test in development environment
5. Deploy to Bludit instance

Comment Management

Moderating Comments

If comments enabled:

1. Navigate to “Comments” in admin
2. Review pending comments
3. Approve or reject comments
4. Edit comments if necessary
5. Delete spam or inappropriate comments
6. Configure comment notifications

Disabling Comments

To disable comments:

1. Go to “Settings”
2. Disable “Allow Comments”
3. Existing comments remain visible
4. No new comments can be posted
5. Update post settings to hide comment forms

Backup and Recovery

Regular Backups

Implement backup strategy:

1. Backup content files daily
2. Backup media files weekly
3. Backup theme/plugin configuration
4. Store backups in multiple locations
5. Test restore procedures regularly

Restoring from Backup

Restore previous content:

1. Access backup files
2. Extract backup archive
3. Replace content directory with backup
4. Verify all posts and pages are restored
5. Test website functionality

Monitoring and Performance

Website Performance

Monitor blog performance:

1. Check page load times
2. Monitor database file sizes
3. Clean up old uploaded media
4. Optimize images for web
5. Enable caching if available
6. Monitor server resources

Logging and Monitoring

Track activity:

1. Review Apache access logs
2. Monitor error logs
3. Check plugin activity logs
4. Review failed login attempts
5. Monitor disk usage

Troubleshooting

Common Issues and Solutions

Issue: Cannot access admin panel

Solutions:

• Verify admin credentials
• Check file permissions on directories
• Clear browser cache and cookies
• Check Apache/PHP error logs
• Restart Bludit container

Issue: Images not uploading

Troubleshooting:

• Verify write permissions on uploads directory
• Check file size limits
• Verify supported image formats
• Check disk space availability
• Review upload logs

Issue: Posts not appearing on site

Solutions:

• Verify post is published (not draft)
• Check post publication date/time
• Verify post category is not hidden
• Clear cache if enabled
• Check browser cache

Issue: Theme not displaying correctly

Solutions:

• Clear browser cache
• Disable custom CSS temporarily
• Switch to default theme
• Check theme file permissions
• Review PHP error logs

Updating Bludit

To update Bludit to a newer version:

1. Read the release notes and changelog
2. Backup all content before updating
3. Update your Dockerfile:

   RUN git checkout latest-version

4. Commit and push to GitHub
5. Klutch.sh will automatically rebuild
6. Test all features after upgrade
7. Verify posts, pages, and media are intact
8. Monitor logs for any issues

Use Cases

Personal Blog

• Share thoughts and ideas
• Build personal brand
• Connect with readers
• Document learning journey

Business Blog

• Share company updates
• Publish industry insights
• Drive traffic to website
• Build authority in field

Documentation Site

• Technical documentation
• Knowledge base
• User guides and tutorials
• FAQ and help articles

Portfolio Website

• Showcase work and projects
• Share case studies
• Display portfolio items
• Professional presence

Additional Resources

• Bludit GitHub Repository - Source code and community contributions
• Bludit Official Documentation - Complete guides and tutorials
• Bludit Official Website - Project information and news
• Bludit Plugin Marketplace - Community plugins and extensions
• Bludit Theme Gallery - Available themes for customization
• Bludit Community Forum - Support and community discussions
• Bludit Discord Community - Real-time community chat
• Klutch.sh Getting Started Guide
• Klutch.sh Volumes Documentation
• Klutch.sh Custom Domains Guide

Conclusion

Deploying Bludit on Klutch.sh provides you with a simple, fast, and flexible blogging platform that maintains complete control over your content. With no database requirements, flat-file architecture, beautiful themes, plugin extensibility, SEO-friendly features, and intuitive content management, Bludit enables you to create and manage your blog effortlessly. Klutch.sh’s managed infrastructure ensures your blog is always available, secure, and performant, allowing you to focus on creating great content.

Start hosting your personal blog or business website today by deploying Bludit on Klutch.sh and experience the simplicity and speed of flat-file blogging.