Skip to content
View deannos's full-sized avatar
🎯
Focusing
🎯
Focusing

Block or report deannos

Block user

Prevent this user from interacting with your repositories and sending you notifications. Learn more about blocking users.

You must be logged in to block users.

Maximum 250 characters. Please don't include any personal information such as legal names or email addresses. Markdown supported. This note will be visible to only you.
Report abuse

Contact GitHub support about this user’s behavior. Learn more about reporting abuse.

Report abuse
deannos/README.md

Amish Jha

Software Engineer | Backend & Systems Architecture | Cloud/DevOps

I build reliable backends, scalable event-driven pipelines, and developer-friendly tools. Focused on clean architecture, performance, observability, and production readiness.

LinkedInGitHubLeetCodeCodeChefEmail


About

  • Backend engineering, systems, and cloud-native deployments
  • Strong focus on performance, API design, observability, and developer experience
  • Comfortable owning work end-to-end: design → implementation → deployment → monitoring
  • Problem-solving mindset: algorithmic rigor with real-world tradeoffs

What I Bring to a Team

Backend and Systems Engineering

  • API design: REST, pagination/filtering, versioning, predictable contracts
  • Performance: batching, pooling, concurrency (workers/channels), profiling
  • Reliability: timeouts, retries/backoff, idempotency, DLQs, backpressure
  • Data layer: schema design, indexing, query tuning, transactions, migrations
  • Event-driven systems: Kafka ingestion patterns, producer/consumer fundamentals

Production and DevOps Ownership

  • Production mindset: structured logs, metrics-first thinking, SLO awareness
  • Observability: Prometheus metrics, actionable instrumentation, debugging support
  • Cloud-native workflow: Dockerized services, env-based config, local reproducibility
  • Deployment discipline: CI checks, automated builds, safe rollouts, health checks
  • Operations: graceful shutdowns, resource limits, incident-ready execution

Code Quality and Architecture

  • Separation of concerns: domain/service/repo/handler boundaries
  • Testing: unit + integration, contract checks where useful, pragmatic TDD
  • Maintainability: composable modules, consistent naming, clean structure
  • Security basics: input validation, least privilege, safe defaults, rate limiting

Collaboration and Execution

  • Clear written communication: concise docs, design notes, tradeoff clarity
  • Execution: scoped milestones, incremental delivery, feedback loops
  • Ownership: from development to production monitoring and iteration
  • Pragmatism: simplest solution that meets reliability and scale needs

Technology

Languages


JavaScript

TypeScript

Python

Go

C++

Rust

Backend and Databases


Django

Node.js

FastAPI

MySQL

PostgreSQL

Redis

DevOps and Cloud


Docker

Kubernetes

AWS

GCP

Nginx

Linux

Engineering Principles

  • Clarity beats cleverness
  • Measure before optimizing
  • Build for failure: timeouts, retries, idempotency, graceful degradation
  • Small composable modules, strong boundaries
  • Observability is a production requirement

Featured Work (Systems/Scale → Tools/APIs)

Injection Go Pipeline — High-Throughput Kafka Ingestion (Go)

HTTP → Kafka ingestion pipeline designed for high throughput with bounded backpressure.

Highlights

  • Batching, retries, DLQ strategy for reliability under load
  • Worker/channel pipeline for controlled concurrency and throughput
  • Includes load generation and throughput validation

Tech: Go • Kafka • Backpressure • Batching • Docker Compose
Repo: https://github.com/deannos/injection-go-pipeline.git

Kafka Injector — HTTP to Kafka with Prometheus Metrics (Go)

Low-latency HTTP → Kafka injector focused on safe ingestion under burst traffic.

Highlights

  • Prometheus metrics endpoint for operational visibility
  • Local stack via docker-compose for reproducible runs
  • Batching and safety-first design for sustained throughput

Tech: Go • Kafka • Prometheus • Docker Compose
Repo: https://github.com/deannos/kafka-injector.git

Email Checker Tool — DNS Email Configuration Auditor (Go)

CLI to audit domain email DNS configuration (MX, SPF, DMARC) at scale.

Highlights

  • Concurrent worker pool with global rate limiting
  • Streaming CSV processing for large datasets
  • Timeout-safe DNS lookups and graceful shutdown behavior

Tech: Go • DNS • CLI • Concurrency • CSV
Repo: https://github.com/deannos/email-checker-tool.git

Salary Management API — Clean Architecture API (Go)

HTTP API for employee salary workflows with clean layering and testing discipline.

Highlights

  • Domain/service/repository/handler separation
  • SQLite persistence with clear boundaries
  • CRUD and salary-related endpoints with predictable contracts

Tech: Go • net/http • SQLite • Testing
Repo: https://github.com/deannos/salary-management-api-go.git


GitHub Stats

GitHub Stats

Top Languages


Problem Solving

  • I practice DSA to sharpen reasoning, edge-case handling, and implementation speed.

Currently Exploring

  • Distributed systems fundamentals (queues, caching strategies, consistency)
  • Backend performance tuning and profiling
  • Better observability patterns (structured logs, metrics-first)

Contact

Pinned Loading

  1. email-checker-tool email-checker-tool Public

    A high-performance, open-source CLI tool to verify DNS configurations (MX, SPF, DMARC). Built in Go with concurrent workers, rate limiting, and CSV streaming support for large-scale domain analysis.

    Go 1

  2. salary-management-api-go salary-management-api-go Public

    This application manages employee data, calculates salaries based on country-specific tax rules, and provides salary-related metrics. The project prioritizes software craftsmanship, leveraging a cl…

    Go

  3. deannosTech-website deannosTech-website Public

    A modern, responsive website built with React, Vite, and Tailwind CSS, featuring smooth animations and a professional design.

    JavaScript

  4. injection-go-pipeline injection-go-pipeline Public

    High-throughput Kafka ingestion service built in Go, designed to handle millions of events per minute with bounded backpressure, batching, retries, and DLQ support. Includes a custom load-generatio…

    Go