Kareem Taher
AI Engineer
C++
SQL
JavaScript
Java
Node JS
C
Python
TypeScript
API Design: 4/10
System Architecture: 4/10
Active 2 days ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
Backend API engineer at senior level specializing in pragmatic AI-assisted cloud compliance and document RAG pipelines. The strongest proven skill is building Python-based AI and retrieval services as shown by services/ai_reasoning.py and Advanced_RAG_pipeline/src/rag_pipeline.py. There is limited evidence of production-grade operational engineering such as structured observability, retries with backoff, database migrations, or distributed systems design.
Technical skills
C++
SQL
JavaScript
Java
Node JS
C
Python• Senior
TypeScript• Middle
C++
PyTorch C++
Java
Spring Boot
Python
FastAPI
Flask
Pydantic
Requests
Databases
pgvector
Google BigQuery
PostgreSQL
AI/ML
Claude
Claude Code
Embeddings
Hallucination
PaddlePaddle
Pandas
Pillow
huggingface_hub
Transformers
Gemini
PyTorch
AWS Bedrock
LlamaIndex
LLM
Mistral
PaddleOCR
Phi
RAG
Frontend
React.js
Tailwind CSS
Recharts
Radix UI
ESLint
PostCSS
Next.js
DevOps
Amazon EC2
AWS Lambda
CI/CD
Docker
Git
Rest API
GCP
AWS CDK
AWS
QA
Postman
Timeline
AI Engineer Extern
•
Middle
Pfizer
•
Internship
Built an OCR-to-RAG pipeline to process 500+ pharmaceutical vendor documents, reducing manual classification time by about 20%. Tuned chunking and evaluated open-source LLMs (Mistral, Phi-2) inside a LlamaIndex retrieval system backed by Amazon Bedrock to improve retrieval quality and lower hallucinations. Used PaddleOCR as part of the document ingestion flow.
PaddleOCR
LlamaIndex
Mistral
Phi
AWS Bedrock
LLM
RAG
Software Engineering Intern
•
Junior
Buildify
•
Internship
Interned on website redesigns for three dental clinic clients, translating requirements into technical specifications and development roadmaps. Optimized site performance by improving page load times. Redesigned relational database schemas and added validation and cleanup logic to reduce data inconsistencies and duplicates.
Security Research Assistant
•
Middle
Johns Hopkins University
•
Full-Time
Conducted static analysis across 20+ open-source Python ML repositories, identifying unsafe getattr/setattr patterns and insecure arbitrary model-loading paths (torch.load). Created proof-of-concept scripts to validate class-pollution and sandbox-escape risks and delivered remediation reports with AST-level validation changes. Researched Python metaprogramming attack surfaces and documented exploit chains and hardening recommendations for model-loading workflows.
Python
PyTorch
Senior Backend Developer
Confidence: Medium API Engineer
Backend API engineer at senior level specializing in pragmatic AI-assisted cloud compliance and document RAG pipelines. The strongest proven skill is building Python-based AI and retrieval services as shown by services/ai_reasoning.py and Advanced_RAG_pipeline/src/rag_pipeline.py. There is limited evidence of production-grade operational engineering such as structured observability, retries with backoff, database migrations, or distributed systems design.
API Design
4/10
How well APIs are designed
REST API surface is pragmatic and well organized with FastAPI endpoints and client usage, but lacks explicit versioning, pagination, idempotency keys, and a formal error contract.
Evidence
Orbyte_Project/backend/main.py: endpoints /api/overview, /api/compliance/controls and /api/compliance/controls/{control_id}/analysis
Orbyte_Project/frontend/lib/api.ts: fetchOverview, fetchComplianceControls and analyzeControl client wrappers
Data Layer & Database
3/10
Working with databases
Data layer shows use of BigQuery and typed Pydantic models but no migration history, transaction handling, tuned SQL, or explicit measures against N+1 and data integrity beyond model typing.
Evidence
Orbyte_Project/backend/services/bigquery_service.py: get_controls_from_bq / get_resources_from_bq signatures and ensure_credentials usage
Orbyte_Project/backend/models/schemas.py: Pydantic models Control and Resource
Scalability & Performance
3/10
Handling load and speed
There is performance awareness in the RAG pipeline (adaptive chunking, safe top_k) and straightforward numerical heuristics, but no caching strategy, queue-based decoupling, connection pooling controls, or measured load optimizations.
Evidence
Advanced_RAG_pipeline/src/rag_pipeline.py: adaptive chunking logic in _build_node_parser and safe_top_k in build_rag_pipeline
Orbyte_Project/backend/services/metrics_engine.py: estimate_daily_emissions_kg and compute_sustainability_metrics (heuristic and vectorized computations)
System Architecture
4/10
Overall system structure
Code is modular with clear service boundaries (ai_reasoning, metrics_engine, bigquery_service) and environment-driven config, but the system is a single-process monolith with limited production ops patterns or inter-service contracts.
Evidence
Orbyte_Project/backend/services/ai_reasoning.py: Vertex AI initialization, USE_MOCK_AI toggle and ensure_credentials invocation
Orbyte_Project/backend/main.py: explicit imports of services and early ensure_credentials() placement
Security & Auth
2/10
Protecting data and access
Basic secrets via env and an auth helper are present, but there is no evidence of authentication/authorization flows, token lifecycle management, input validation at boundaries, or secret rotation and dependency audit.
Evidence
Orbyte_Project/backend/services/gcp_auth_helper.py: ensure_credentials helper present
Orbyte_Project/backend/main.py: CORS configuration and no visible auth enforcement on endpoints
Reliability & Observability
3/10
Stability and monitoring
There are pragmatic fallback and mock modes and try/except guards around external calls, but structured logging, timeouts, retries with backoff and jitter, graceful shutdown, and metrics/alert hooks are not evident.
Evidence
Orbyte_Project/backend/services/ai_reasoning.py: try/except around Vertex AI init and mock fallback functions
Orbyte_Project/backend/main.py: BigQuery call try/except fallbacks to mock_data in endpoints
Expertise
Python• Middle
Backend AI & LLM• Middle
Databases & Vector Storage• Middle
Microservices & API Architecture• Middle
Industries
Software• Middle
Technologies
GCP
Flask
FastAPI
Pydantic
Google BigQuery
Cloud• mentioned only
Recommendations
- Build and harden FastAPI endpoints that integrate Vertex AI and BigQuery with explicit versioning, pagination and idempotency semantics.
- Develop and productionize RAG/document pipelines including caching, connection pooling, and embedding storage lifecycle for vector indexes.
- Implement production operational features: structured logging, metrics (Prometheus/OpenTelemetry), retries with backoff+jitter, timeouts and graceful shutdown.
- Design data migration histories and stronger data-layer contracts for BigQuery usage including query tuning and transactional patterns where applicable.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Frontend Developer
Confidence: Medium UI Engineer
UI-focused frontend engineer at a middle level with a strength for building polished, responsive client-side interfaces and pragmatic LLM-powered prototypes. The strongest proven skill is crafting interactive, well-structured UIs and UX flows with clear loading and error states, evidenced by a refined personal portfolio and a client-side Gemini-powered cold email generator that handles API errors and response parsing. Backend system design, production-grade server-state management patterns, automated test coverage and CI automation are not evidenced in public code.
UI Component Architecture
3/10
How interface parts are built
Component structure is pragmatic but lightweight; mostly handcrafted HTML/CSS and simple modular JS rather than a reusable component library or a deliberate component-system architecture.
Evidence
karMareal1/portfolioa/index.html: single-file structured HTML/CSS with reveal classes and JS interactions rather than composable components
karMareal1/Orbyte_Project/frontend/tailwind.config.ts: design tokens and content paths indicating a coordinated styling approach
karMareal1/Orbyte_Project/frontend/app/globals.css: global utility styles and tokens used across app
Responsive & Cross-browser
4/10
Works on all screens and browsers
Responsive behavior is implemented with explicit CSS media queries and layout patterns; shows attention to mobile-first adjustments and cross-viewport features but lacks advanced strategies like container queries or thorough RTL/i18n patterns.
Performance Optimization
3/10
Speed of the interface
Practical client-side performance techniques are used, such as IntersectionObserver for reveal, preconnect hints and transform-based animations, but no measured optimization artifacts, bundle analysis, or advanced code-splitting evidence.
Accessibility & Semantics
4/10
Usable for everyone
Basic accessibility and semantics are present - labelled form controls, aria-labels on interactive items and keyboard-accessible focus states - but no evidence of systematic a11y testing, ARIA for custom widgets, or CI axe checks.
State Management & Data Flow
4/10
Managing data in the app
Client-side data flows are thoughtful at the request level with typed API wrappers and explicit error handling, and the LLM UI shows clear UI state handling; however there is no evidence of advanced server-state discipline like request cancellation, optimistic updates or state machines.
UX & Visual Polish
5/10
Look and feel quality
UX and visual polish are strong for portfolio and tools: considered microinteractions, reveal animations, loading states, and status feedback create a refined front-end experience, though not always backed by design-system scale or accessibility QA.
Verified artifacts
Expertise
Frontend AI Integration• Middle
Industries
Software• Middle
Technologies
TypeScript• Middle
Node JS
Tailwind CSS
Next.js
React.js
Radix UI
PostCSS
ESLint
Recharts
Cloud• mentioned only
Recommendations
- Build customer-facing interactive frontends and landing experiences where polished UI and microinteractions matter.
- Prototype LLM-powered features and client-side AI integrations, focusing on safe prompt handling and secure key management via a backend.
- Design component libraries or a small design system to scale consistent UI patterns across projects.
- Lead implementation of robust client-server state handling (request cancellation, retries, optimistic updates) for data-heavy dashboards.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior AI/ML Engineer
Confidence: High LLM Engineer
LLM-focused engineer (middle level) who builds end-to-end retrieval-augmented document pipelines with pragmatic preprocessing and retrieval engineering. The strongest proven skill is document ingestion and retrieval engineering, demonstrated by the SEC HTML extractor and token-budgeted truncation (cdk-10q-inference/text_extractor.py) together with the hybrid RAG pipeline and OCR fallback (Advanced_RAG_pipeline/src/rag_pipeline.py). There is little public evidence of custom model training, systematic experiment tracking, or production-grade serving instrumentation and monitoring.
Model Architecture & Training
2/10
How well models are designed and trained
No evidence of custom model architectures or training loops; uses hosted LLMs and off-the-shelf rerankers and embeddings with basic configuration choices.
Data Pipeline & Feature Engineering
5/10
How data is prepared for models
Clear, pragmatic document ingestion and preprocessing: SEC HTML parsing, OCR fallback for scanned pages, token-budgeted truncation, and adaptive chunking for indexing.
Experimentation & Evaluation
2/10
How results are measured and tested
Contains demonstration notebooks and retrieval comparison utilities but no structured experiment tracking, ablations, or reproducible evaluation harness.
MLOps & Deployment
3/10
How models are shipped to production
Some deployment and infra artifacts (CDK stack, lambda modules and a unit test) indicate basic productionization awareness but limited full MLOps features (no model versioning, drift monitoring, or serving SLA code shown).
Evidence
karMareal1/MLT-Gen-AI-bot/cdk-10q-inference/cdk_10q_inference/cdk_10q_inference_stack.py: Cdk10QInferenceStack (stack definition)
karMareal1/MLT-Gen-AI-bot/cdk-10q-inference/tests/unit/test_cdk_10q_inference_stack.py:test_sqs_queue_created
karMareal1/MLT-Gen-AI-bot/cdk-10q-inference/inference_with_context.py:get_filing_text / ask_with_context
Computational Efficiency
3/10
How efficiently computing resources are used
Practical efficiency-minded choices at the pipeline level (token budgeting, chunk overlap, OCR DPI) but no GPU/quantization/distributed-training optimization artifacts.
Research Depth & Innovation
2/10
Depth of research and new ideas
Pragmatic application of hybrid retrieval and reranking (hybrid retriever, cross-encoder rerank) but no novel research contributions or reproduced paper implementations.
Expertise
RAG• Junior
Document Intelligence & OCR• Junior
Industries
Financial Services• Junior
Technologies
Python• Senior
SQL
C++
PostgreSQL
Rest API
Claude
pgvector
Claude Code
LlamaIndex
AWS CDK
Embeddings
Mistral
AWS Bedrock
huggingface_hub
CI/CD
Transformers
Pandas
Git
PaddlePaddle
PyTorch
AWS
Docker
Gemini
LLM
RAG
PyTorch C++
Requests
Phi
Pillow
PaddleOCR
AWS Lambda
Amazon EC2
Hallucination
Reranking• mentioned only
Recommendations
- Build or extend production RAG systems and document-intelligence pipelines (OCR, robust HTML extraction, adaptive chunking).
- Implement robust evaluation and experiment tracking (W&B or MLflow) and add reproducible retrieval/answering benchmarks and ablations.
- Harden MLOps for inference serving (model versioning, latency budgets, simple drift checks) using the existing CDK/Lambda foundations.
- Convert notebook prototypes into tested, modular libraries and add unit/integration tests around ingestion and retrieval components.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: