AMAN KUMAR PANDEY BCA STUDENT DEVELOPER · INDIA · MACOS & KALI LINUX LAB

OPEN FOR SOFTWARE & SECURITY ROLES

Software · Automation · Security

Building software, learning systems, and exploring security.

I'm Aman — a BCA student developer from India. I spend my days poking at system internals, writing CLI utilities, and building open-source security tools across macOS and Kali Linux. Most of my projects begin with an itch — finding where a workflow breaks or eliminating friction — and end up as clean, verifiable code on GitHub.

View projects GitHub Resume Contact

FEATURED PROJECT TraceForge OSINT / DFIR investigation toolkit

AUTOMATION Astra Engine Async WhatsApp Web automation

OPEN SOURCE Public code Available on GitHub & PyPI

LOCAL-FIRST Runs on your machine Offline triage, zero tracking

02 / SELECTED WORK

A few things I've built.

Open-source tools and libraries with public code you can inspect on GitHub.

paman@macbook-air: ~/traceforge (zsh)

$ traceforge tools ioc-extract ./incident_evidence.txt --defang
[+] Scanned 4,120 lines in 18ms (via optimized chunked engine)
[+] Extracted 14 indicators of compromise:
    [IP]     198.51.100.24         → defanged: 198.51.100[.]24
    [IP]     203.0.113.19          → defanged: 203.0.113[.]19
    [DOMAIN] malicious-c2.test     → defanged: malicious-c2[.]test
    [URL]    http://bad.test/drop  → defanged: hxxp://bad[.]test/drop
    [HASH]   e3b0c44298fc1c149afb… → indexed SHA-256

01 / IOC Extraction & Defanging

02 / HASH SHA-256 Custody

03 / TIME Event Normalization

04 / EXPORT STIX · MISP · JSONL

SWITCH TABS OR TRY COMMANDS IN THE INTERACTIVE CLI

01 · FEATURED PROJECT · OSINT & DFIR TOOLING

v1.0.1 on PyPI

TraceForge

A local-first command-line toolkit for digital forensics, OSINT, and incident response. Built to run entirely on your own machine without sending evidence or queries to third-party servers.

Python 3.10+ SQLite WAL Ledger macOS (Apple Silicon) Kali Linux 2026 Termux (Android) PyPI: traceforge-osint

What is it? A local-first command-line toolkit for digital forensics, OSINT collection, and incident triage. It runs entirely on the analyst's machine without transmitting hashes, logs, or queried indicators to third-party cloud servers.

Why did I build it? I wanted to understand how digital forensic triage works under the hood. Many cloud OSINT tools leak queried IP addresses and file hashes to third parties, violating confidentiality and breaking the chain of custody. I built TraceForge to keep all investigations 100% offline.

How does it work? Uses 64 KB chunked streaming I/O buffers and Python multiprocessing pools to hash directory snapshots and scan large log files without memory spikes. Defangs indicators (IPs, URLs, domains) using regular expressions, stores audit trails in an ACID-compliant local SQLite WAL database, and exports incident bundles to STIX 2.1 JSON.

What did I learn? Designing memory-efficient streaming buffers in Python, managing embedded SQLite schema migrations with Write-Ahead Logging, cross-platform Unix development across macOS (Apple Silicon) and Kali Linux, and packaging CLI software for PyPI.

Read case study Dev tools GitHub

AUTOMATION LIBRARY Open Source

Astra Engine

An asynchronous Python library for headless WhatsApp Web automation. Built using Playwright to manage pairing codes, session state, and background event loops without needing a visible browser window.

Why I built it: Existing automation scripts frequently broke on QR refreshes and required heavy GUI browsers. I wanted a clean headless library that connects over pairing codes and emits structured events.

How it works: Injects an in-browser JavaScript bridge to capture incoming message events and dispatch them to async Python callbacks without polling.

What I learned: Asynchronous event loop dispatching in Python, WebSocket connection lifecycle management, and reverse-engineering web client protocols.

Python 3 Playwright AsyncIO JS Bridge WebSockets

BOT FRAMEWORK Modular

Astra Userbot

A modular bot framework built on top of Astra Engine featuring dynamic runtime plugin loading, local state stored in SQLite, and production Linux systemd service configurations.

Why I built it: After writing Astra Engine, I needed an extensible application where custom commands could be dropped in as single .py files without altering the core codebase.

How it works: Uses Python's importlib for dynamic plugin discovery, isolates configuration in SQLite, and provides systemd daemon templates for 24/7 background operation.

What I learned: Extensible plugin architecture, runtime module importing, and writing resilient systemd service definitions on Linux.

Python 3 Plugin Architecture SQLite Linux Systemd

CONTAINER SERVICE Node.js

WhatsApp-X

A containerized Node.js service for WhatsApp automation, chat history persistence, and media transcoding pipelines.

Why I built it: An earlier exploration into server-side JavaScript automation, streaming media pipelines, and containerized deployments.

How it works: Automates headless Chromium via Puppeteer, pipes incoming voice notes and stickers through FFmpeg for normalization, and logs records in MongoDB.

What I learned: Preventing memory leaks in long-running Puppeteer processes, handling binary streams with FFmpeg, and multi-stage Docker builds.

Node.js Puppeteer MongoDB Docker FFmpeg

SYSTEMS & HARDENING Sysadmin

Windows Tools & Hardening

A menu-driven PowerShell and Batch utility for administrative automation, system maintenance, and workstation privacy hardening.

Why I built it: Repetitive workstation administration is error-prone. I wanted a transparent, open-source script to audit services and clean caches without installing third-party utilities.

How it works: Uses native PowerShell cmdlets and WMI/CIM queries to audit background services, flush DNS and temporary caches, and apply registry policy hardening.

What I learned: Windows WMI/CIM querying, PowerShell registry manipulation, and administrative scripting best practices.

PowerShell Batch Windows WMI Workstation Hardening

See all repositories on GitHub ↗

WHAT I FOCUS ON

Building tools, learning systems, and exploring security.

I started out building automation scripts and web scrapers, and now I spend most of my time learning systems programming and cybersecurity. I learn best by building from scratch: understanding protocols by dissecting raw packets in Wireshark, learning defensive principles by writing offline triage utilities, and writing chunked streaming buffers when processing large log files or disk images.

SECURITY TOOLING OSINT & Digital Forensics

Writing command-line tools for IOC extraction, evidence hashing, timeline analysis, and log triage.

SYSTEMS Linux & Networking

Learning operating system internals, bash scripting, network packet flows, and system administration.

DEVELOPMENT Python & Bash

Writing clean, typed Python for application logic and robust Bash scripts for system automation and diagnostics.

RELIABILITY Testing & Documentation

Writing automated tests and detailed READMEs so other people (and future me) can actually run my code.

TECHNICAL CAPABILITIES

Where I stand: what I've built, what I'm learning, and what I'm exploring.

An honest breakdown of my current skills as a student developer moving deeper into systems and security.

BUILT · PRODUCTION & PROJECTS Software & Automation

Command-line tools (TraceForge on PyPI), headless automation libraries (Astra Engine, WhatsApp-X), SQLite WAL ledgers, and streaming file processors.

Python 3 SQLite WAL Bash AsyncIO Playwright Docker

LEARNING · ACTIVE STUDY Linux Internals & Networking

Operating system architecture, socket programming, network packet inspection with Wireshark and tshark, and OWASP Top 10 vulnerabilities.

Linux Internals tshark Wireshark Socket API OWASP Top 10 Computer Networks

EXPLORING · LABS & PRACTICE Defensive Security & Triage

Solving CTF challenges, analyzing malware incident writeups, defensive auditd log analysis, and system privacy hardening.

CTF Challenges DFIR Triage Auditd Hardening Incident Write-ups

WORKSTATION & TESTBEDS macOS & Kali Linux Environments

Daily software engineering in a native macOS (Apple Silicon Darwin zsh) environment; virtualized security testing and packet dissection in a dedicated Kali Linux lab.

macOS (Apple Silicon) Kali Linux 2026 Zsh Shell Termux

NOTES & CASE STUDIES

Write-ups & case studies.

Detailed write-ups covering how my projects work, why I made specific design choices, and what went wrong along the way.

FEATURED WRITE-UP · CASE STUDY 01 Inside TraceForge: Engineering a Local-First OSINT & DFIR Toolkit

Why I built TraceForge, how I structured forensic workflows in Python, and the practical systems lessons learned along the way.

Read case study →

ABOUT ME

Background & education.

I'm Aman — a BCA (Bachelor of Computer Applications) student based in India. I'm drawn to software engineering, systems programming, and defensive cybersecurity. Most of what I build starts with a simple question: "how does this actually work under the hood?" The best way for me to answer that is to write code, test it against real data, and see where it breaks.

My college coursework covers core computer science foundations — Data Structures & Algorithms, Object-Oriented Programming, Database Management Systems (DBMS), Operating Systems, and Computer Networks. Outside of coursework, I spend my time writing Python, Bash, and SQL, building local-first command-line utilities, and learning how network protocols operate by inspecting raw packet captures.

I care about building software that runs locally without unnecessary telemetry, keeping dependencies lean, and documenting setup instructions clearly so other developers can run the code without guesswork.

EDUCATION BCA (Bachelor of Computer Applications)

LOCATION India

EMAIL paman7647@proton.me

RESUME View / Print Resume (PDF) ↗

GITHUB @paman7647 ↗

STATUS Open for Software & Security Roles

CONTACT

Get in touch.

DIRECT EMAIL paman7647@proton.me ↗ RESUME View & Print Resume (PDF) ↗ GITHUB @paman7647 ↗ REPOSITORIES All projects on GitHub ↗