Dhiraj Suthar
Software Developer
5+ years exp
4+ years ML exp
JavaScript
TypeScript
Node JS
Rust
Python
Active 9 days ago
+91 (9901) 987709 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A Middle-level Rust developer focused on small, correct CLI libraries and numeric utilities. The strongest proven skill is designing a compact Rust crate with a CLI and parameterized tests, evidenced by src/lib.rs, src/main.rs and tests/test.rs. There is no public evidence of backend systems work such as databases, distributed components, production observability or service-level architecture.
Technical skills
JavaScript
TypeScript
Node JS
Rust• Middle
Python• Middle
Node JS
Nest.JS• 4y+
Rust
Cargo
Clap
Python
pylint
Flask• 5y+
Scrapy• 5y+
FastAPI• 4y+
Databases
Cassandra
ElasticSearch• 5y+
PostgreSQL• 4y+
Redis• 4y+
ScyllaDB• 4y+
DevOps
CI/CD
Git
Kong
Kubernetes
Kibana• 5y+
Docker• 4y+
gRPC• 4y+
Rest API• 4y+
Jenkins
WebSockets
AI/ML
LLM
Pandas
RAG• 4y+
AI Agents
Frontend
React.js
Next.js• 4y+
Cybersecurity
SonarQube• 5y+
Timeline
Product Developer
•
Middle
Epicor
•
Full-Time
Expanded capabilities of Epicor Payment Application by building new payment integrations across REST and WebSocket flows. Implemented device agent support for PIN pad endpoints and improved reference data versioning to maintain backward compatibility. Migrated payment services to newer Python versions, addressed security vulnerabilities, and strengthened code quality with standard linting practices. Optimized service performance via load testing, log analysis, and Jenkins pipeline script updates for reliable deployments.
Python
Rest API
WebSockets
Jenkins
Software Engineer
•
Middle
Tarento Group
•
Full-Time
Developed the backend for Krutrim’s B2B conversational AI chatbot using NestJS, including LLM orchestration, tool execution, and RAG pipelines in coordination with the model team. Optimized database and cache performance by tuning Redis and PostgreSQL connection usage and improving latency for external API calls. Worked across services including FastAPI-based APIs with gRPC support and RESTful inference endpoints. Supported migrations and reliability improvements involving ScyllaDB schemas, Docker deployment sizing, and security via role-based access controls.
Nest.JS
Next.js
Redis
PostgreSQL
Docker
ScyllaDB
FastAPI
gRPC
Rest APIsince 2022
RAG
Associate Software Engineer
•
Middle
Tarento Group
•
Full-Time
Built and maintained a high-performance Flask web application that coordinated multiple Scrapy-based data scrapers for Nordic energy providers. Improved Elasticsearch query performance and created Kibana dashboards for monitoring and data visualization. Raised code quality using SonarQube and increased test coverage with mocking. Collaborated with other teams to share practices in web scraping and browser automation.
Flask
Scrapy
ElasticSearch
Kibana
SonarQube
Visvesvaraya Technological University (VTU)
Bachelor's Degree •
Computer Science
Middle Backend Developer
Confidence: High Generalist
A Middle-level Rust developer focused on small, correct CLI libraries and numeric utilities. The strongest proven skill is designing a compact Rust crate with a CLI and parameterized tests, evidenced by src/lib.rs, src/main.rs and tests/test.rs. There is no public evidence of backend systems work such as databases, distributed components, production observability or service-level architecture.
API Design
3/10
How well APIs are designed
Small, well-scoped public API and CLI with basic error returns and a consistent output contract, but no versioning, advanced idempotency or pagination considerations.
Evidence
Data Layer & Database
Working with databases
Not evidenced in public code
Scalability & Performance
1/10
Handling load and speed
Algorithmic conversion implemented but no performance engineering, caching, or load considerations; potential numeric/overflow limitations not addressed.
System Architecture
3/10
Overall system structure
Clear modular separation between library logic, CLI entrypoint and output formatting for a small tool, but no multi-service decomposition or config/secret management patterns.
Security & Auth
2/10
Protecting data and access
Basic input validation is present for supported bases and digit validity, but no stronger security practices or typed error handling are applied.
Reliability & Observability
3/10
Stability and monitoring
Includes parameterized unit tests and uses Result for error propagation, indicating attention to correctness, but lacks production reliability patterns like observability, retries, timeouts or structured logging.
Expertise
Rust• Middle
Technologies
Rust• Middle
Clap
Systems• mentioned only
Recommendations
- Develop small-to-medium Rust CLI tools or libraries that implement algorithmic utilities and publish crates.
- Own numeric and algorithmic logic modules where correctness and test coverage are primary requirements.
- Improve robustness for larger inputs by adding big-integer support and explicit overflow handling, and expand test coverage with property tests.
- Harden APIs by introducing typed error enums and richer error contexts before moving to production backend services.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Game Developer
Confidence: Medium Generalist
A Rust-focused tool/library developer (middle level) who builds small, well-tested command-line utilities. The strongest proven skill is implementing numeric conversion logic and a tidy CLI with tests, demonstrated by numeral-system-rs/src/lib.rs and numeral-system-rs/src/main.rs along with tests in numeral-system-rs/tests/test.rs. The public code does not show game-specific systems, rendering/physics work, profiling data, or multi-threaded/advanced architecture patterns.
Gameplay Systems & Mechanics
How game logic works
Not evidenced in public code
Graphics & Rendering
Drawing game visuals
Not evidenced in public code
Physics & Math
2/10
Game physics and math
Basic numeric/math algorithm implementation for base conversion and parsing; correct handling of digit values and base power accumulation.
Evidence
numeral-system-rs/src/lib.rs: get_base10_value function implementing base-to-decimal accumulation
numeral-system-rs/src/lib.rs: NumberWithBase::get_base_and_value_post_base_update conversion loop and digit-to-char mapping
Engine Proficiency
Skill with the game engine
Not evidenced in public code
Performance & Frame Budget
Keeping the game smooth
Not evidenced in public code
Content Pipeline & Tooling
1/10
Tools for game content
Minimal tooling and packaging hygiene: Cargo manifest, CLI wiring with clap, and parameterized unit tests provide basic developer tooling.
Evidence
numeral-system-rs/Cargo.toml: crate metadata and dependencies (clap, parameterized in dev-dependencies)
numeral-system-rs/src/main.rs: Clap Parser usage wiring a CLI for the library
numeral-system-rs/tests/test.rs: parameterized unit tests exercising conversion logic
Verified artifacts
Expertise
Game Development Tools & Pipeline• Junior
Recommendations
- Develop small CLI utilities and libraries in Rust where the output is a reusable crate and documented API.
- Expand this work into developer tooling such as formatters, validators, or conversion libraries that include CI, benchmarks, and crate publishing (crates.io).
- Improve numeric robustness by adding BigInt support, clearer error types, and explicit edge-case tests (zero, negative, very large inputs).
- Add microbenchmarks and profiling traces when optimizing hot paths; use criterion or simple benchmark harnesses before and after changes.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Embedded Engineer
Confidence: Medium Generalist
A Middle-level Rust developer specializing in small command-line tools and numeric algorithm implementations. The strongest proven skill is implementing base conversion logic and a test-driven CLI flow, evidenced by src/lib.rs functions such as get_base10_value and get_base_and_value_post_base_update together with parameterized tests in tests/test.rs. No embedded firmware, hardware interface, real-time, DMA, low-power or HDL work is evidenced in the public code.
Embedded & Firmware
Low-level device code
Not evidenced in public code
Hardware-Software Interface
Connecting code to hardware
Not evidenced in public code
Resource Constraints
Working with limited resources
Not evidenced in public code
Real-time & Timing
Precise timing control
Not evidenced in public code
HDL & Circuit Logic
Designing digital circuits
Not evidenced in public code
Reliability & On-device Testing
Testing on real hardware
Not evidenced in public code
Expertise
Low-level Development & Tooling• Middle
Technologies
Cargo
Recommendations
- Add arbitrary precision support (for example via num-bigint) and explicit overflow/error handling to replace the current u32-based conversion limits.
- Add benchmarks and performance tests to characterize conversion performance and avoid hidden quadratic behavior when building strings.
- Introduce CI with test runs and release artifacts, and add explicit error types instead of string errors for clearer API ergonomics.
- Expand property-based tests (for example using quickcheck or similar) to validate conversions across many random bases and values.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: