codewithsam110g · ssrk.dev

Platform Intern @ TANUH, IISc | B.Tech ECE @ RGUKT Systems Engineering · Platform Engineering · Edge AI · Open Source

I like building systems from the hardware boundary upward — from low-level tooling and inference runtimes to backend platforms, observability, and infrastructure.

I'm a systems-focused engineer who enjoys problems where software architecture meets real hardware and operational constraints.

My work spans platform engineering, Linux systems, backend architecture, machine learning, edge deployment, and developer tooling. I care especially about memory behavior, performance, reliability, observability, and understanding the layers underneath the abstractions I use.

• Currently a Platform Intern at TANUH, IISc.
• Building and experimenting across systems engineering, platform infrastructure, ML/Edge AI, and developer tooling.
• Interested in direct memory management, distributed systems, observability, HA, and Kubernetes-oriented infrastructure.
• Prefer understanding and designing the system over treating deployment as a collection of black boxes.

• 🌐 Website: ssrk.dev
• 📫 Email: me@ssrk.dev
• 💼 LinkedIn: linkedin.com/in/samba-siva-rao-kovvuru

I spend a significant amount of time building and operating my own infrastructure through ssrk.dev.

It serves as a personal platform for experimenting with:

• self-hosted applications and developer services
• Linux and container infrastructure
• identity and SSO
• reverse proxies and edge networking
• metrics, logs, health monitoring, and observability
• self-hosted Git and infrastructure-as-code workflows
• security-oriented infrastructure design

The goal isn't to recreate a hyperscaler at home — it's to understand how the pieces fit together and have a real environment where architecture decisions have consequences.

Working with machine-learning systems designed for constrained and edge environments, including:

• PyTorch and MONAI
• evidential and credal learning
• medical imaging pipelines
• ONNX-based deployment
• Android / NNAPI acceleration
• hardware-aware inference

Building a high-performance, binary-compatible 8086 emulator and parser in Rust, with an emphasis on correctness, efficient instruction decoding, and systems-level design.

Built a TypeScript-to-Dart transpilation toolchain to replace legacy binding-generation workflows and automate cross-language API bindings.

Built a custom Linux-based operating environment from the ground up, including kernel compilation, system configuration, package integration, and driver troubleshooting.

Maintainer of Dart bindings for Uber H3 through h3_flutter_plus, with the project recognized in upstream H3 documentation.

• Rust — Tokio, parsers, emulators, systems tooling
• C / C++
• Linux internals and kernel compilation
• Arch Linux
• Bash and shell tooling
• Make / CMake
• debugging, profiling, and performance-oriented development

• Kubernetes — CKA in progress
• Docker / Docker Compose
• Helm
• NGINX
• Linux networking
• AWS — SAA in progress
• self-hosted infrastructure
• DNS and edge routing
• infrastructure and service observability

• Prometheus
• Grafana
• Loki
• Alloy
• application and infrastructure health monitoring
• centralized metrics and logging

• OAuth 2.0 / OpenID Connect
• SSO and identity-aware services
• Authentik
• Forgejo / Git
• secure service exposure and access boundaries

• PyTorch
• MONAI
• Evidential / Credal Networks
• ONNX
• NNAPI
• sensor fusion
• hardware-aware inference

• Go — chi, REST APIs, concurrent services
• Python — FastAPI, Django, async and multi-threaded systems
• API and service architecture
• Domain-Driven Design
• distributed and microservice-oriented systems

• PostgreSQL
• MongoDB
• SQLite
• Redis

• Dart
• Flutter
• native FFI and bindings
• mobile and web applications

I tend to prefer systems that are:

• observable before they become complicated
• documented before their architecture disappears into tribal knowledge
• explicit about trust and failure boundaries
• understandable without depending entirely on managed abstractions
• optimized only after there is something real to measure

I'm equally happy reading kernel logs, debugging a parser, tracing an HTTP request through infrastructure, or profiling an inference pipeline.

Docs-first. Systems-first. Hype-last. RTFM is religion. Design before deploy.