DEV Community: Satish Tripathi

🐳 Podman vs Docker: Which Container Tool Should You Choose?

Satish Tripathi — Sat, 26 Jul 2025 19:42:46 +0000

Containerization has revolutionized how we develop and deploy applications, with Docker leading the charge for years. However, Podman has emerged as a compelling alternative that addresses some of Docker's limitations. Let's explore the key differences and help you decide which tool fits your needs.

What Are Docker and Podman?

Docker is the pioneer in containerization, providing a complete platform for building, running, and managing containers. It uses a client-server architecture with a daemon running in the background.

Podman (Pod Manager) is Red Hat's answer to Docker, designed as a daemonless alternative that can run containers and pods without requiring root privileges.

🔍 Key Differences

Architecture: Daemon vs Daemonless

Docker relies on a central daemon (dockerd) that runs as root and manages all containers. This creates a single point of failure and potential security concerns.

Podman operates without a daemon, spawning containers directly. Each container runs as a child process, making the system more resilient and secure.

🔒 Security: Root vs Rootless

Docker traditionally requires root access, though rootless mode is available (but with limitations).

Podman was designed with rootless containers in mind from the start. You can run containers as a regular user without compromising security.

Pod Support

Docker focuses on individual containers, requiring Docker Compose or Kubernetes for multi-container applications.

Podman natively supports Kubernetes-style pods, allowing you to group multiple containers that share resources like network and storage.

Systemd Integration and Service Management

Docker requires additional tooling or manual configuration to integrate containers with systemd services.

Podman (as of 2024) offers enhanced systemd integration, allowing developers to generate system-managed service units directly from containers using podman generate systemd. This makes it seamless to deploy containers as long-running Linux services with proper service management, automatic restarts, and system integration.

Standards Compliance

Docker maintains good OCI compliance but with some proprietary extensions.

Podman has significantly improved its OCI (Open Container Initiative) compliance in 2024, ensuring strong compatibility with open container standards and tools across the broader ecosystem. This makes it easier to work with other OCI-compliant tools and ensures better portability.

Command Compatibility

Podman maintains near-perfect Docker CLI compatibility, making transitions seamless. The commands are practically identical:

# These work the same way:
docker run -d -p 8080:80 nginx    →    podman run -d -p 8080:80 nginx
docker build -t myapp .           →    podman build -t myapp .
docker exec -it container bash    →    podman exec -it container bash

Pro tip for existing Docker workflows: Instead of changing every script, you can set up a simple wrapper function in your .bashrc or .zshrc:

# Gradually transition your workflow
docker() {
    echo "→ Running with Podman"
    podman "$@"
}

This approach lets you keep your muscle memory while gaining Podman's benefits, and you can easily track which commands you're actually using.

Performance and Resource Usage

Docker uses slightly more system resources due to its daemon architecture but offers excellent performance and mature optimization.

Podman typically uses fewer system resources since there's no background daemon, and containers integrate more directly with the host system.

💰 Licensing and Cost Considerations

Docker's Subscription Changes: As of late 2023, Docker introduced changes to its subscription model, limiting free usage for larger teams and commercial entities. Docker Desktop now requires paid subscriptions for:

Companies with more than 250 employees OR more than $10 million in annual revenue
Commercial use in larger organizations

Podman's Open Source Advantage: Podman remains completely free and open source under the Apache 2.0 license, with no usage restrictions for commercial entities of any size.

This licensing shift has become a significant factor for many organizations when choosing containerization tools, especially for enterprise deployments and larger development teams.

When to Choose Docker

Choose Docker if you:

Need maximum ecosystem compatibility
Work in teams already using Docker
Require Docker Swarm for orchestration
Want the most mature tooling and extensive documentation
Can accommodate the licensing requirements for your organization size
Use Docker Desktop for local development (and meet licensing terms)

When to Choose Podman

Choose Podman if you:

Want to avoid licensing fees and restrictions
Prioritize security and want rootless containers
Work in environments where running daemons as root is prohibited
Need native pod support without Kubernetes
Want superior systemd integration for service management
Require strong OCI compliance and open standards compatibility
Prefer a more lightweight, completely open-source solution
Deploy containers as long-running system services on Linux

Migration from Docker to Podman

Migrating is surprisingly straightforward:

Install Podman: Most Linux distributions include it in their repositories
Set up transition wrapper: Add this function to your shell configuration for gradual migration:

   docker() {
       echo "→ Running with Podman: $*"
       podman "$@"
   }

Test existing scripts: Most Docker commands should work unchanged
Handle Docker Compose: Use podman-compose or docker-compose with Podman's Docker socket compatibility

Real-World Considerations

Development Environment

Docker: Docker Desktop provides an excellent developer experience on macOS and Windows
Podman: Better suited for Linux development; requires additional setup on other platforms

Production Deployment

Docker: More widespread adoption, extensive cloud provider support
Podman: Growing adoption, especially in enterprise environments prioritizing security

Learning Curve

Docker: Extensive tutorials, Stack Overflow answers, and community resources
Podman: Smaller community but growing rapidly; Docker knowledge transfers easily

🎯 The Bottom Line

Both tools are excellent for containerization. Your choice depends on your specific needs:

Choose Docker for maximum compatibility, mature ecosystem, and cross-platform development
Choose Podman for enhanced security, rootless operation, and native pod support

The good news? You don't have to choose permanently. Podman's Docker compatibility means you can experiment with both and switch when it makes sense for your workflow.

[Boost]

Satish Tripathi — Sat, 26 Jul 2025 19:41:11 +0000

🔖 Turn AI Assistant into Your Personal Bookmark Assistant: Building an MCP-Powered Bookmark Manager

Satish Tripathi — Sun, 13 Jul 2025 09:49:00 +0000

The Bookmark Nightmare Every Developer Knows

You're 3 hours deep into solving a critical production issue. You've opened 47 tabs researching solutions, found THE perfect Stack Overflow answer, bookmarked it... and then it vanishes into the void of your 2,847 other bookmarks.

Two weeks later, facing the same issue: "I KNOW I bookmarked this somewhere!"

Sound familiar?

As an SRE Engineer constantly switching between AWS docs, Terraform modules, GitHub repos, and monitoring dashboards, I was drowning in information chaos. Traditional bookmark managers felt like digital hoarding – everything went in, nothing useful came out.

Then I discovered Model Context Protocol (MCP) and realized: What if AI Assistant could actually manage my bookmarks intelligently?

What You'll Learn

By the end of this post, you'll know how to:

Build an AI-powered bookmark manager that integrates with AI Assistant
Use natural language to organize and retrieve bookmarks
Set up automatic syncing across devices
Never lose another important resource again

The "Aha!" Moment: What if AI Could Understand Context?

Picture this instead:

You: "AI Assistant, I'm working on Kubernetes scaling issues. What bookmarks do I have?"
AI Assistant: "Here are your 3 most relevant Kubernetes resources, plus that AWS EKS article you saved last month when debugging the same cluster."

That's exactly what I built with bookmark-manager-mcp.

How It Actually Works

The Problem-Solution Fit

Before: Bookmark → Forget → Search → Frustration → Repeat

After:

"Add this AWS Lambda guide to my serverless collection"
"Show me my Terraform bookmarks from last week"
"Find that debugging article I bookmarked during the outage"

Architecture That Makes Sense

The system uses three core components:

Local JSON Storage (~/.data/bookmarks.json) - Your data stays yours
MCP Integration - AI Assistant can read/write bookmarks naturally
Smart Categories - Auto-organizing by project, technology, or custom tags

Why These Technology Choices

TypeScript + Zod Validation: Because getting a "malformed URL" error at 3 AM during an incident is the last thing you need.

Docker Deployment: One command setup. No dependency hell, no "works on my machine" problems.

JSON Storage: Human-readable, git-friendly, easily backed up. Sometimes simple wins.

Getting Started (5-Minute Setup)

Claude Code Integration

# One command to rule them all
docker pull mindriftfall2infinitepiio/bookmark-manager-mcp:latest

# Connect to Claude
# Add to Claude Code (Docker)
docker pull mindriftfall2infinitepiio/bookmark-manager-mcp:latest
claude mcp add bookmark-manager -- docker run \
    --rm \
    --interactive \
    --volume ~/.data:/app/.data \
    mindriftfall2infinitepiio/bookmark-manager-mcp:latest

# Or with Podman
podman pull mindriftfall2infinitepiio/bookmark-manager-mcp:latest
claude mcp add bookmark-manager -- podman run \
    --rm \
    --interactive \
    --volume ~/.data:/app/.data \
    mindriftfall2infinitepiio/bookmark-manager-mcp:latest

VS Code Integration

Docker

docker pull mindriftfall2infinitepiio/bookmark-manager-mcp:latest

Create .vscode/mcp.json

{
  "servers": {
    "bookmark-manager": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "--interactive",
        "--volume",
        "~/.data:/app/.data",
        "mindriftfall2infinitepiio/bookmark-manager-mcp:latest"
      ]
    }
  }
}

For Podman users:

podman pull mindriftfall2infinitepiio/bookmark-manager-mcp:latest

Create .vscode/mcp.json

{
  "servers": {
    "bookmark-manager": {
      "command": "podman",
      "args": [
        "run",
        "--rm",
        "--interactive",
        "--volume",
        "~/.data:/app/.data",
        "mindriftfall2infinitepiio/bookmark-manager-mcp:latest"
      ]
    }
  }
}

Your First AI Bookmark Conversation

You: "Add https://docs.aws.amazon.com/eks/latest/userguide/troubleshooting.html to my kubernetes category"

AI Assistant: "✅ Added 'Amazon EKS Troubleshooting' to your kubernetes bookmarks. You now have 12 bookmarks in this category."

You: "What Terraform bookmarks do I have about AWS providers?"

AI Assistant: "Found 3 relevant bookmarks:
1. AWS Provider Documentation  
2. Managing AWS Resources with Terraform
3. Terraform AWS Best Practices Guide"

Real-World Impact: Before vs After

Before (Traditional Bookmarking)

500+ unsorted bookmarks
15 minutes searching for that "one article"
Duplicate bookmarks everywhere
Broken links and outdated resources

After (MCP-Powered Bookmarking)

Contextual retrieval: "Show me monitoring tools for Node.js apps"
Smart categorization: Resources auto-tagged by project
Conversation history: "What was that article you showed me yesterday?"
Cross-device sync via S3 backup

Advanced Features for Power Users

Enterprise-Ready Backup

# Sync to your S3 bucket (BYOS3 - Bring Your Own S3)
bookmark_sync_to_local_tos3()

# Pull bookmarks from S3 to new machine
bookmark_sync_to_s3_to_local()

Get the complete S3 sync function: GitHub Setup Guide

Context-Aware Suggestions

Working on a Lambda function? AI Assistant automatically surfaces your serverless bookmarks. Debugging Terraform? Your IaC resources appear instantly.

Natural Language Organization

No more folder hierarchies. Just talk:

"Move all my React bookmarks to frontend category"
"Tag these three articles as 'incident-response'"
"Show me everything I bookmarked this week"

Common Challenges and Solutions

"Where Do I Store My Data?"

Challenge: Trust and data ownership
Solution: Local JSON storage with optional S3 sync. Your data, your control.

"What About Broken Links?"

Challenge: Bookmarks become outdated
Solution: Built-in URL validation and health checks (coming in v2.0)

"How Do I Organize Thousands of Bookmarks?"

Challenge: Information overload
Solution: AI-powered categorization and contextual search

What's Coming Next

The roadmap based on user feedback:

Full-text search across bookmark content (not just titles)
Smart duplicates detection
Import from Chrome/Firefox/Safari
Web interface for visual management
Team sharing for engineering teams

Your Turn: Join the Experiment

I'm curious about your bookmark management pain points:

🤔 Question for you: What's your biggest frustration with current bookmark tools? Is it finding old bookmarks, organizing them, or something else entirely?

🔧 Want to contribute? The project is open source and needs:

Beta testers with different workflows
Documentation improvements
Feature ideas from real users
Bug reports (yes, they exist!)

Try It Out

5-minute challenge: Set this up and bookmark 5 resources from your current project. Then ask AI Assistant to list them by category.

⭐ Star the GitHub repo if this solves a problem for you

💬 Drop a comment below: What would make this more useful for your workflow?

🐦 Share your results: I'd love to see how different developers organize their resources

About the Author
I'm Satish Tripathi, an SRE Engineer who builds tools that solve real productivity problems.

Connect with me:

GitHub: @infinitepi-io
LinkedIn: Satish Tripathi
Blog: infinitepi-io.github.io
Docker Hub: mindriftfall2infinitepiio/bookmark-manager-mcp

Built something cool with MCP? I'd love to hear about it!