Python developer building functional applications across automation, e-commerce, and backend infrastructure. Specialized in secure software design, child-safe browsing architectures, and data workflows.
Total Repositories
Core Frameworks
Industry Domains
Code Executions
Production-grade logic built across three core tech segments
Designing sandboxed network applications, child-safe web routing rules, and restricted execution environments to handle secure browsing safely.
Developing database product schemas, secure transactional checkouts, cart management utilities, and multi-user platform flows.
Structuring clean MVC routing architectures, data processing automation flows, custom CSV management frameworks, and API logging utilities.
Systems built for production
A secure sandboxed browsing tool with automated content filtering algorithms, restricted keyword matching matrices, and child-safe network domain routing layouts.
Full-stack web deployment supporting dynamic inventory structures, cart workflows, data-driven order tracking state layers, and authenticated client execution profiles.
Engineered pipeline optimization components handling secure CSV workflows, database normalization steps, automated process streams, and systemic performance instrumentation.
High-efficiency execution model running on centralized multi-threaded process modules to standardize complex analytical tasks and transaction payload records.
Python developer with experience building production systems across automation, e-commerce, and foodtech. I architect clean applications, focus on secure routing models, and implement data workflows that optimize backend execution paths.
My software engineering journey began with a deep interest in automated scripts and secure file architectures. What started as micro-utilities quickly evolved into developing functional web architectures, sandboxed browsing modules, and company product registries.
I thrive on translating logical problems into readable, production-grade applications. Building projects from scratch has taught me how to strike the right balance between rapid deployment pipelines and clean software engineering paradigms.
Designing sandboxed environments, content filtering layers, threat signature monitors, and isolated workflow paths.
Structuring relational database engines, operational item managers, user sessions, and transactional state layers.
Developing corporate grain mill platforms, supply tracking displays, and specialized B2B product catalogs.
Technologies I use to build production systems
Production systems built across cybersecurity, fintech, and foodtech —
from concept to deployment at scale.
A secure sandboxed browsing tool with automated content filtering algorithms.
A production grade corporate web platform engineered for a pulse processing mill.
Full-stack web deployment supporting dynamic inventory structures and order tracking.
A comprehensive software application designed to streamline academic monitoring.
Deep technical breakdowns of production systems — architecture decisions, hard problems, and lessons learned while building software.
High-performance FastAPI backend with PostgreSQL, modular APIs, validation, and scalable request handling.
I love discussing architecture tradeoffs and production engineering.
Let's Talk ArchitectureTechnical writing on backend architecture, cybersecurity, serverless systems, and lessons from building production platforms.
How and why I built GarudaEye — a single-binary AWS asset discovery and security analysis tool with an embedded dashboard, no API keys required, and a passive fingerprinting engine written entirely in Rust.
What I learned building, launching, and operating security platforms as a solo engineer. Product decisions, technical tradeoffs, and mistakes to avoid.
Organizations struggle to maintain visibility into their internet-facing assets. Here's why attack surface monitoring remains an unsolved problem and what it takes to build effective solutions.
Technical writing on backend architecture, cybersecurity, serverless systems, and lessons from building production platforms.
How and why I built GarudaEye — a single-binary AWS asset discovery tool with an embedded dashboard, no API keys required, and a passive fingerprinting engine written entirely in Rust.
There's a loop I kept running every time I wanted a quick security picture of an AWS environment.
Install the scanner. Grab the Shodan API key. Set up the Censys token. Figure out why the dashboard isn't connecting to the backend. Stitch together output from three different JSON dumps.
I got tired of it. So I built GarudaEye.
Rust's async runtime (Tokio) handles the concurrent scanning naturally. Collecting 17 different AWS resource types across multiple regions simultaneously is exactly what it is designed for.
// Simplified orchestrator — collectors run concurrently per region
let handles: Vec<_> = regions
.iter()
.flat_map(|region| collectors.iter().map(|c| c.collect(region)))
.map(tokio::spawn)
.collect();
Individual findings are useful. Attack paths are actionable. The attack path engine runs after fingerprinting completes and looks at relationships between assets.
| Path Type | Severity |
|---|---|
| ExposedDatabase | Critical |
| WeakTLS | High |
export MODE=cloud
./garudaeye --mode cloudgit clone https://github.com
cargo run -- --openBuilding cybersecurity products as a solo engineer is simultaneously liberating and terrifying. You control every decision—and own every mistake.
Over the past several years, I've built multiple security platforms from scratch: RiskProfiler, CloudFrontier, and CIS CSAT. Here's what I learned.
Mistake I made: Starting with "I want to build a serverless security platform" instead of "organizations can't see their attack surface." The technology should serve the problem, not the other way around.
How I Course-Corrected: I spent weeks talking to security teams to discover:
Most didn't care about serverless architecture or DynamoDB performance. They cared about seeing unknown assets, reducing false positives, and getting actionable alerts.
As a solo engineer, operational burden is your enemy. Stick to reliable infrastructure elements that won't require midnight maintenance pipelines.
Technologies I Chose:
Early-stage products require rapid experimentation. Adopting monorepos, keeping an API-first interface pattern, deploying automated confidence tests, and using runtime feature flags allowed high deploy agility.
from feature_flags import is_enabled
def scan_target(target, org_id):
if is_enabled('advanced_scanning', org_id):
return advanced_scan(target)
return basic_scan(target)Your time is the scarcest resource. If you do an administrative or operational step more than twice, automate it immediately.
# GitHub Actions automated branch deploy workflow
on:
push:
branches: [main]
jobs:
deploy:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Deploy to AWS
run: serverless deploySecurity products face structural hurdles that other SaaS verticals don't experience:
Building cybersecurity platforms as an independent solo engineer is challenging but immensely rewarding. When you bridge customer focus with ruthless operational discipline, the journey teaches you complete architecture full-stack product ownership.
Despite billions invested in cybersecurity, most organizations can't answer a simple question: "What assets do we have exposed to the internet?"
This isn't a new problem. Yet in 2026, attack surface monitoring remains fundamentally difficult. Here's why.
Modern organizations have assets scattered across dynamic perimeters:
Manual inventories do not scale; they are outdated the moment they are written. Network scanners contain massive blind spots because cloud services leverage ephemeral configurations, Third-Party CDNs, and dynamic container IPs.
1. Continuous Discovery:
2. Multi-Source Correlation: Merely collecting asset dumps creates data fatigue. Platforms must validate discovered entities against active cloud configurations, separate expected infrastructure from anomalies, and filter out false indicators.
3. Context-Aware Alerts & Integration: Blasting standard port notifications turns down operator attention. Security signals must verify if an open endpoint interacts with customer production environments, holds sensitive datasets, or integrates into standard issue queues (Jira, Slack).
Managing Rate Limiting policies across public DNS queries and throttling points within certificate logs requires advanced request queue mechanics. Additionally, tracking millions of assets over historical time windows introduces scale parameters that require robust data processing architectures.
Through platforms like CloudFrontier and RiskProfiler, I addressed these data ingestion layers via multi-threaded Python ingestion loops:
def discover_assets(organization):
sources = [
dns_enumeration(org.domains),
cert_transparency_search(org.domains),
cloud_api_discovery(org.cloud_accounts),
shodan_search(org.ip_ranges),
github_search(org.repositories)
]
# Correlate and deduplicate across ingested targets
assets = correlate_sources(sources)
# Enrich entities with live infrastructure context
return enrich_asset_data(assets)Attack surface monitoring remains challenging because environments change faster than systems can track them. The path forward combines continuous automated discovery with data correlation to deliver actionable visibility.
A snapshot of what I'm currently working on and thinking about. Inspired by Derek Sivers' now page movement.
Active projects and explorations.
Building security tools specifically for AI interfaces and LLM platforms. The attack surface for AI systems is fundamentally different — model poisoning, prompt injection, data leakage through embeddings.
Exploring automated prompt injection detection, ML model vulnerability scanning, and guardrails for LLM-powered applications.
Researching how cyber insurance companies assess risk and exploring ways to automate technical risk scoring. The goal: real-time, data-driven assessments based on actual security posture.
Key areas: continuous attack surface monitoring, vulnerability intelligence aggregation, and breach probability modeling.
Building tools to help security teams monitor for leaked credentials, exposed databases, and compromised systems on dark web forums and marketplaces.
Technical challenges: data collection from hidden services, credential matching, and privacy-preserving alerting.
Integrating RiskProfiler's detection capabilities to discover shadow IT, forgotten test environments, and misconfigured cloud resources — assets organizations didn't know were exposed.
Focus: subdomain enumeration, cloud storage bucket discovery, API endpoint fuzzing, and repository exposure checks.