Forem: Sarav AK

ConfMap: Transform Your Configuration Files into Interactive Mind Maps

Sarav AK — Mon, 22 Sep 2025 13:30:33 +0000

How many times have you opened any Complex YAML or JSON file or a complex application configuration and felt overwhelmed by the nested structure?

You know the data is there, but understanding the relationships and hierarchy feels like solving a puzzle.

ConfMap solves this problem by transforming your configuration files into beautiful, interactive mind maps that make complex structures instantly understandable, searchable, extractable and more.

🚀 What is ConfMap?

ConfMap is an open-source tool that converts YAML, JSON, and YML configuration files into interactive mind maps with intelligent 13-level color coding. Think of it as a visual debugger for your configuration files.

Try it live: https://confmap.com

Quick Demo on ConfMap

✨ Key Features - Curated from the feedback and pain

🎨 Intelligent Color Coding

13 distinct colors for different hierarchy levels
Automatic color cycling for deeper nesting
Visual legend showing all color levels

🔍 Powerful Search & Navigation

Find and highlight ALL matching nodes
Navigate results with ↑/↓ arrow keys
Smart highlighting with visual feedback

🧹 TidyUp Mode (My Personal Favorite!)

Press Alt+T to focus on any node's lineage
Shows only the path from root + all descendants
Perfect for understanding complex nested structures

📝 Word Wrapping for Long Text

Press Alt+W to toggle word wrapping
Handles those ridiculously long configuration keys
Makes everything readable without horizontal scrolling

🎯 Multiple Layouts

Horizontal: Traditional left-to-right flow
Vertical: Top-to-bottom hierarchy
Radial: Circular, centered view

🌀 Copy Lineage Feature

Press Ctrl+C to copy any node's lineage
Multiple formats: tree view and YAML-like structure
Perfect for documentation and debugging

⌨️ Keyboard Shortcuts (Because We Love Efficiency)

Click on the Help section of the app to get to know all the shortcuts available - I know Legends does not use mouse

🛠️ Built with Modern Tech

TypeScript for type safety
ECharts for beautiful visualizations
Tailwind CSS for responsive design
Vite for lightning-fast builds

How to use it

Option 1: Use the Live Version (Recommended)

Visit https://confmap.com
Upload your configuration file ( Its locally rendered - data is not shared anywhere)
Start exploring immediately!

Option 2: Run Locally

# Clone the repository
git clone https://github.com/aksarav/confmap.git
cd confmap

# Install dependencies
npm install

# Start development server
npm run dev

# Open map.html in your browser

🤝 Contributing & Community

ConfMap is open-source and we'd love your contributions! Whether it's:

🐛 Bug reports
💡 Feature suggestions
🔧 Code contributions
📖 Documentation improvements

Visit our GitHub repository to get involved.

*⭐ Star the repo if you find it useful! Your support helps us continue improving.
*

🎯 Why This Matters

Configuration files are the backbone of modern applications, but they're often treated as an afterthought.

ConfMap and our other initiaves like ConfQL, YamlQL bridges the gap between complex configurations and human understanding, making your development workflow more efficient and less error-prone.

What's Next?

We're constantly adding new features based on community feedback.

Some ideas in the pipeline:

Support for more file formats (TOML, INI, etc.)
Collaborative editing features
Configuration diff visualization
Integration with popular IDEs as Extension

Query YAML Like a Database — Why I Built YamlQL (And How It Works)

Sarav AK — Fri, 20 Jun 2025 22:02:58 +0000

Have you ever tried to grep through large set of Kubernetes YAML files just to figure out which pods are missing CPU limits?

I did.
And I hated it.

So I built YamlQL — a tool that lets you query YAML files using SQL.

YAMLQL has three mode of opeartions

Discover the schema of your YAML file
Run manual SQL queries over YAML
Use AI to generate SQL (schema-aware, no data sent)

YamlQL is a CLI + Python tool that converts YAML into DuckDB tables, so you can query it like a database.

😵‍💫 YAML is beautiful until it is not

YAML is beautiful for humans to write — but a nightmare to audit or analyze at scale. You’ve likely seen it everywhere:

• Docker Compose
• Kubernetes manifests
• Helm values
• GitHub Actions
• CircleCI, ArgoCD, and more

But try to ask simple questions like:

• “Which containers expose port 80?”
• “Where did we forget resources.limits.memory?”
• “Are any services still using HTTP?”

You’re stuck with grep, yq, or writing ad-hoc scripts that break when a field is missing or nested differently.

YAML as a language has various problems

The following article is a great summary of the problems with YAML:

https://ruudvanasseldonk.com/2023/01/11/the-yaml-document-from-hell

🛠️ What I Built: YamlQL

YamlQL is a CLI + Python tool that converts YAML into DuckDB tables, so you can query it like a database.

✅ Key Features
• discover — See the schema of your YAML file
• sql — Run manual SQL queries over YAML
• ai — Use AI to generate SQL (schema-aware, no data sent)
• Supports nested structures, lists, dicts
• Works locally, offline, and fast

Let's see how YAMLQL works with an example

The Sample Deployment file

Lets consider the following kubernetes deployment manifest for an example

apiVersion: apps/v1
kind: Deployment
metadata:
  name: complex-app
  labels:
    app: complex-app
    tier: backend
  annotations:
    prometheus.io/scrape: "true"
    prometheus.io/port: "9090"
spec:
  replicas: 3
  selector:
    matchLabels:
      app: complex-app
  template:
    metadata:
      labels:
        app: complex-app
        version: v1
    spec:
      volumes:
        - name: config-volume
          configMap:
            name: app-config
        - name: secret-volume
          secret:
            secretName: app-secrets
        - name: shared-logs
          emptyDir: {}
      containers:
        - name: main-app
          image: myorg/main-app:latest
          ports:
            - containerPort: 8080
          env:
            - name: APP_ENV
              value: production
            - name: CONFIG_PATH
              value: /etc/config
            - name: SECRET_TOKEN
              valueFrom:
                secretKeyRef:
                  name: app-secrets
                  key: token
          volumeMounts:
            - name: config-volume
              mountPath: /etc/config
            - name: shared-logs
              mountPath: /var/log/app
          livenessProbe:
            httpGet:
              path: /health
              port: 8080
            initialDelaySeconds: 30
            periodSeconds: 10
          readinessProbe:
            httpGet:
              path: /ready
              port: 8080
            initialDelaySeconds: 10
            periodSeconds: 5
          resources:
            requests:
              cpu: "500m"
              memory: "256Mi"
            limits:
              cpu: "1"
              memory: "512Mi"
        - name: sidecar-logger
          image: fluent/fluentd:latest
          ports:
            - containerPort: 24224
          volumeMounts:
            - name: shared-logs
              mountPath: /fluentd/log
          env:
            - name: FLUENTD_CONF
              value: fluentd.conf
        - name: metrics-exporter
          image: prom/node-exporter
          ports:
            - containerPort: 9090
          resources:
            limits:
              cpu: "100m"
              memory: "128Mi"

Discover

Before writing the query - you need to know how this YAML file is converted as a table and its schema

So first we use the discover mode

yamlql discover deployment.yaml

🧠 Write SQL queries Manually

Now we know the Table and the field names and the Schema of this file - Let us put it to use

Lets write some SQL queries to get the data from YAML

👨‍💻 Write SQL queries with AI - without sharing your actual Data

As English has become the new programming language in the ERA of Software 3.0

Let us do some Vibe Code and write Natural Language Query which would be sent to AI along with the schema - without sharing the actual data

LLM is used here only for converting the NLP to SQL with schema as an input

🎥 Video Demo

https://www.youtube.com/watch?v=6MRYTz027Fc

🤖 YAML in RAG and AI Workflows

This started as a tool for my RAG pipelines.

I needed to:
• Ingest YAML-based metadata (Helm, K8s, config files)
• Normalize it
• Extract relevant structured data before embedding

YamlQL made it clean, SQL-native, and easy to scale.

✨ It’s Open Source

Find the sourcecode here and feel free to contribute and improve

https://github.com/AKSarav/YamlQL

Install with pip

pip install yamlql

Here are some example commands you can use

yamlql discover yourfile.yaml
yamlql sql yourfile.yaml --query "SELECT * FROM metadata"

I’d Love Your Feedback and contribution

What would make this more useful in your workflow?
What’s missing before you’d use this in CI/CD?
Would you want to see it in YAMLQL

Leave a comment, open an issue, or just ping me.

I’m building this in the open, and you hoping it would help someone and with your feedback and contribute this can go further.

Thanks
Sarav

Find me on LinkedIn
https://www.linkedin.com/in/aksarav/