Raju Gottumukkala

Backend • Middle • Management: Under a year (1-5 people) • 25 years • San Francisco, USA • UTC-08:00 • In office, Partially remote, Fully remote • Relocation • Work permits: United States, India • Citizenship: India • Available in 2 weeks • from $160k per year

AI Engineer

7+ years exp

7+ years ML exp

Management: Under a year (1-5 people)

Python

Java

TypeScript

JavaScript

Node JS

C++

SQL

API Design: 6/10

Scalability & Performance: 6/10

System Architecture: 6/10

Active 1 day ago

Invite to interview

Download CVCV

Overview

Technical skills

Timeline

Roles

Overview

Backend automation engineer (senior) focused on deterministic LLM-driven browser automation and replay with strong artifact and guardrail design. The strongest proven skill is designing a deterministic discover-then-replay execution model and artifact schema, demonstrated by src/cua/agent.py, src/cua/replay.py and src/cua/schemas.py. Not evidenced are database schema evolution, production distributed scaling (queues or sharding), or HTTP/REST service design beyond a CLI-based surface.

Phone

Technical skills

Languages

Python

Java

TypeScript

JavaScript

Node JS

C++

SQL

Python

Dask

FastAPI

Flask

pySpark

Pydantic

Typer

Java

Spring Boot

Spring Framework

Spring Security

Spring MVC

SLF4J

Databases

FAISS

Milvus

BigQuery

Snowflake

Databricks

Neo4j

Google BigQuery

Apache Kafka

AI/ML

Airflow

Ray

Prophet

Amazon SageMaker

Scikit-learn

TensorFlow

XGBoost

BERT

Keras

SHAP

Spark

Kubeflow

Machine Learning

MLFlow

Vertex AI

Claude

PyTorch

AWS Bedrock

Gemini

LlamaIndex

LoRA

Embeddings

Cohere SDK

PEFT

QLoRA

Hugging Face

vLLM

Model Context Protocol

GPT-5

RAG

LLM

Anthropic SDK

CrewAI

LangChain

LangGraph

Llama

NumPy

OpenAI SDK

Pandas

Transformers

CNN

Time Series Forecasting

Tool Use

DevOps

Kubernetes

Amazon EKS

Amazon CloudWatch

AWS

Grafana

Terraform

Prometheus

ArgoCD

Azure

GCP

IAM

Amazon S3

GitHub

Other

React.js

Express

Next.js

Tailwind CSS

React Query

Zod

PyTorch C++

TensorFlow C++

Pytest

Anthropic

OpenAI

Azure AKS

GitHub Actions

Vite

LangSmith

Docker

Git

Rest API

LLVM

Claude Code

Copilot

Cursor

Contrastive Learning

Hybrid Search

AI Agents

OpenAI Codex

CI/CD

WebSockets

PCI DSS

Fine-tuning

Prompt Engineering

Computer Vision

Feature Store

Function Calling

LLM Evaluation

LLM Guardrails

NLP

SFT

Least Privilege

Anomaly Detection

Reranking

Timeline

Generative AI Engineer • Middle

Arm Holdings • Full-Time

Sep 2024 to Present 2 Years San Jose In office

Led an internal team building an MCP server and agent stack for agent-driven code migration workflows. Developed a fine-tuned Llama 3 RAG pipeline with hybrid retrieval and evaluation gating, and improved retrieval quality and hallucination reduction. Operated LLM serving with GPU-based inference, multi-model routing, and production observability for reliability and cost control. Implemented agent safety and least-privilege tool execution for production environments.

Python

Model Context Protocol

Tool Use

RAG

Hybrid Search

PyTorch

PEFT

LoRA

QLoRA

Hugging Face

vLLM

Milvus

LlamaIndex

FAISS

Cohere SDK

AWS Bedrock

GPT-5

Claude

Gemini

Amazon EKS

Kubernetes

ArgoCD

Prometheus

Grafana

Terraform

IAM

Neo4j

Contrastive Learning

Embeddings

University of Missouri (Kansas City Campus)

Master's Degree • Computer Science

2023–2025 Kansas City, Missouri

Machine Learning Engineer II • Middle

FIS • Full-Time

Jun 2022 to Jul 2023 1 Year 1 Month Partially remote

Built and deployed production fraud analytics models and real-time scoring services for large transaction volumes. Implemented deep learning and ensemble pipelines with inference services running on Kubernetes and protected by model governance and audit controls. Automated training, monitoring, and drift detection using MLOps tooling, and delivered interpretable reason codes for declined transactions. Collaborated with analysts and data scientists to define stable API contracts for monitoring and review workflows.

Python

TensorFlow

Keras

Scikit-learn

XGBoost

FastAPI

Flask

Spring Boot

Kubernetes

Amazon EKS

Amazon SageMaker

Airflow

MLFlow

Amazon CloudWatch

SHAP

Snowflake

Spark

pySpark

Databricks

Machine Learning Engineer • Middle

Walmart • Full-Time

Aug 2019 to May 2022 2 Years 9 Months Partially remote

Owned catalog enrichment and demand forecasting pipelines on Google Cloud, improving forecast accuracy for large-scale commerce operations. Built semantic search using dense embeddings with vector retrieval and hybrid indexing, plus label-aware NLP and vision components for attribute extraction. Developed time-series forecasting workflows with automated training and monitoring, and scaled distributed training across large datasets. Reduced operational risk by implementing data quality checks, drift dashboards, and cost-aware query optimization.

Python

BERT

CNN

Milvus

FAISS

Prophet

Time Series Forecasting

Vertex AI

Kubeflow

Airflow

pySpark

Dask

Ray

BigQuery

Embeddings

Middle Backend Developer Confidence: Medium Platform Engineer

API Design

6/10

How well APIs are designed

Clear, typed capability contract and CLI-driven API surface with input validation and explicit result/error contracts; lacking HTTP-versioning or idempotency key patterns but shows deliberate API contract design via pydantic models and CLI ergonomics.

Evidence

src/cua/schemas.py: Capability, ParamSpec, OutputSpec, ReplayResult and Step models (typed contract)

src/cua/cli.py: discover and replay CLI commands enforcing params and writing artifacts

src/cua/agent.py: _TOOLS vocabulary and system prompt that define the tool-level API for the LLM-driven discovery

Data Layer & Database

1/10

Working with databases

Almost no relational/data-layer engineering in the human-authored parts; persistence is file-based artifacts and there is no migration history, transactional boundaries or tuned SQL in the analyzed code.

Evidence

src/cua/cli.py: CAPABILITIES_DIR and out_path.write_text used to persist artifacts as JSON files

src/cua/schemas.py: artifact models stored as JSON (no DB schema or migration files present)

Scalability & Performance

6/10

Handling load and speed

Thoughtful runtime timeouts, candidate-level shorter fallbacks, oscillation and stall detection, and deterministic replay controls show performance/resilience awareness though no explicit load-testing or distributed scaling primitives are present.

Evidence

src/cua/locator.py: resolve() applies full timeout to first candidate and shorter timeouts to fallbacks to avoid len(candidates) * timeout behavior

src/cua/agent.py: stall_count and OSCILLATION_WINDOW/OSCILLATION_THRESHOLD used to detect stuck or oscillating runs and trigger escalation

src/cua/replay.py: step timeout_ms usage and inject_fault_step_id for deterministic fault-injection testing

System Architecture

6/10

Overall system structure

A deliberate architecture separating discovery, artifact schema, and deterministic replay with human escalation and evidence collection; modular boundaries are clear and justified by comments and code structure.

Evidence

src/cua/agent.py: discovery run orchestration with separate AgentRun, trace steps, and artifact building

src/cua/replay.py: deterministic replay path and clear result model (SUCCESS / BUSINESS_OUTCOME / HARD_FAILURE / ESCALATED)

src/cua/schemas.py: single-source-of-truth artifact schema shared across modules

Security & Auth

6/10

Protecting data and access

Security-conscious patterns are present: guardrails enforcing risky-action gating, redaction of sensitive values, secret registration, and credential resolution, but no full auth/token lifecycle or external secrets management integrations are shown.

Evidence

src/cua/agent.py: logger.register_secret(param_values.get("password")) and templating/redaction logic in _build_artifact

src/cua/replay.py: _build_substitutions and policy.resolve_credential usage to avoid storing raw credentials

src/cua/guardrails.py: referenced GuardrailPolicy used to check navigation, action types and classify risky actions (guardrails module present in repo)

Reliability & Observability

6/10

Stability and monitoring

Good observability and reliability practices: structured RunLogger events, screenshots on failure, explicit escalation/human-handoff flows, and verified retries rather than blind retries; lacks explicit metrics/alerting hooks but has strong local tracing.

Evidence

src/cua/evidence.py: RunLogger usage for events, secret scrubbing and evidence writes

src/cua/replay.py: _handle_unresolved captures screenshots, raises escalation, and retries after human handoff

src/cua/agent.py: frequent logger.event calls and evidence directory usage for discovery runs

Verified artifacts

kubernetes/kubernetes• ★ 128K kubeflow/pipelines• ★ 4.2K

Expertise

Backend AI & LLM• Middle

Python• Middle

System Architecture• Middle

Technologies

Python• since 2019 • Middle

Rest API

Flask• since 2022

Spring Boot• since 2022

FastAPI• since 2022

Apache Kafka

Pydantic

Typer

Recommendations

Extend the replay/agent pipeline with metrics and exported Prometheus counters and alerts to surface system health and escalation rates
Add integration tests / load tests that exercise concurrent replay runs and measure resource usage to harden scaling characteristics
Introduce a small durable control-plane (e.g., a queue + worker model) if multiple parallel replays or long-running sessions are required
Add secrets-management integration (Vault or cloud KMS) and documented credential lifecycle for production credential resolution

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

Kanakaraju Banking-Web-Application -computer-use-agent

Middle Frontend Developer Confidence: Medium App Engineer

Senior-level app engineer specializing in building asynchronous, IDE-like web applications and developer tooling interfaces. The strongest proven skill is designing and implementing terminal orchestration and streaming with careful async handling as shown in VelocIDE_Monolith_Version/src/services/terminal/TerminalStreamService.ts and TerminalExecutionService.ts. There is limited public evidence of automated test coverage, measured performance benchmarking, or enterprise-scale architecture docs for large distributed systems.

UI Component Architecture

5/10

How interface parts are built

Reasoned component/service boundaries for an IDE-style SPA are evident via callback-driven services and a shared validation layer, though few dedicated UI component source files appear in the human-authored subset.

Evidence

VelocIDE_Monolith_Version/src/services/terminal/TerminalExecutionService.ts: TerminalExecutionService (callbacks, queueing, execution flow)

VelocIDE_Monolith_Version/src/services/gitService.ts: GitService (well-scoped API surface for git ops)

VelocIDE_Monolith_Version/src/index.css: design tokens and component class naming indicating a design system

Responsive & Cross-browser

6/10

Works on all screens and browsers

Thoughtful responsive rules, print styles, touch optimizations and reduced-motion handling show cross-browser and mobile considerations beyond basic breakpoint usage.

Evidence

VelocIDE_Monolith_Version/src/index.css: @media rules, print styles and touch / mobile optimizations

VelocIDE_Monolith_Version/src/index.css: prefers-reduced-motion and focus-visible handling

Performance Optimization

4/10

Speed of the interface

Performance-aware CSS and some network-level controls (timeouts, aborts, reconnect/backoff) are present but there is no measured telemetry, bundle analysis, or explicit code-splitting evidence in the human-authored files.

Evidence

VelocIDE_Monolith_Version/src/index.css: will-change, hardware-acceleration hints and conservative animation choices

VelocIDE_Monolith_Version/src/services/terminal/TerminalStreamService.ts: exponential reconnect/backoff and use of AbortController in executeCommandHTTP

Accessibility & Semantics

6/10

Usable for everyone

Accessible patterns are intentionally included in CSS (focus-visible, skip-link, reduced-motion) indicating awareness of a11y, though ARIA on custom widgets is not present in the examined human-authored files.

Evidence

VelocIDE_Monolith_Version/src/index.css: :focus-visible rule and .skip-link for keyboard users

VelocIDE_Monolith_Version/src/index.css: prefers-reduced-motion media query

State Management & Data Flow

6/10

Managing data in the app

Robust async state discipline is visible: command validation, queuing/sequential execution, approval flow, reconnection/backoff and AbortController timeouts demonstrate realistic server-state and race handling.

Evidence

VelocIDE_Monolith_Version/src/services/terminal/TerminalExecutionService.ts: command queue, processQueue, approval flow and parseAgentResponse

VelocIDE_Monolith_Version/src/services/terminal/TerminalStreamService.ts: connectWebSocket, attemptReconnect, executeCommandHTTP with AbortController and timeout handling

UX & Visual Polish

5/10

Look and feel quality

Visual polish and UX touches (skeleton classes, loading indicators, typed system outputs) are present; UX flows such as undo, optimistic updates or measured perceived-performance improvements are not evident in the human-authored subset.

Evidence

VelocIDE_Monolith_Version/src/index.css: .skeleton, .typing-indicator and loading state styles

VelocIDE_Monolith_Version/src/services/terminal/TerminalExecutionService.ts: addSystemOutput and onOutput callbacks for incremental UX feedback

Expertise

React• Middle

Modern Web Frameworks• Middle

Frontend Architecture & Build Tools• Middle

Industries

Financial Services• Middle

Software• Middle

Technologies

TypeScript• since 2025 • Middle

Node JS• Middle

Tailwind CSS

Next.js

Express

WebSockets

React.js

Vite

React Query

Zod

Recommendations

Lead development of complex single-page applications that require robust async flows, streaming, and offline/session management such as web-based IDEs or developer portals.
Own developer tools and internal platforms that integrate terminal/CLI features, git operations and real-time collaboration components.
Implement feature work that requires careful server-state coordination (sequential execution, approval flows, reconnect logic) and build the observability/tests around it (RUM, e2e, unit tests).

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

Kanakaraju raju-portfolio VelocIDE_Monolith_Version

Junior QA Engineer Confidence: Medium Generalist

Full-stack web engineer (Middle) focused on secure server-side Java with Spring; the main strength is practical application-level security and input handling. The strongest proven skill is secure backend implementation as shown by FileUploadUtil and the security filters (CsrfFilter, AuthenticationFilter, SecurityHeadersFilter) under Banking-Web-Application/src/main/java/com/Bank/web. There is limited evidence of automation engineering practices such as comprehensive test suites, CI test integration, contract testing or performance testing in the public code.

Test Automation Frameworks

2/10

Building automated tests

Very light test automation presence: a single Spring Boot test class exists but there is no test framework, fixtures, factories, or parallelization config.

Evidence

Banking-Web-Application/src/test/java/com/Bank/web/WebApplicationTests.java

Test Coverage & Strategy

1/10

What and how to test

Minimal test coverage and strategy; no evidence of risk-based tagging, negative-path suites, property-based tests or mutation testing.

Evidence

Banking-Web-Application/src/test/java/com/Bank/web/WebApplicationTests.java

API & Integration Testing

1/10

Testing how parts work together

Application contains server-side DB integration code (JdbcTemplate / SimpleJdbcCall) but no contract tests, schema validation tests or testcontainers-based integration harness.

Evidence

Banking-Web-Application/src/main/java/com/Bank/web/dao/impl/UserDaoImpl.java

Performance & Load Testing

Testing speed under load

Not evidenced in public code

Bug Reporting & Analysis

Finding and describing bugs

Not evidenced in public code

CI Test Integration

Running tests automatically

Not evidenced in public code

Expertise

Unit & Component Testing• Junior

Industries

Financial Services• Middle

Technologies

JavaScript• since 2025 • Junior

Java• since 2024 • Junior

Spring Framework

Spring MVC

Spring Security

SLF4J

Pytest

Recommendations

Develop and harden Spring Boot backend services that require secure file handling, session management and DB integration (use the existing filters and FileUploadUtil as a base).
Add integration and contract tests (testcontainers or similar), negative-path and boundary tests, and CI pipelines with per-test artifact capture to raise quality to a stronger SDET profile.
Implement API schema validation and automated contract checks for DB-backed endpoints to reduce regression risk and support safe refactoring.

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

Kanakaraju Banking-Web-Application raju-portfolio