Vamsi Marella
Founding Engineer
4+ years exp
4+ years ML exp
2+ projects
Python
Node JS
Solidity
JavaScript
SQL
TypeScript
Data Pipeline & Feature Engineering: 6/10
Computational Efficiency: 6/10
Experimentation & Evaluation: 5/10
Active 2 hours ago
Invite to interview
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
Backend engineer (Senior) focused on secure, database-backed API platforms and real-time services. The strongest proven skill is designing and testing Postgres row-level security and a deploy-time verification pipeline as shown by vibedeploy's buildjob/attack.py and buildjob/seed.py. There is limited public evidence of large-scale cloud operations, production CI/CD manifests, or formal SRE/runbook artifacts.
Phone
Technical skills
Languages
6
Python
Node JS
Solidity
JavaScript
SQL
TypeScript
Python
7
FastAPI
Pydantic
SQLAlchemy
Asyncio
Uvicorn
Alembic
structlog
Web3
6
Ethereum
Ethers.js
Uniswap
Web3.js
Alchemy
PancakeSwap SDK
Other
17
PostgreSQL
Computer Vision
AWS
Hardhat
DeFi
GCP
React.js
Redis
React Native
DynamoDB
Amazon EC2
AWS Lambda
GitHub
Databases
Rest API
DNS
OCR
Timeline
Vellore Institute of Technology (VIT)
Bachelor's Degree •
Computer Science and Engineering
Software Development Engineer Intern
•
Junior
Olive Technologies
•
Full-Time
Developed Node.js inventory REST APIs with request validation. Implemented a React Native OCR flow to transform scanned bills into structured JSON for backend ingestion. Focused on reliable input validation and end-to-end capture-to-API data flow.
Node JS
Rest API
React Native
OCR
Backend Engineer
•
Middle
GlueX Protocol
•
Full-Time
Owned an async Python/FastAPI backend handling high concurrency with non-blocking I/O, background jobs, and cached responses. Built a yield aggregation service across multiple DeFi protocols and designed caching plus batch pipelines for large-scale pool and yield processing. Orchestrated many EVM calls per cycle with batching, isolation via timeouts, and deployed serverless/VM workloads on AWS with latency monitoring.
Python
FastAPI
AWS
AWS Lambda
Amazon EC2
DynamoDB
DeFi
Founding Engineer
•
Middle
OneCent Labs
•
Full-Time
Built and operated a real-time trade routing and settlement engine, including an optimized bidding pipeline with strict response-time targets. Implemented route search across large asset and liquidity-pool datasets with pruning and worker-based execution. Integrated multiple protocol adapters for chain-specific setups and hardened production systems with retries, caching, tracing, and AWS/GCP-based monitoring.
AWS
GCP
Senior AI/ML Engineer
Confidence: High Generalist
A senior-level backend systems engineer specializing in secure, reliable server and data infrastructure with a strong focus on correctness and test-driven delivery. The strongest proven skill is designing security-first database access and verification tooling as shown by vibedeploy/buildjob/attack.py and the deterministic derivation logic in vibedeploy/buildjob/derive.py. Public code shows almost no ML model work or training pipelines, so there is no evidence of model-building, fine-tuning, quantization or experiment tracking for ML workloads.
Model Architecture & Training
How well models are designed and trained
Not evidenced in public code
Data Pipeline & Feature Engineering
6/10
How data is prepared for models
Strong, production-minded data pipeline work: explicit Parquet access, partition pruning, row-group statistics and predicate pushdown for reduced I/O are implemented and tested.
Evidence
query-engine/apps/engine/parquet_reader.py: read_row_groups, list_files, prune_files and read_row_group_metadata
query-engine/apps/engine/predicates.py: Predicate model, to_arrow and row-group skipping logic
query-engine/apps/engine/executor.py: worker read tasks that materialise partition columns for scans
Experimentation & Evaluation
5/10
How results are measured and tested
Deliberate evaluation and experimentation tooling with unit tests and statistical functions for A/B experiments and local SDK/vectorized evaluation paths.
Evidence
Feature-Flags/server/app/core/stats.py: two_proportion_z_test and welch_t_test implementations
Feature-Flags/server/app/core/evaluator.py: deterministic evaluator with fallthrough and rollout resolution
Feature-Flags/server/tests/test_stats.py and server/tests/test_evaluator.py: concrete tests validating statistical and evaluator behaviour
MLOps & Deployment
4/10
How models are shipped to production
Practical deployment and runtime concerns are handled (streaming sync, pubsub, background workers, migrations and test harnesses) though not ML-specific MLOps.
Evidence
Feature-Flags/server/app/pubsub.py: Redis-backed pubsub and SSE fan-out
Feature-Flags/server/app/worker/tasks.py: background experiment recompute jobs and cron configuration
vibedeploy/buildjob/migrate_scratch.py: migration application and scratch DB migration utilities
Computational Efficiency
6/10
How efficiently computing resources are used
Clear attention to computational efficiency: file/row-group pruning, column projection, partial aggregation and parallel worker map-reduce are implemented and benchmarked.
Evidence
query-engine/apps/engine/executor.py: process-pool parallelism, partial aggregation and worker map/reduce
query-engine/apps/engine/parquet_reader.py: partition pruning and efficient row-group reads
query-engine/apps/engine/physical_plan.py: metrics for scanned bytes and pruning counts
Research Depth & Innovation
5/10
Depth of research and new ideas
Good systems-level design and thoughtful trade-offs (security-first DB model, deterministic derivation logic, custom SQL planner) showing solid engineering innovation though not pushing SOTA research.
Evidence
vibedeploy/buildjob/attack.py: comprehensive security verification harness for Postgres RLS
vibedeploy/buildjob/derive.py: deterministic derivation of access model with questions/refusals
query-engine/apps/engine/parser.py and logical_plan.py: custom SQL -> logical plan conversion and planner
Industries
Data & Analytics• Senior
Software• Middle
Technologies
Databases
Python• since 2022 • Senior
SQL
PostgreSQL
Redis
GCP
DynamoDB
AWS
Asyncio• since 2022
AWS Lambda
Amazon EC2
GitHub
OCR
DNS
Recommendations
- Build secure, DB-backed services and access-control tooling that enforce Row Level Security (Postgres RLS) and auditability.
- Implement low-latency, local evaluation systems and SDKs for feature flags, streaming sync and metrics-backed experimentation.
- Develop analytics engines that read Parquet directly with partition and row-group pruning, parallel execution and measurable I/O metrics.
- Design robust end-to-end test harnesses and negative tests for concurrency, security and deployment-sensitive behaviour.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Backend Developer
Confidence: High API Engineer
Backend engineer (Senior) focused on secure, database-backed API platforms and real-time services. The strongest proven skill is designing and testing Postgres row-level security and a deploy-time verification pipeline as shown by vibedeploy's buildjob/attack.py and buildjob/seed.py. There is limited public evidence of large-scale cloud operations, production CI/CD manifests, or formal SRE/runbook artifacts.
API Design
6/10
How well APIs are designed
Well-structured HTTP API surface with auth gating and streaming endpoints; lacks explicit evidence of a versioning strategy or idempotency key patterns.
Evidence
Feature-Flags/server/app/api/flags.py
Feature-Flags/server/app/auth.py
Feature-Flags/server/app/api/stream.py
Data Layer & Database
7/10
Working with databases
Clear, deliberate database-facing design: schema introspection, seed plans, Postgres RLS enforcement and tests exercising transactional boundaries.
Evidence
vibedeploy/buildjob/attack.py
vibedeploy/buildjob/seed.py
vibedeploy/kernel/provision.py
Scalability & Performance
6/10
Handling load and speed
Performance-aware choices: local, sub-millisecond flag evaluation, SSE-based streaming with polling fallback and a pubsub layer; no published load-test artifacts found.
Evidence
Feature-Flags/sdk-python/flagsdk/client.py
Feature-Flags/server/app/pubsub.py
Feature-Flags/server/app/core/bucketing.py
System Architecture
6/10
Overall system structure
Deliberate system decomposition (sidecar/shim/kernel/buildjob, separated API/core/services/workers) showing architectural intent and separation of concerns.
Evidence
vibedeploy/sidecar/app.py
vibedeploy/shims/python/vibedeploy_shim/__init__.py
Feature-Flags/server/app/main.py
Security & Auth
8/10
Protecting data and access
Strong security focus: identity signing/verification, tests for forged headers, Postgres RLS-first enforcement model and careful auth token handling.
Evidence
vibedeploy/shims/python/vibedeploy_shim/identity.py
vibedeploy/sidecar/app.py
Feature-Flags/server/tests/test_auth.py
Reliability & Observability
6/10
Stability and monitoring
Good observability and reliability practices: Prometheus metrics, structured logging, reconnect/backoff in clients and test coverage for reliability scenarios; operational SRE artifacts (runbooks/alerts/k8s manifests) are absent.
Evidence
Feature-Flags/server/app/observability.py
Feature-Flags/server/tests/test_metrics.py
Feature-Flags/sdk-python/flagsdk/client.py
Verified artifacts
Expertise
Python• Senior
Databases & Vector Storage• Senior
Messaging & Real-time• Senior
Microservices & API Architecture• Senior
Industries
Gaming• Middle
Technologies
Node JS• since 2022 • Senior
Rest API
SQLAlchemy• since 2022
FastAPI• since 2022
Pydantic• since 2022
Uvicorn• since 2022
Alembic
structlog
Recommendations
- Develop secure backend services that push authorization into the database (RLS) and include automated verification tests.
- Build low-latency feature flag systems and SDKs where local evaluation and streaming sync are critical.
- Implement real-time, server-authoritative multiplayer features and socket-based reliability handling.
- Lead schema evolution work that includes migration histories and regression tests for data integrity.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Blockchain Developer
Confidence: Medium Protocol Engineer
A protocol-focused Solidity engineer at a senior level with a strength in gas-optimized AMM and tick-scanning logic. The strongest proven skill is low-level AMM and bitmap/tick processing as implemented in CLAMM-TICK-COLLECTOR/main.sol (BitMath, TickMath, SwapMath and the MultiprotocolTickCollector). There is limited evidence of formal security/audit tooling, multisig/governance patterns or invariant/fuzz tests in public code.
Smart Contract Development
6/10
Writing smart contracts
Strong Solidity engineering and gas-optimized protocol code with custom Uniswap-style math and a multi-protocol tick collector.
Security & Audit
4/10
Checking contracts for flaws
Some access control and sanity checks are present but limited explicit audit tooling, invariant/fuzz tests or advanced mitigation patterns were found.
Blockchain Protocol Understanding
6/10
Knowing how blockchains work
Clear protocol-level understanding of AMM internals, tick/bitmap layout and gas mechanics across Uniswap V4 and PancakePool integrations.
DApp & Web3 Integration
3/10
Connecting apps to blockchain
Basic Web3 integration work exists with ethers.js and WebSocket reconnection logic but with simplistic error handling and insecure defaults.
Tokenomics & DeFi Logic
4/10
Token and finance logic
DeFi data fetching and AMM math are implemented, but there is limited evidence of formal economic modeling, rounding proofs or attacker tests for invariants.
Decentralization & Trust Model
2/10
Designing trust without middlemen
Only basic owner/admin patterns are present; no multisig, timelock, documented upgrade governance or explicit trust model found.
Expertise
DeFi & Decentralized Finance• Senior
Ethereum & EVM Development• Senior
Industries
Blockchain & Crypto• Senior
Financial Services• Middle
Technologies
Solidity• since 2024 • Senior
Ethers.js
Hardhat
Web3.js
Alchemy
PancakeSwap SDK
Uniswap
Ethereum
Recommendations
- Build a production-grade indexer or subgraph that ingests tick data from the MultiprotocolTickCollector and emits normalized time-series for analytics and strategies.
- Harden protocol code by adding invariant and fuzz tests, attacker-style negative tests, and include CI steps for slither/echidna or Foundry-based fuzzing.
- Improve Web3 integration security by removing hardcoded credentials, adding robust reconnect/backoff, and implementing credential rotation and secrets management.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: