Mohammed Abdul Moid
LLM & Agents
Python
SQL
Node JS
JavaScript
C#
Active 5 days ago
Download CVCV
Overview
Technical skills
Projects
Timeline
Roles
Overview
LLM-enabled full-stack engineer (middle level) focused on building pragmatic agentic systems and ML-enabled tools with an emphasis on integrations and end-to-end delivery. The strongest proven skill is integrating LLMs and content pipelines into a reliable product flow, demonstrated by the OllamaAgent and the FastAPI-based LinkedIn post agent (Postagent/src/linkedin_agent/ai/ollama_agent.py and Postagent/src/linkedin_agent/main.py). There is limited evidence of deep research work, production-grade MLOps (model versioning, profiling), or clinical-grade validation for health-related models.
Phone
Technical skills
Languages
5
Python
SQL
Node JS
JavaScript
C#
Python
6
Requests
FastAPI
Pydantic
HTTPX
Boto3
Beautiful Soup
AI/ML
16
LangChain
OpenAI
NumPy
OpenCV
Pandas
Scikit-learn
Streamlit
LLM
Amazon SageMaker
AWS Bedrock
LangGraph
PyTorch
TensorFlow
YOLO
Keras
RAG
DevOps
5
AWS
Azure
Amazon S3
Amazon EC2
AWS Lambda
Frontend
4
React.js
Bootstrap
React Router
Socket.IO
Databases
6
PostgreSQL
MySQL
SQLite
Amazon Aurora
Pinecone
Weaviate
Other
25
Express
Axios
Pytest
GitHub
GitHub Actions
Uvicorn
LangSmith
Docker
Git
Linux
Rest API
Supabase
Twilio
AI Agents
CI/CD
Jenkins
Embeddings
Prompt Engineering
WebSockets
Agentic Workflows
Computer Vision
Human-in-the-Loop
Knowledge Graph
NLP
IAM
Projects
Face identification CLI that extracts 512-dimensional face embeddings and stores them in a persistent vector database for lookup. The real-time pipeline is optimized to reach high throughput using background threading and configurable frame-handling strategies. It supports multiple InsightFace model variants to balance speed and accuracy.
Real-time weapon detection system using YOLOv8 running on multiple camera feeds. It fetches CCTV footage via RTSP and optimizes the inference pipeline for low latency performance. The system integrates with AWS S3 for storage and Twilio for automated alerting when detections occur.
A FastAPI-based agent that polls RSS feeds and generates structured LinkedIn drafts via an LLM, formatted for human review. Publishing is gated with a human-in-the-loop approval step. It integrates LinkedIn OAuth2 and the UGC API with CSRF state validation and token expiry handling, while using SQLite state to deduplicate processed content. Dockerized and covered with automated tests for reproducible deployment.
Timeline
Full Stack Developer Intern
·
Junior
One Path Business Solutions
·
Internship
Built a multi-tenant WhatsApp-ops SaaS using React and Supabase, including tenant-scoped row-level security and an AI-driven edge-function workflow. Implemented a human-confirm-before-write pattern to control AI actions. Developed modules for task/meeting automation, inventory tracking, and CRM pipeline management, and also created a construction ERP with role-based portals and end-to-end workflows from CRM to closeout.
Supabase
Osmania University (OU)
Bachelor's Degree ·
Computer Science & Engineering (AI and Data Science concentration)
Software Solutions Associate
·
Middle
Telangana Forest Development Corporation Limited
·
Full-Time
Designed and built a role-based reporting platform for district managers and a super-admin general manager. Implemented a spreadsheet-style inline data-entry grid for users and applied hashed credential-based authentication. Aggregated and presented real-time cross-district data for managerial visibility.
Full Stack Developer with AI Integration Intern
·
Junior
The Student Spot
·
Internship
Deployed a RAG-based LLM agent into production workflows serving 500+ users, using the OpenAI API and LangChain for retrieval and prompt handling. Orchestrated asynchronous API flows to deliver end-to-end responses in an operational environment. Worked in Agile/Scrum and improved performance by optimizing prompts and profiling bottlenecks in the retrieval pipeline.
OpenAI
LangChain
RAG
Middle AI/ML Engineer
Confidence: High LLM Engineer
LLM-enabled full-stack engineer (middle level) focused on building pragmatic agentic systems and ML-enabled tools with an emphasis on integrations and end-to-end delivery. The strongest proven skill is integrating LLMs and content pipelines into a reliable product flow, demonstrated by the OllamaAgent and the FastAPI-based LinkedIn post agent (Postagent/src/linkedin_agent/ai/ollama_agent.py and Postagent/src/linkedin_agent/main.py). There is limited evidence of deep research work, production-grade MLOps (model versioning, profiling), or clinical-grade validation for health-related models.
Model Architecture & Training
2/10
How well models are designed and trained
Mostly uses pretrained models and classical ML workflows; contains a RandomForest training notebook and use of InsightFace for embeddings but no custom architectures, distributed training, or advanced optimizer/scheduler engineering.
Evidence
GUT-HEALTH/Training.ipynb: notebook with RandomForest training and GridSearchCV
Facerecognition-cli/src/face_recognizer.py: InsightFace usage and embedding extraction
Data Pipeline & Feature Engineering
3/10
How data is prepared for models
Practical data pipelines and ingestion for multiple domains (face image directories, RSS feeds), plus migration-aware DB logic; pipelines are functional but not highly instrumented or production-hardened at scale.
Evidence
Facerecognition-cli/src/face_recognizer.py: load_faces_from_directory and add_face_to_database for structured image ingestion
Postagent/src/linkedin_agent/feeds/rss.py: fetch_feed/_parse_entry and Postagent/src/linkedin_agent/feeds/normalize.py: normalize_url
Postagent/src/linkedin_agent/db.py: _init_schema and _migrate_image_columns
Experimentation & Evaluation
2/10
How results are measured and tested
Contains unit tests and basic evaluation (ML notebook metrics and pytest unit tests) and reasonable logging; lacks experiment tracking, reproducible run management, or extensive ablation studies.
Evidence
Postagent/tests/test_drafting.py: unit tests for draft generation logic
GUT-HEALTH/Training.ipynb: GridSearchCV and evaluation cells
MLOps & Deployment
3/10
How models are shipped to production
Delivers working deployment artifacts (FastAPI app with lifespan/scheduler, SQLite migrations, CLI apps, Streamlit UI); shows decent operational concerns but lacks advanced MLOps features like model versioning, serving infrastructure or observability for models.
Evidence
Postagent/src/linkedin_agent/main.py: FastAPI app with lifespan and FeedScheduler integration
Postagent/src/linkedin_agent/db.py: schema init, migrations and token/draft management
Facerecognition-cli/main.py and interactive_cli.py: CLI entrypoints and runtime behaviors
Computational Efficiency
1/10
How efficiently computing resources are used
Some attention to runtime performance (ultra-fast realtime hints, camera settings) but no measured profiling, GPU/quantization work, or explicit batching/throughput optimization artifacts.
Evidence
Facerecognition-cli/interactive_cli.py and main.py: 'ultrafast' and 'fastrealtime' command stubs
Facerecognition-cli/src/photo_capture.py: camera FPS/size tuning and UI optimizations
Research Depth & Innovation
1/10
Depth of research and new ideas
Limited research depth; uses off-the-shelf models and reasonable prompt engineering for Ollama, but no novel algorithms, custom layers, or reproduced paper results.
Evidence
Postagent/src/linkedin_agent/ai/ollama_agent.py: system prompt design and response cleaning
Facerecognition-cli/src/face_recognizer.py: integration of InsightFace rather than custom architecture
Expertise
AI / LLM Engineering (Agents)· Middle
Technologies
Python· since 2024 · Middle
SQL
MySQL
PostgreSQL
Supabase· since 2026
Weaviate
LangGraph
LangChain· since 2025
Pinecone
OpenCV
YOLO
GitHub Actions
WebSockets
Embeddings
Scikit-learn
Prompt Engineering
Beautiful Soup
Computer Vision
AI Agents
NLP
LangSmith
Azure
AWS Bedrock
CI/CD
Jenkins
TensorFlow
Pandas
NumPy
Keras
Git
SQLite
PyTorch
AWS
Docker
LLM· since 2026
RAG· since 2025
Streamlit
Pydantic
HTTPX
Requests
Boto3
Amazon Aurora
AWS Lambda
Amazon EC2
OpenAI· since 2025
Amazon SageMaker
GitHub
Amazon S3
IAM
Human-in-the-Loop
Knowledge Graph
Agentic Workflows
Linux
Computer Vision· mentioned only
Human-in-the-Loop· mentioned only
Llama· mentioned only
Machine Learning· mentioned only
Ollama· mentioned only
Vision· mentioned only
Recommendations
- Build human-in-the-loop LLM agents and content automation pipelines where prompt design, validation and safe approval flows are primary requirements.
- Develop prototype computer-vision tools and CLI utilities that integrate pretrained models (detection/embedding) and simple database-backed management.
- Implement full-stack ML apps (FastAPI + background schedulers + SQLite/Postgres) that require pragmatic engineering, testing and OAuth integrations.
- Work on Streamlit or lightweight dashboards for model demonstration and user feedback loops, including adding basic telemetry and experiment logging.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Backend Developer
Confidence: High API Engineer
A practical Middle-level backend engineer focused on Python-based APIs and AI integration - strongest at building pragmatic REST services with OAuth and AI-assisted content pipelines as shown by the FastAPI app and Ollama integration - lacks evidence of large-scale distributed system design or production-grade security hardening.
API Design
4/10
How well APIs are designed
Well-structured REST endpoints and OAuth flows show practical API design skills but lack formal versioning, pagination, idempotency keys, or a documented error contract.
Evidence
Postagent/src/linkedin_agent/main.py: /login, /oauth/linkedin/callback and /drafts handlers showing OAuth and route design
Postagent/src/linkedin_agent/web/routes.py: create_routes function and approve_draft endpoint with simple CSRF/form handling
Postagent/src/linkedin_agent/linkedin/posting.py: validate_posting_requirements and post_to_linkedin functions (request payload construction and error handling)
Data Layer & Database
4/10
Working with databases
Shows deliberate data-layer decisions for SQLite including schema init, indexing, simple migrations and upsert patterns, but no multi-step migration history or advanced transactional patterns.
Evidence
Postagent/src/linkedin_agent/db.py: _init_schema creates tables and indexes and calls _migrate_image_columns
Postagent/src/linkedin_agent/db.py: _migrate_image_columns uses PRAGMA to inspect schema and ALTER TABLE to add columns
Postagent/src/linkedin_agent/db.py: save_token uses INSERT ... ON CONFLICT for upsert and mark_url_posted uses INSERT OR IGNORE (idempotency at URL level)
Scalability & Performance
3/10
Handling load and speed
Some scalability awareness - background scheduler and polling limits - but no queueing, caching strategy or connection pooling for production-scale workloads.
Evidence
Postagent/src/linkedin_agent/scheduler.py: FeedScheduler uses APScheduler background scheduler to decouple polling work
Postagent/src/linkedin_agent/main.py: poll_feeds_and_create_drafts implements max_drafts limit and per-feed processing
Postagent/src/linkedin_agent/main.py: add_article uses httpx.AsyncClient with timeout to avoid blocking on remote fetches
System Architecture
4/10
Overall system structure
Code is modularized into clear packages (oauth, posting, db, web, ai), with an application lifespan and separation of concerns, but the architecture is a single-process deployment pattern without multi-service contracts.
Evidence
Postagent/src/linkedin_agent/main.py: FastAPI app with lifespan manager creating DB and scheduler
Postagent/src/linkedin_agent/web/routes.py: create_routes showing modular route registration and separation of web vs api logic
Package layout: src/linkedin_agent with dedicated modules (db.py, linkedin/, ai/, feeds/, drafting/) showing deliberate module boundaries
Security & Auth
3/10
Protecting data and access
Practical auth handling (OAuth state validation, token storage and validation) but surface security gaps exist such as minimal CSRF protection, direct env file edits, and no prepared defenses for rate limiting or deeper threat models.
Evidence
Postagent/src/linkedin_agent/main.py: oauth_callback validates state and saves token via Database.save_token
Postagent/src/linkedin_agent/linkedin/posting.py: validate_posting_requirements enforces presence of person URN and access_token
Postagent/src/linkedin_agent/main.py: add_feed directly edits .env file to update FEEDS (security/config hygiene concern)
Reliability & Observability
4/10
Stability and monitoring
Good basic observability and reliability practices: structured logging, lifespan start/shutdown, timeouts, and unit tests for core logic, but missing distributed tracing and advanced resilience patterns (retries with backoff, circuit breakers).
Evidence
Postagent/src/linkedin_agent/main.py: logging.basicConfig and try/except blocks with exc_info for error visibility; FastAPI lifespan for graceful startup/shutdown
Postagent/tests/test_drafting.py and tests/test_rss.py: unit tests covering drafting and RSS parsing
Postagent/src/linkedin_agent/main.py: httpx timeouts and try/except around remote requests for resilience
Expertise
Backend AI & LLM· Middle
Microservices & API Architecture· Middle
Databases & Vector Storage· Middle
Python· Middle
Industries
Artificial Intelligence· Middle
Internet Services· Middle
Technologies
C#
Rest API
FastAPI
Uvicorn
Recommendations
- Implement production-safe token and secret handling and avoid writing secrets directly to .env; use a secrets manager or clearly gated config flows.
- Migrate SQLite workflows to a proper RDBMS or managed DB for concurrent access and add schema migrations (Alembic) to create a verifiable migration chain.
- Harden posting endpoints by adding CSRF protection, idempotency keys for publish actions, and rate limiting with reasoned limits and backoff.
- For the face-recognition work, add a vector-backed store (FAISS/Annoy/PGVector) and a small async worker queue to offload embedding extraction and improve throughput.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior Frontend Developer
Confidence: Medium UI Engineer
Frontend developer (approx junior-to-middle level) focused on building polished React-based sites and simple real-time features; strongest at producing presentational UI and small end-to-end features. The strongest proven skill is building small real-time web apps and UIs, demonstrated by a complete Socket.IO based chat (chatify/server.js and chatify/public/app.js) and a polished portfolio site (own-website components and style.css). There is limited evidence of architecture for large-scale apps, measurable performance work, automated tests, or advanced state-management patterns in the public code.
UI Component Architecture
3/10
How interface parts are built
Modular React components and composition are present, but there is no custom design system, limited custom hooks, and most composition uses react-bootstrap and simple prop passing rather than advanced component architecture.
Evidence
own-website/src/components/Projects/Projects.js: composes ProjectCard components to render project list
own-website/src/components/Navbar.js: encapsulated Navbar using react-bootstrap and Link composition
own-website/src/components/Home/Home2.js: presentational component structure with layout via react-bootstrap
Responsive & Cross-browser
4/10
Works on all screens and browsers
Responsive rules and breakpoints are implemented via CSS media queries and react-bootstrap; mobile-focused adjustments are present, but there is no evidence of advanced layout techniques like container queries or explicit RTL/i18n handling.
Evidence
chatify/public/style.css: multiple @media queries adapting layout and sizes for narrow viewports
own-website/src/style.css: many @media (max-width: 767px) rules tailoring layout, typography and component spacing
Performance Optimization
1/10
Speed of the interface
Little to no measured performance work or advanced optimizations; no code-splitting, bundle analysis artifacts, virtualization, or explicit render profiling present in the human-authored files.
Evidence
chatify/public/app.js: straightforward DOM updates and scrolling without virtualization or batching
own-website/src/style.css: visual polish and preloader present but no measured performance artifacts or build optimization traces
Accessibility & Semantics
2/10
Usable for everyone
Basic semantic HTML and some accessible attributes exist (alt text, labels, aria-controls), but there is no systematic ARIA usage, focus management for custom widgets, keyboard handling beyond defaults, or accessibility testing artifacts.
Evidence
chatify/public/index.html: input elements with label (hidden) and autocomplete attributes
own-website/src/components/Home/Home2.js: <img> includes alt="avatar"
own-website/src/components/Navbar.js: Navbar.Toggle includes aria-controls usage via react-bootstrap
State Management & Data Flow
2/10
Managing data in the app
State and data flow are simple and correct for small apps (React local state, Socket.IO event flow). There is no evidence of server-state caching strategies, optimistic update rollback, request cancellation, or state machines for complex flows.
Evidence
chatify/server.js: Socket.IO handlers implementing join-room, message broadcast and disconnect notifications
chatify/public/app.js: client-side join and message emit handlers implementing the real-time flow
UX & Visual Polish
4/10
Look and feel quality
Clear visual polish and UX attention for small sites: preloader, transitions, polished chat UI and layout. Much of the polish is template-driven and there are limited custom UX resilience patterns (undo, optimistic states).
Evidence
chatify/public/style.css: styled chat bubbles, responsive message container and focus states
own-website/src/style.css: preloader, animations, and detailed visual styles used across the site
own-website/src/components/Projects/Projects.js: curated project cards and presentation-focused content
Verified artifacts
Expertise
React· Junior
HTML & CSS· Junior
Technologies
JavaScript
Node JS· Junior
Express
Socket.IO
Bootstrap
React.js
Axios
React Router
GitHub· mentioned only
Recommendations
- Build small-to-medium React web apps and marketing sites where component-level polish and responsive CSS matter (landing pages, portfolios, marketing micro-sites).
- Implement real-time features and prototyping for product demos using Socket.IO and Node/Express (chat, presence, collaborative widgets).
- Work on component libraries and refactor existing code into reusable design-system tokens and hooks (to demonstrate component architecture and ownership).
- Contribute to medium-complexity SPA features that require improved state discipline (introduce React Query / SWR, request cancellation, and testing for flows).
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: