DEV Community: Sumit Dhaka

[Boost]

Sumit Dhaka — Sun, 22 Feb 2026 13:02:51 +0000

I Built a Free, Self-Hosted SNMP Toolkit — Now With Real-Time WebSocket Push

Sumit Dhaka ・ Feb 22

I Built a Free, Self-Hosted SNMP Toolkit — Now With Real-Time WebSocket Push

Sumit Dhaka — Sun, 22 Feb 2026 13:01:01 +0000

If you've ever worked with SNMP — testing NMS integrations, debugging trap handlers, or validating MIB structures — you know the pain. You end up juggling Net-SNMP CLI commands you can never remember, snmptrapd configs scattered everywhere, and a $500 MIB browser that still looks like it was designed in 2003.

I built Trishul SNMP to fix that. One Docker container. Browser-based. Free.

This post covers what's new in v1.2.4 — the biggest update yet — and why I built it this way.

What Is Trishul SNMP?

It's a self-hosted SNMP dev toolkit that combines five tools into one clean web UI:

What	Instead of
SNMP Simulator (UDP agent)	`snmpsim` + CLI config
Walk & Parse → JSON	`snmpwalk` + manual OID lookup
Trap Sender + Receiver	`snmptrap` + `snmptrapd`
MIB Browser (tree view)	iReasoning MIB Browser ($500+)
MIB Manager (upload/validate)	Text editor + manual dependency hell

Stack: Python 3.11, FastAPI, pysnmp, pysmi, Bootstrap 5, Docker.

# Install in one command
curl -fsSL https://raw.githubusercontent.com/tosumitdhaka/trishul-snmp/main/install-trishul-snmp.sh | bash

Then open http://localhost:8080. Default login: admin / admin123 — change it immediately in Settings.

What's New in v1.2.4

⚡ Real-Time WebSocket Push — Polling Is Dead

The biggest architectural change: the entire frontend is now event-driven.

Before: Every page polled the backend on a setInterval — dashboard every 30s, simulator every 5s. Stale data was common. Switching pages caused spinners.

After: A single persistent WebSocket connection at /api/ws. The backend broadcasts state changes the moment they happen. Dashboard, Simulator status, and Trap Receiver all update instantly — no refresh needed.

Browser ←──── WS push ────── FastAPI /api/ws
                                    │
                              broadcasts on:
                              - trap received
                              - simulator start/stop
                              - MIB uploaded
                              - stats change

The navbar shows a live green dot when the WebSocket is healthy. On reconnect, the backend sends a full_state message to re-seed everything — so you never see stale data after a network hiccup.

Why this matters for devs: If you're building a trap handler and sending test traps from the UI, you now see the counter increment on the dashboard in real time. No F5 needed.

📊 Live Activity Stats Dashboard

A new 8-counter row on the dashboard shows everything happening in your session:

SNMP Requests — Total polls served by the simulator
OIDs Loaded — OIDs currently in memory across all loaded MIBs
Traps Received / Sent — Live trap counters
Walks Executed — How many SNMP walks you've run
OIDs Returned — Total OIDs returned across all walks
MIBs Uploaded / Times Reloaded — MIB management activity

All counters update via WebSocket push. They're also file-backed — they survive container restarts so you don't lose your session history.

⚙️ Settings — Three New Cards

App Behaviour

Two toggles: auto-start Simulator and auto-start Trap Receiver on container boot. Plus a configurable session timeout (60s–86400s). Settings persist to app_settings.json and take effect on next restart.

Stats Management

Export all counters as JSON (useful for logging test session results) or reset to zero for a clean baseline before a test run.

About

Version, author, and description pulled live from the backend — always in sync with what's actually deployed.

🐛 Notable Fixes

Timestamp bug: The Trap Receiver was showing 1970 for Last Received when the backend returned a Unix epoch 0. Now guarded and shown as --.

Traps Sent undercount: Stats were only incremented in the frontend — if you sent traps via API directly, the counter never moved. Fixed by broadcasting stats from the backend after every successful trap send.

Dashboard spinners on page switch: The WS full_state event fires before DashboardModule.init() registers its listener on page switch, so status tiles stayed as spinners until the next reconnect. Fixed by always seeding via REST on init, regardless of WS state.

MIB Browser state conflict: Navigating to the Browser from Walk & Parse (with a pre-filled OID) would sometimes log Could not find node because the previous session's pending tree state conflicted. Fixed by clearing pendingSelectedOid and pendingExpandedNodes when a programmatic OID search is present.

Who Is This For?

NMS / backend developers who need a real SNMP agent to poll without actual hardware, or need to fire specific trap OIDs to validate their handler code.

DevOps / integration engineers who need to test SNMP monitoring integrations in CI/staging environments.

Network engineers who want to explore MIB structures interactively — search by OID, by name, or by description — and understand what traps a device can fire before it's on the floor.

What It's NOT For

Production 24/7 monitoring → use Zabbix, LibreNMS, PRTG
Enterprise NMS → use SolarWinds, Cisco Prime
High-availability trap collection at scale → use dedicated platforms

Trishul is a developer and testing tool, not a production monitoring system.

Quick Architecture

Browser (8080)
    │ HTTP + WebSocket
    ▼
Nginx (static files + reverse proxy)
    │ REST + WS
    ▼
FastAPI Backend (8000)
    ├── MIB Service (parse, validate, search)
    ├── SNMP Simulator (UDP 1061)
    ├── Trap Manager (send + receive on UDP 1162)
    ├── Walker (SNMP walk client)
    └── WebSocket hub (/api/ws)

Everything runs in Docker with host network mode so the SNMP UDP ports (1061, 1162) are accessible directly from your local machine or test devices.

Try It

# One-command install
curl -fsSL https://raw.githubusercontent.com/tosumitdhaka/trishul-snmp/main/install-trishul-snmp.sh | bash

# Access at
http://localhost:8080

If it's useful, a ⭐ on GitHub goes a long way — it helps other devs find the project.

Happy to answer questions in the comments about architecture decisions, the pysnmp/pysmi integration, or the WebSocket implementation. 🔱

Created OpenSource SNMP dev/testing tool for devs, please checkout and help improving it.

Sumit Dhaka — Sun, 22 Feb 2026 12:40:19 +0000

I Built a Free, Self-Hosted SNMP Toolkit That Replaces $500+ Tools — Now With Real-Time WebSocket Push

Sumit Dhaka ・ Feb 22

#networking #python #devops #opensource

[Boost]

Sumit Dhaka — Sun, 22 Feb 2026 12:38:49 +0000

Building Trishul-SNMP: A Modern Web-Based SNMP Toolkit to Replace $500 Commercial Tools

Sumit Dhaka ・ Feb 10

#snmp #networking #opensource #python

I Built a Free, Self-Hosted SNMP Toolkit — Now With Real-Time WebSocket Push

Sumit Dhaka — Sun, 22 Feb 2026 12:38:22 +0000

I built Trishul SNMP Studio to fix that. One Docker container. Browser-based. Free.

This post covers what's new in v1.2.4 — the biggest update yet — and why I built it this way.

What Is Trishul SNMP Studio?

It's a self-hosted SNMP dev toolkit that combines five tools into one clean web UI:

What	Instead of
SNMP Simulator (UDP agent)	`snmpsim` + CLI config
Walk & Parse → JSON	`snmpwalk` + manual OID lookup
Trap Sender + Receiver	`snmptrap` + `snmptrapd`
MIB Browser (tree view)	iReasoning MIB Browser ($500+)
MIB Manager (upload/validate)	Text editor + manual dependency hell

Stack: Python 3.11, FastAPI, pysnmp, pysmi, Bootstrap 5, Docker.

# Install in one command
curl -fsSL https://raw.githubusercontent.com/tosumitdhaka/trishul-snmp/main/install-trishul-snmp.sh | bash

Then open http://localhost:8080. Default login: admin / admin123 — change it immediately in Settings.

What's New in v1.2.4

⚡ Real-Time WebSocket Push — Polling Is Dead

The biggest architectural change: the entire frontend is now event-driven.

Before: Every page polled the backend on a setInterval — dashboard every 30s, simulator every 5s. Stale data was common. Switching pages caused spinners.

Browser ←──── WS push ────── FastAPI /api/ws
                                    │
                              broadcasts on:
                              - trap received
                              - simulator start/stop
                              - MIB uploaded
                              - stats change

The navbar shows a live green dot when the WebSocket is healthy. On reconnect, the backend sends a full_state message to re-seed everything — so you never see stale data after a network hiccup.

Why this matters for devs: If you're building a trap handler and sending test traps from the UI, you now see the counter increment on the dashboard in real time. No F5 needed.

📊 Live Activity Stats Dashboard

A new 8-counter row on the dashboard shows everything happening in your session:

SNMP Requests — Total polls served by the simulator
OIDs Loaded — OIDs currently in memory across all loaded MIBs
Traps Received / Sent — Live trap counters
Walks Executed — How many SNMP walks you've run
OIDs Returned — Total OIDs returned across all walks
MIBs Uploaded / Times Reloaded — MIB management activity

All counters update via WebSocket push. They're also file-backed — they survive container restarts so you don't lose your session history.

⚙️ Settings — Three New Cards

App Behaviour

Stats Management

Export all counters as JSON (useful for logging test session results) or reset to zero for a clean baseline before a test run.

About

Version, author, and description pulled live from the backend — always in sync with what's actually deployed.

🐛 Notable Fixes

Timestamp bug: The Trap Receiver was showing 1970 for Last Received when the backend returned a Unix epoch 0. Now guarded and shown as --.

Who Is This For?

NMS / backend developers who need a real SNMP agent to poll without actual hardware, or need to fire specific trap OIDs to validate their handler code.

DevOps / integration engineers who need to test SNMP monitoring integrations in CI/staging environments.

Network engineers who want to explore MIB structures interactively — search by OID, by name, or by description — and understand what traps a device can fire before it's on the floor.

What It's NOT For

Production 24/7 monitoring → use Zabbix, LibreNMS, PRTG
Enterprise NMS → use SolarWinds, Cisco Prime
High-availability trap collection at scale → use dedicated platforms

Trishul is a developer and testing tool, not a production monitoring system.

Quick Architecture

Browser (8080)
    │ HTTP + WebSocket
    ▼
Nginx (static files + reverse proxy)
    │ REST + WS
    ▼
FastAPI Backend (8000)
    ├── MIB Service (parse, validate, search)
    ├── SNMP Simulator (UDP 1061)
    ├── Trap Manager (send + receive on UDP 1162)
    ├── Walker (SNMP walk client)
    └── WebSocket hub (/api/ws)

Everything runs in Docker with host network mode so the SNMP UDP ports (1061, 1162) are accessible directly from your local machine or test devices.

Try It

# One-command install
curl -fsSL https://raw.githubusercontent.com/tosumitdhaka/trishul-snmp/main/install-trishul-snmp.sh | bash

# Access at
http://localhost:8080

If it's useful, a ⭐ on GitHub goes a long way — it helps other devs find the project.

Happy to answer questions in the comments about architecture decisions, the pysnmp/pysmi integration, or the WebSocket implementation. 🔱

Building Trishul-SNMP: A Modern Web-Based SNMP Toolkit to Replace $500 Commercial Tools

Sumit Dhaka — Tue, 10 Feb 2026 08:45:14 +0000

Building Trishul-SNMP: A Modern Web-Based SNMP Toolkit

I built Trishul-SNMP 🔱, a free open-source web-based SNMP toolkit that replaces 5+ commercial tools. It includes an SNMP simulator, walker, trap manager, MIB browser, and more—all in one unified platform.

🔗 GitHub: https://github.com/tosumitdhaka/trishul-snmp

⭐ Star it if you find it useful!

The Problem: SNMP Tooling is Stuck in the Past

As a network engineer, I was frustrated with the state of SNMP tooling:

What's Available Today:

Net-SNMP 🐌

Powerful but CLI-only
Steep learning curve
Need to memorize commands
No visual feedback

iReasoning MIB Browser 💰

Great GUI but costs $500+
Desktop app (not web-based)
No trap receiver
Closed source

snmpsim 🔧

Good simulator but no web interface
CLI configuration
Limited features

Custom Scripts 📝

Scattered across repos
Hard to maintain
No unified workflow

What I Needed:

✅ Web-based (access from anywhere)

✅ Free & open source (no $500 license)

✅ Unified platform (one tool for everything)

✅ Modern UI (not from 2005)

✅ Easy deployment (Docker one-liner)

So I built it. 🔱

Introducing Trishul-SNMP

A web-based SNMP toolkit with 6 integrated components:

🖥️ 1. SNMP Simulator (Server Mode)

Test SNMP agent responses without real hardware.

# Start simulator with custom OIDs
curl -X POST http://localhost:8000/api/simulator/start \
  -H "Content-Type: application/json" \
  -d '{
    "port": 1061,
    "community": "public",
    "oids": {
      "1.3.6.1.2.1.1.1.0": "Test Device v1.0",
      "1.3.6.1.2.1.1.3.0": "12345"
    }
  }'

Use case: Simulate devices for NMS development and testing.

🚶 2. Walk & Parse (Client Mode)

Test SNMP queries with automatic MIB resolution.

# Walk a device
curl -X POST http://localhost:8000/api/walker/walk \
  -H "Content-Type: application/json" \
  -d '{
    "host": "192.168.1.1",
    "community": "public",
    "oid": "1.3.6.1.2.1.1",
    "version": "2c"
  }'

Features:

Automatic OID → name resolution
Export to JSON/CSV
Bulk operations (GETBULK)
Walk history

Use case: Test SNMP agent responses, validate walk implementations.

📡 3. Trap Manager (Client + Server)

Send Test Traps (Client):

# Send trap to test receiver
curl -X POST http://localhost:8000/api/traps/send \
  -H "Content-Type: application/json" \
  -d '{
    "target": "192.168.1.100",
    "port": 162,
    "community": "public",
    "trap_oid": "1.3.6.1.6.3.1.1.5.3",
    "varbinds": [
      {"oid": "1.3.6.1.2.1.1.3.0", "value": "12345"}
    ]
  }'

Receive Test Traps (Server):

Real-time display on UDP 1162
Automatic OID resolution
Trap library with 24+ traps

Use case: Validate trap format/syntax for NMS development.

📚 4. MIB Manager

Upload and validate MIB files with dependency checking.

Features:

Drag-and-drop upload
Syntax validation
Dependency resolution
Trap enumeration
Statistics (objects, imports, traps)

Use case: Validate MIBs before deployment, centralized MIB library.

🌳 5. MIB Browser (NEW in v1.2.0!)

Interactive tree explorer for MIB structures.

Features:

Dual views: By module or OID hierarchy
Real-time search: Find OIDs by name, numeric OID, or description
Smart filtering: By module and type (scalars, tables, notifications)
Tree navigation: Expandable with configurable depth (1-5 levels)
Details panel: Full metadata, descriptions, varbinds
Integration: Jump to Walker/Trap Sender with pre-filled data
State persistence: Remembers your position

Use case: Explore MIB structures, understand OID relationships, find traps.

🔐 6. Settings

Manage authentication and preferences.

Architecture: How It Works

┌─────────────────────────────────────────────────────────────────────┐
│                      Web Browser (Port 8080)                        │
│                                                                     │
│  ┌──────────┐ ┌──────────┐ ┌───────┐ ┌──────┐ ┌────────┐ ┌─────┐    │
│  │Dashboard │ │Simulator │ │Walker │ │Traps │ │Browser │ │MIBs │    │
│  └──────────┘ └──────────┘ └───────┘ └──────┘ └────────┘ └─────┘    │
└────────────────────────────┬────────────────────────────────────────┘
                             │ HTTP
                             │
              ┌──────────────▼──────────────┐
              │   Nginx (Frontend)          │
              │   • Serves static files     │
              │   • Reverse proxy to API    │
              └──────────────┬──────────────┘
                             │ REST API
                             │
┌────────────────────────────▼────────────────────────────────────────┐
│                  FastAPI Backend (Port 8000)                        │
│                                                                     │
│  ┌───────────────────────────────────────────────────────────────┐  │
│  │                      API Endpoints                            │  │
│  │  /api/simulator/*  /api/walker/*   /api/traps/*               │  │
│  │  /api/mibs/*       /api/browser/*  /api/settings/*            │  │
│  └───────────────────────────────────────────────────────────────┘  │
│                                                                     │
│  ┌───────────────────────────────────────────────────────────────┐  │
│  │                    Service Layer                              │  │
│  │                                                               │  │
│  │  ┌─────────────────────────────────────────────────────────┐  │  │
│  │  │              MIB Service (pysmi/pysnmp)                 │  │  │
│  │  │  • Parse & validate MIB files                           │  │  │
│  │  │  • Check syntax & dependencies                          │  │  │
│  │  │  • Build OID tree (module/hierarchy views)              │  │  │
│  │  │  • Resolve OID names ↔ numeric OIDs                     │  │  │
│  │  │  • Enumerate traps (24: 19 loaded + 5 system)           │  │  │
│  │  │  • Search & filter (name, OID, type, module)            │  │  │
│  │  └─────────────────────────────────────────────────────────┘  │  │
│  │                                                               │  │
│  │  ┌─────────────────────────────────────────────────────────┐  │  │
│  │  │              SNMP Service (pysnmp)                      │  │  │
│  │  │  • Simulator: Test SNMP agent responses                 │  │  │
│  │  │  • Walker: Test SNMP client queries                     │  │  │
│  │  │  • Trap Sender: Send test traps (client)                │  │  │
│  │  │  • Trap Receiver: Receive test traps (server)           │  │  │
│  │  └─────────────────────────────────────────────────────────┘  │  │
│  │                                                               │  │
│  │  ┌─────────────────────────────────────────────────────────┐  │  │
│  │  │              Auth Service                               │  │  │
│  │  │  • Session management (token-based)                     │  │  │
│  │  │  • User authentication                                  │  │  │
│  │  └─────────────────────────────────────────────────────────┘  │  │
│  └───────────────────────────────────────────────────────────────┘  │
│                                                                     │
│  ┌───────────────────────────────────────────────────────────────┐  │
│  │                    SNMP Network Layer                         │  │
│  │                                                               │  │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐       │  │
│  │  │Simulator │  │  Sender  │  │ Receiver │  │  Walker  │       │  │
│  │  │  (SVR)   │  │  (CLI)   │  │  (SVR)   │  │  (CLI)   │       │  │
│  │  │UDP: 1061 │  │ Dynamic  │  │UDP: 1162 │  │ Dynamic  │       │  │
│  │  │          │  │          │  │          │  │          │       │  │
│  │  │Test SNMP │  │Send test │  │Receive   │  │Test SNMP │       │  │
│  │  │agent     │  │traps to  │  │test traps│  │queries   │       │  │
│  │  │responses │  │dev/test  │  │from dev/ │  │to dev/   │       │  │
│  │  │          │  │targets   │  │test env  │  │test env  │       │  │
│  │  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘       │  │
│  │       │             │             │             │             │  │
│  └───────┼─────────────┼─────────────┼─────────────┼─────────────┘  │
│          │             │             │             │                │
│  ┌───────▼─────────────▼─────────────▼─────────────▼─────────────┐  │
│  │              Data Storage (Docker Volume)                     │  │
│  │  /app/data/                                                   │  │
│  │    ├── mibs/           (MIB files for validation)             │  │
│  │    ├── sessions.json   (Auth tokens)                          │  │
│  │    └── settings.json   (User config)                          │  │
│  └───────────────────────────────────────────────────────────────┘  │
│                                                                     │
└───────────────────────────┬─────────────────────────────────────────┘
                            │ SNMP Protocol (UDP)
                            │ Host Network Mode
                            │
             ┌──────────────┴──────────────┐
             │                             │
     ┌───────▼────────┐           ┌────────▼────────┐
     │ Test SNMP      │           │  Test Trap      │
     │ Clients/Agents │           │  Receivers      │
     │ (Dev/Test Env) │           │  (Dev/Test Env) │
     │                │           │                 │
     │ • Your NMS     │           │ • Your NMS      │
     │ • Custom apps  │           │ • Trap parsers  │
     │ • Test devices │           │ • Log servers   │
     │ • Simulators   │           │ • Test apps     │
     └────────────────┘           └─────────────────┘

Tech Stack:

Backend: Python 3.11, FastAPI, pysnmp, pysmi
Frontend: Vanilla JS, Bootstrap 5
Deployment: Docker Compose, Nginx
Storage: Docker volumes for persistence

Key Technical Decisions

1. Host Network Mode for SNMP

Challenge: SNMP uses dynamic UDP ports. Traps can come from any port, not just 162.

Solution: Use Docker's host network mode.

# docker-compose.yml
services:
  backend:
    network_mode: "host"
    ports:
      - "8000:8000"  # API
      - "1061:1061/udp"  # Simulator
      - "1162:1162/udp"  # Trap receiver

Trade-off: Less isolation, but necessary for SNMP's dynamic nature.

2. MIB Parsing with pysmi

Challenge: MIBs have complex dependencies (IMPORTS clause).

Solution: Use pysmi's MibBuilder with custom sources.

from pysmi.reader import FileReader
from pysmi.searcher import StubSearcher
from pysnmp.smi import builder, view

# Initialize MIB builder
mib_builder = builder.MibBuilder()

# Add custom MIB directory
mib_builder.addMibSources(
    FileReader('/app/data/mibs')
)

# Load MIB with automatic dependency resolution
mib_builder.loadModules('IF-MIB')

# Access MIB objects
mib_view = view.MibViewController(mib_builder)

Result: Automatic dependency resolution—upload IF-MIB, and it automatically finds SNMPv2-SMI, SNMPv2-TC, etc.

3. State Persistence Across Pages

Challenge: Users lose context when switching between components (e.g., Browser → Walker).

Solution: SessionStorage for UI state.

// Save state when leaving page
sessionStorage.setItem('browserState', JSON.stringify({
    view: 'module',
    module: 'IF-MIB',
    searchTerm: 'ifDescr',
    expandedNodes: ['1.3.6.1.2.1.2'],
    selectedOid: '1.3.6.1.2.1.2.2.1.2'
}));

// Restore state on page load
window.addEventListener('DOMContentLoaded', () => {
    const state = JSON.parse(sessionStorage.getItem('browserState'));
    if (state) {
        // Restore view, search, expanded nodes, selection
        restoreState(state);
    }
});

Result: Seamless navigation. Browse a trap in MIB Browser → click "Send this Trap" → Trap Sender opens with trap pre-filled → click "Browse" → returns to same position in tree.

4. Performance: Backend Caching

Challenge: Listing 24 traps on every dashboard load is slow (parses all MIBs).

Solution: In-memory cache with 60-second TTL.

from time import time

class MibService:
    def __init__(self):
        self._trap_cache = None
        self._trap_cache_time = 0
        self._trap_cache_ttl = 60  # seconds

    def list_traps(self):
        current_time = time()

        # Return cached data if fresh
        if self._trap_cache and (current_time - self._trap_cache_time) < self._trap_cache_ttl:
            return self._trap_cache

        # Build fresh list
        traps = self._build_trap_list()

        # Update cache
        self._trap_cache = traps
        self._trap_cache_time = current_time

        return traps

Result: Dashboard load time reduced from 2s → 0.2s (10x faster).

5. Lazy Loading for MIB Tree

Challenge: Rendering 1000+ OIDs at once freezes the browser.

Solution: Load children on-demand with configurable depth.

async expandNodeRecursively(nodeEl, depth) {
    if (depth <= 0) return;

    const oid = nodeEl.dataset.oid;

    // Load only immediate children
    const res = await fetch(`/api/mibs/browse/tree/oid?root_oid=${oid}&depth=1`);
    const data = await res.json();

    // Render children
    const childrenContainer = nodeEl.querySelector('.tree-children');
    childrenContainer.innerHTML = data.children.map(child => 
        this.buildTreeNodeHtml(child, 0)
    ).join('');

    // Recursively expand if depth > 1
    if (depth > 1) {
        const childNodes = childrenContainer.querySelectorAll('.tree-node');
        for (const childNode of childNodes) {
            await this.expandNodeRecursively(childNode, depth - 1);
        }
    }
}

Features:

User selects depth: 1-5 levels (default: 3)
Only visible nodes rendered
Smooth expansion even with large MIBs

Result: Can handle MIBs with 5000+ objects without lag.

Challenges & Solutions

Challenge 1: Trap Count Inconsistency

Problem: Dashboard showed 24 traps, MIB Manager showed 19.

Root cause: System MIBs (SNMPv2-MIB, RMON-MIB) are built into pysnmp but not in the "loaded MIB" list.

Solution: Visual distinction with badges.

const knownSystemMibs = ['SNMPv2-MIB', 'RMON-MIB', 'IF-MIB'];
const loadedModules = new Set(loadedMibs.map(m => m.module));

traps.forEach(trap => {
    const isSystemMib = knownSystemMibs.includes(trap.module) 
                        && !loadedModules.has(trap.module);

    // Gray badge for system MIBs, blue for loaded
    const badge = `
        <span class="badge ${isSystemMib ? 'bg-secondary' : 'bg-primary'}">
            ${trap.module}
        </span>
        ${isSystemMib ? '<span class="badge bg-secondary">System</span>' : ''}
    `;
});

Result: Clear distinction—users understand which MIBs are built-in vs. uploaded.

Challenge 2: Docker Image Size

Problem: Initial image was 1.2GB (too large for quick pulls).

Solution: Multi-stage builds + Alpine base.

# Build stage
FROM python:3.11-slim as builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --user --no-cache-dir -r requirements.txt

# Runtime stage
FROM python:3.11-alpine
WORKDIR /app

# Copy only installed packages
COPY --from=builder /root/.local /root/.local

# Copy application
COPY . .

# Set PATH
ENV PATH=/root/.local/bin:$PATH

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Result: Image size reduced to 350MB (70% smaller).

Challenge 3: MIB Browser Tree Performance

Problem: Expanding large MIBs (e.g., CISCO-SMI with 3000+ objects) caused browser freeze.

Solutions implemented:

Lazy loading: Load children only when node is expanded
Depth control: User chooses 1-5 levels (prevents over-expansion)
Debounced search: 500ms delay to avoid excessive API calls
Virtual scrolling: Only render visible nodes (future enhancement)

// Debounced search
let searchTimeout;
searchInput.addEventListener('input', (e) => {
    clearTimeout(searchTimeout);
    searchTimeout = setTimeout(() => {
        performSearch(e.target.value);
    }, 500);  // Wait 500ms after user stops typing
});

Result: Smooth navigation even with 5000+ object MIBs.

Lessons Learned

1. Start with MVP, Iterate Based on Feedback

v1.0.0 (June 2025):

4 components: Simulator, Walker, Traps, MIB Manager
Basic functionality

v1.2.0 (Feb 2026):

Added MIB Browser (most requested feature)
Enhanced trap management
State persistence

Lesson: Ship early, listen to users, add features they actually need.

2. Documentation is as Important as Code

I spent 20% of development time on documentation:

Comprehensive README
Architecture diagrams
API documentation (FastAPI auto-docs)
Code comments
Contributing guidelines

Result: 150+ stars in 2 months, active community.

Lesson: Good docs = more users = more contributors.

3. One-Command Install is Crucial

Users won't read complex setup instructions.

Bad:

# Clone repo
git clone ...
cd trishul-snmp

# Install dependencies
pip install -r requirements.txt
npm install

# Configure
cp .env.example .env
vim .env

# Build
docker-compose build

# Run
docker-compose up -d

Good:

curl -fsSL https://raw.githubusercontent.com/tosumitdhaka/trishul-snmp/main/install-trishul-snmp.sh | bash

Result: Lower barrier to entry = more users trying it.

4. Open Source ≠ Free Labor

Be clear about support expectations:

✅ Added:

Code of Conduct
Contributing guidelines
Issue templates
Pull request template
License (MIT)

✅ Set boundaries:

Response time: "Best effort, usually within 48 hours"
Feature requests: "Vote on issues, no guarantees"
Support: "Community-driven, use Discussions"

Lesson: Protect your time while being welcoming.

5. Community Matters

What worked:

GitHub Discussions for Q&A
Twitter/LinkedIn posts
Dev.to articles (like this one!)
Responding to every comment/issue

What didn't:

Discord server (too early, not enough users)
Weekly newsletters (too much overhead)

Lesson: Focus on platforms where your users already are.

Results (8 Months After Launch)

⭐ 150+ GitHub stars
🍴 25+ forks
🐳 500+ Docker pulls
💬 Active community in Discussions
🏢 3 companies using in production (for dev/test)
📝 5 blog posts by community members

What's Next? v1.3.0 Roadmap

🚧 In Progress:

🔐 SNMPv3 authentication (MD5, SHA, AES encryption)
⏰ Scheduled SNMP walks (cron-like syntax)
📧 Notifications (Email/Slack/Webhook for traps)

📋 Planned:

📊 Custom dashboards (drag-and-drop widgets)
🔑 API keys (rate limiting, authentication)
📦 Bulk device management (import/export CSV)
📈 Historical data (time-series graphs)
🌙 Dark mode
🌍 Multi-language support (i18n)

Vote on features: https://github.com/tosumitdhaka/trishul-snmp/issues

Try It Yourself

Quick Start:

curl -fsSL https://raw.githubusercontent.com/tosumitdhaka/trishul-snmp/main/install-trishul-snmp.sh | bash

Access:

Frontend: http://localhost:8080
Default login: admin / admin123

Explore:

Upload a MIB file (try IF-MIB)
Browse the MIB tree
Walk a device (or use the simulator)
Send a test trap
Explore trap library

Contributing

Trishul-SNMP is 100% open source (MIT License).

Ways to contribute:

⭐ Star the repo
🐛 Report bugs
💡 Suggest features
🔧 Submit PRs
📝 Write tutorials
💰 Sponsor development

GitHub: https://github.com/tosumitdhaka/trishul-snmp

Conclusion

Building Trishul-SNMP taught me:

Modern web tech can revitalize old protocols - SNMP is from 1988, but a good UI makes it accessible
Open source is about community, not just code - Documentation, support, and engagement matter
Good UX matters, even for network tools - Engineers appreciate beautiful, intuitive interfaces too
Start small, iterate fast - MVP → feedback → features users actually want

If you work with SNMP, give it a try. If you find it useful, star the repo and share it!

Questions? Comments? Drop them below or open a GitHub Discussion.

About the Author

I'm Sumit Dhaka, a devops & integration engineer who loves building tools that make life easier.

Connect with me:

🐙 GitHub: @tosumitdhaka
💼 LinkedIn: Sumit Dhaka
📧 Email: sumitdhaka@zohomail.in

Note: Its an AI generated article and may have some inconsistency.

Tags: #snmp #networking #opensource #python #fastapi #docker #devops #webdev #mib #networkengineering