Desired Experience & Qualification
Qualifications & Experience
Relevant degree or equivalent experience
6–10 years in professional software development
Agile working experience
Essential Skills & Requirements
Technical Expertise
Strong data engineering skills, including Python coding and data ingestion (ETL, Kafka, Apache Spark)
Familiarity with AI/ML frameworks (e.g., Langchain, Langgraph, GAIA)
Frontend development (HTML, CSS, JavaScript/TypeScript, Angular/React)
AWS services (API Gateway, Lambda, DynamoDB, S3, SQS)
Git and GitHub Actions for version control and CI/CD
Knowledge of unit testing frameworks (Jest, pytest)
UI/UX principles and RESTful APIs/GraphQL
Functional Knowledge
Ability to translate business requirements into technical specifications
Defining acceptance criteria and managing scope for deliverables
Strong communication skills with technical and non-technical stakeholders
Agile Working Model participation (e.g., sprint planning, retrospectives, reviews)
Advantageous Skills
Strong interest in AI and LLM-based applications
Problem-solving mindset and eagerness to learn new technologies
Flexibility to take on varied tasks within projects
Team collaboration in a multi-national environment
Excellent interpersonal and organisational skills
Strong presentation skills
Above-board work ethics
Willingness and ability to travel internationally
Here’s a comprehensive list of 100 essential knowledge areas every AI Engineer should know, grouped by domain (ETL, Data Engineering, Machine Learning, Deep Learning, MLOps, Cloud, etc.).
Data structures (arrays, lists, trees, hash maps)
Algorithms (sorting, searching, dynamic programming)
Big O notation and computational complexity
Object-oriented programming principles
Functional programming concepts
Parallel and distributed computing basics
Networking fundamentals (TCP/IP, HTTP, APIs)
Database theory and normalization
Software architecture design patterns
Version control (Git, branching, merging)
ETL (Extract, Transform, Load) pipelines design
ELT (Extract, Load, Transform) for modern data stacks
Data ingestion from APIs, files, and streaming sources
Data quality checks and validation
Data cleansing and preprocessing techniques
Schema design and evolution
Incremental data loading and change data capture (CDC)
Batch vs. streaming data processing
Data warehousing concepts (OLAP, OLTP)
Data pipeline orchestration (Airflow, Luigi, Prefect)
SQL optimization and window functions
Integration with data lakes (Delta Lake, Iceberg, Hudi)
Metadata management and data lineage
Data partitioning and bucketing strategies
Monitoring and logging of data flows
Kafka architecture (brokers, topics, partitions)
Kafka producers and consumers
Consumer groups and offsets
Kafka Streams API and KSQL
Schema Registry and Avro/JSON serialization
Kafka Connect for integrating external systems
Idempotency and exactly-once semantics
Designing event-driven architectures
Stream processing with Spark Streaming or Flink
Kafka security (SASL, ACLs, encryption)
Spark Core RDDs and transformations
Spark SQL and DataFrames
Spark MLlib for scalable ML
Spark Streaming (Structured Streaming)
Spark integration with Kafka and HDFS
Spark optimization (partitioning, caching, joins)
PySpark programming best practices
Spark cluster management (YARN, Mesos, Kubernetes)
Spark job scheduling and tuning
Delta Lake and ACID transactions in Spark
Supervised vs unsupervised learning
Feature engineering and selection
Bias-variance trade-off
Model evaluation metrics (accuracy, precision, recall, F1, ROC-AUC)
Cross-validation and hyperparameter tuning
Regularization (L1, L2, dropout)
Ensemble methods (bagging, boosting, stacking)
Gradient descent and optimization algorithms
Linear and logistic regression fundamentals
Decision trees and random forests
SVMs and kernel tricks
Clustering (K-means, DBSCAN, hierarchical)
Dimensionality reduction (PCA, t-SNE, UMAP)
Time series forecasting methods (ARIMA, Prophet, LSTM)
Model interpretability and explainability (SHAP, LIME)
Neural networks (feedforward, CNN, RNN, LSTM)
Backpropagation and gradient computation
Activation functions (ReLU, sigmoid, tanh, GELU)
Loss functions and optimization
Convolutional Neural Networks (CNNs) for vision
Transformers and attention mechanisms
Autoencoders and embeddings
Generative models (GANs, VAEs)
Transfer learning and fine-tuning
Frameworks: TensorFlow, PyTorch, Keras
Model deployment (batch, real-time, edge)
Containerization (Docker)
Container orchestration (Kubernetes)
CI/CD for ML models (GitHub Actions, Jenkins, GitLab CI)
ML model serving (TensorFlow Serving, TorchServe, FastAPI)
Cloud platforms (AWS SageMaker, Azure ML, GCP Vertex AI)
Model monitoring and drift detection
Experiment tracking (MLflow, Weights & Biases)
Data versioning (DVC, LakeFS)
Infrastructure as code (Terraform, CloudFormation)
Text preprocessing (tokenization, stemming, lemmatization)
Bag-of-words, TF-IDF, and word embeddings
Language models (BERT, GPT, T5, LLaMA)
Named Entity Recognition (NER)
Sentiment analysis
Text summarization and translation
Question answering and retrieval-augmented generation (RAG)
Vector databases and semantic search (FAISS, Pinecone, Weaviate)
Prompt engineering and fine-tuning LLMs
Ethical considerations in NLP (bias, fairness)
Linear algebra (matrices, eigenvalues, singular value decomposition)
Probability and random variables
Bayesian inference and distributions
Hypothesis testing and p-values
Descriptive and inferential statistics
Gradient and partial derivatives
Calculus for optimization
Information theory (entropy, cross-entropy)
Matrix calculus in neural networks
Statistical modeling and simulation
Here’s a comprehensive list of 100 line items covering familiarity with modern AI/ML frameworks, especially LangChain, LangGraph, GAIA, and related LLM, MLOps, orchestration, and generative AI ecosystems.
Understanding LangChain architecture (LLMs, Chains, Tools, Agents)
Building prompt templates for LLM workflows
Using LLMChain for single-prompt tasks
Constructing multi-step chains for complex reasoning
Implementing memory in chains (ConversationBufferMemory, VectorStoreMemory)
Integrating custom tools with LangChain agents
Handling different LLM providers (OpenAI, Anthropic, Hugging Face, etc.)
Working with structured outputs (PydanticOutputParser)
Creating retrieval-augmented generation (RAG) pipelines
Building custom retrievers (BM25, FAISS, Chroma)
Using LangChain Expression Language (LCEL) for chaining logic
Streaming responses from LLMs
Logging and debugging LangChain executions
Integrating LangChain with APIs (Slack, Gmail, etc.)
Persisting agent state between sessions
Using callbacks for event-driven tracing and logging
Building knowledge assistants and chatbots with LangChain
Deploying LangChain apps via FastAPI or Streamlit
Error handling and fallback logic for model failures
Integrating LangChain with MLOps tools (MLflow, Weights & Biases)
Understanding LangGraph’s graph-based execution model
Building workflows using nodes and edges
Designing conversational state machines
Managing branching logic in AI workflows
Defining conditional and looping structures
Integrating LangGraph with LangChain components
Visualizing data and flow paths in LangGraph
Using the LangGraph SDK for Python
Orchestrating multi-agent systems with LangGraph
Persisting workflow states in vector stores or databases
Building resilient pipelines with retries and checkpoints
Debugging and tracing graph-based workflows
Deploying LangGraph pipelines in production
Integrating event-driven logic into AI pipelines
Combining LangGraph with RAG or hybrid LLM systems
(Refers to emerging frameworks like Meta’s GAIA or other Graph-based AI Agents frameworks)
36. Understanding the purpose of GAIA (Graph-based AI Agents)
37. Using GAIA for multi-agent orchestration
38. Managing distributed AI tasks across nodes
39. Implementing goal-oriented reasoning in GAIA
40. Integrating GAIA with LLM APIs and external models
41. Coordinating agent collaboration and communication
42. State synchronization between agents
43. Data persistence across distributed AI components
44. Implementing context-sharing and task delegation
45. Building composite AI workflows using GAIA
46. Debugging distributed AI networks
47. Managing versioning of AI nodes and graphs
48. Interfacing GAIA with databases and message queues
49. Leveraging GAIA for autonomous decision systems
50. Deploying GAIA pipelines in cloud-native environments
Setting up vector stores (FAISS, Chroma, Pinecone, Weaviate)
Embedding models (OpenAI, Sentence Transformers, Cohere)
Vector indexing and similarity search fundamentals
Chunking and metadata strategies for documents
Query embedding vs document embedding comparison
Hybrid retrieval (semantic + keyword search)
Context compression and summarization techniques
Storing conversation history in vector stores
RAG optimization for speed and relevance
Combining multiple retrieval sources (hybrid RAG)
Working with OpenAI API (GPT-4, GPT-4o, GPT-3.5)
Using Anthropic Claude models (Claude 3 family)
Integrating Hugging Face Transformers
Calling Cohere and Mistral APIs
Using Azure OpenAI endpoints
Streaming and batching responses efficiently
Managing tokens and rate limits
Implementing guardrails and prompt validation
Designing fallback model hierarchies
Multi-LLM orchestration for performance and reliability
Familiarity with LlamaIndex (formerly GPT Index)
Understanding semantic graph indexing
Combining LlamaIndex with LangChain workflows
Using Dust.tt or Haystack for RAG-based workflows
Knowledge of OpenDevin and CrewAI (multi-agent frameworks)
Experience with AutoGen (Microsoft) for multi-agent automation
Using Semantic Kernel for contextual reasoning
Orchestrating AI pipelines using Flowise or SuperAGI
Implementing vector graph stores in Neo4j or TigerGraph
Integrating AI orchestration frameworks with Kubernetes
Model deployment in production (FastAPI, Flask, BentoML)
Managing experiments with MLflow or W&B
Model registry and version control practices
Implementing CI/CD pipelines for AI models
Managing API gateways and load balancers for LLM apps
Logging and monitoring LLM metrics
Cost optimization and scaling strategies
Distributed model inference (Ray, Dask)
GPU optimization and resource management
Integrating AI pipelines into cloud (AWS, Azure, GCP)
Writing effective system and user prompts
Using few-shot and zero-shot prompting techniques
Designing structured prompts for reasoning
Prompt chaining and self-reflection techniques
Evaluating prompt quality with test cases
Fine-tuning open-source models (LLaMA, Falcon, Mistral)
Synthetic data generation for fine-tuning
Safety and bias mitigation in prompts
Automated prompt testing and scoring
Building reusable prompt libraries and templates
Here’s a comprehensive 100-line breakdown of essential knowledge areas covering HTML, CSS, JavaScript/TypeScript, and Angular/React — ideal for a front-end engineer or AI developer building modern, responsive, and interactive web apps.
Understanding the structure of an HTML document (doctype, head, body)
Semantic HTML tags (<header>, <main>, <section>, <footer>)
Proper use of headings (<h1>–<h6>) for accessibility and SEO
Inline vs block-level elements
HTML forms and input types (<form>, <input>, <select>, <textarea>)
Form validation (required, pattern, min/max)
Labels and accessibility attributes (aria-label, aria-hidden)
Hyperlinks and navigation (<a>, target, rel)
Image handling and optimization (<img>, srcset, alt)
Lists and tables (<ul>, <ol>, <table>)
Metadata and SEO optimization (<meta>, title, description)
Embedding content (<iframe>, <video>, <audio>)
HTML5 APIs (geolocation, drag-and-drop, web storage)
Creating modals and popups with semantic elements
Using <canvas> for graphics and visualizations
Accessibility and screen reader best practices
Lazy loading and deferred media loading
Microdata and schema.org structured data
Integrating external scripts and libraries via <script>
HTML validation and performance testing
CSS syntax, selectors, and specificity
Understanding the box model (margin, border, padding, content)
Positioning: static, relative, absolute, fixed, sticky
CSS display types (block, inline, flex, grid)
Flexbox layouts (justify-content, align-items, flex-wrap)
CSS Grid layouts (rows, columns, template areas)
Responsive design with media queries
CSS units (px, %, em, rem, vh, vw)
CSS variables (--primary-color) and custom properties
Pseudo-classes and pseudo-elements (:hover, ::after)
Transitions and animations (@keyframes, transition)
CSS transformations (scale, rotate, translate)
Shadows, gradients, and background effects
CSS clipping and masking for shapes
Typography (web fonts, line-height, letter-spacing)
CSS frameworks (Bootstrap, Tailwind, Material UI)
Theming and dark mode handling
CSS preprocessors (SASS, LESS)
Using CSS custom media and container queries
Print and accessibility styles
CSS-in-JS techniques for React/Angular
Layering with z-index and stacking contexts
Cross-browser compatibility and vendor prefixes
Performance optimization with critical CSS
Using CSS logical properties for localization
JavaScript syntax and data types
Understanding var, let, const scope rules
Control structures (loops, conditionals, switch)
Functions, arrow functions, and higher-order functions
Closures and lexical scoping
Promises, async/await, and callbacks
Event handling and DOM manipulation
Understanding the event loop and concurrency model
ES6+ features (destructuring, spread, modules)
Template literals and tagged templates
Modules and imports/exports (import, export default)
Error handling (try, catch, finally)
Fetch API and Axios for HTTP requests
JSON parsing and serialization
LocalStorage, SessionStorage, and IndexedDB
Regular expressions for data validation
JavaScript object prototypes and inheritance
Functional programming concepts (map, filter, reduce)
Working with Dates, Timers, and Intervals
DOM traversal and mutation (querySelector, appendChild)
Understanding this and context binding
Event bubbling and delegation
TypeScript basics (types, interfaces, enums)
Generics and type inference in TypeScript
Type narrowing and union types
Modules and namespaces in TypeScript
Decorators and metadata reflection
TypeScript configuration (tsconfig.json)
Linting and formatting with ESLint and Prettier
Compiling and bundling (Webpack, Vite, Rollup)
Understanding JSX and the virtual DOM
Functional components and hooks (useState, useEffect, useMemo)
Props and component composition
Context API for global state management
React Router for navigation and routing
Controlled vs uncontrolled components
Form handling and validation
React performance optimization (memoization, lazy loading)
Custom hooks for reusable logic
Error boundaries and fallback UIs
React portals and modals
Server-side rendering (Next.js fundamentals)
Integrating APIs and managing async state
Testing React apps (Jest, React Testing Library)
Deploying React apps to Netlify, Vercel, or AWS Amplify
Understanding Angular architecture (modules, components, services)
Two-way data binding and reactive forms
Dependency injection and service providers
Angular directives (*ngFor, *ngIf, custom directives)
Routing and navigation with RouterModule
Observables and RxJS for reactive programming
Change detection and zone.js
Using Angular CLI for scaffolding and builds
State management (NgRx or Akita)
Deploying Angular apps (build optimization, lazy loading)
Here’s a comprehensive 100-line breakdown on the AWS serverless stack: API Gateway, Lambda, DynamoDB, S3, and SQS — covering concepts, architecture, performance, and implementation essentials.
Purpose of API Gateway: managing and exposing APIs at scale
Difference between REST APIs, HTTP APIs, and WebSocket APIs
Setting up an API endpoint for Lambda integration
Mapping templates and request/response transformation
Custom domain names and SSL certificates with ACM
Handling different HTTP methods (GET, POST, PUT, DELETE)
Using stages for development, testing, and production
Stage variables and environment-specific configuration
Throttling and rate limiting for API protection
Request validation and input models
Enabling CORS for cross-origin requests
Integrating with AWS Lambda proxy and non-proxy models
VPC Link integrations with private services
Caching responses with API Gateway cache
Authentication with Cognito User Pools or JWT tokens
IAM-based authorization and resource policies
API Gateway logging and metrics with CloudWatch
Versioning and deployment management
Custom error responses and fallback logic
Monitoring latency and error rates in the API dashboard
Understanding Lambda’s serverless compute model
Supported runtimes (Node.js, Python, Java, Go, .NET, etc.)
Writing a simple Lambda function (Hello World example)
Triggering Lambda from API Gateway, S3, or SQS
Event-driven architecture concepts
Managing Lambda memory and timeout configurations
Cold starts and strategies to minimize latency
Environment variables and secure configurations
Lambda Layers for shared dependencies
Monitoring with CloudWatch logs and metrics
Error handling and retries in Lambda invocations
Using Dead Letter Queues (DLQs) for failed events
Asynchronous vs synchronous invocations
Using Lambda destinations for event routing
VPC integration for secure access to private resources
Security: IAM roles and least-privilege policies
Packaging and deployment using AWS SAM or Serverless Framework
CI/CD integration for Lambda (CodePipeline, GitHub Actions)
Using Lambda Powertools for observability and tracing
Concurrency controls and reserved concurrency
Cost optimization by monitoring invocation frequency
Step Functions integration for orchestration
Invoking Lambda from other services (EventBridge, DynamoDB Streams)
Handling large payloads with S3 presigned URLs
Managing function versions and aliases
Overview of DynamoDB as a NoSQL key-value database
Core components: tables, items, and attributes
Understanding partition keys and sort keys
Designing efficient primary keys for scalability
Read/write capacity modes (provisioned vs on-demand)
Global and local secondary indexes (GSI, LSI)
Querying vs scanning data — performance considerations
Data modeling using access patterns
DynamoDB Streams for real-time event triggers
Integration with Lambda for event-driven processing
Batch writes and batch gets for efficiency
Conditional writes and optimistic locking
TTL (Time to Live) for automatic item expiration
Transactions for atomic multi-item operations
Backup and restore capabilities
Point-in-time recovery (PITR) configuration
DAX (DynamoDB Accelerator) for caching performance
Security: IAM permissions and encryption at rest
Global tables for multi-region replication
Monitoring performance and throttling via CloudWatch
Understanding S3 buckets and object storage fundamentals
S3 naming conventions and regional scope
Uploading, downloading, and listing objects
S3 storage classes (Standard, Intelligent-Tiering, Glacier, Deep Archive)
S3 event triggers (for Lambda, SNS, SQS)
Presigned URLs for secure temporary access
Object versioning and lifecycle management
Cross-region replication (CRR) and same-region replication (SRR)
Static website hosting with S3
Bucket policies and access control lists (ACLs)
Encryption at rest (SSE-S3, SSE-KMS, SSE-C)
Encryption in transit (HTTPS and TLS)
Multipart uploads for large files
Object tagging and metadata management
Data consistency models (strong read-after-write consistency)
Logging access and activity in S3
Cost optimization with intelligent tiering and lifecycle rules
Integrating with CloudFront for content delivery
S3 Select and Glacier Select for querying data
Monitoring and auditing via AWS CloudTrail
Understanding Simple Queue Service (SQS) fundamentals
Standard queues vs FIFO queues
Message visibility timeout and retention period
Dead Letter Queues for failed message processing
Long polling for efficient message retrieval
Message deduplication and ordering in FIFO queues
Using message attributes for structured metadata
Integrating SQS with Lambda for event-driven systems
Scaling message consumers dynamically
Handling large message payloads with S3 references
Security and encryption of SQS messages
Monitoring queue metrics (age, delay, inflight count)
Error handling and retry strategies
Using SNS + SQS fan-out pattern for message broadcasting
Designing resilient microservices using SQS decoupling
Here are 100 clean, plain-text lines covering Knowledge of unit testing frameworks (Jest, pytest), UI/UX principles, and RESTful APIs/GraphQL:
Unit testing ensures that individual components or functions work as intended.
Jest is a popular JavaScript testing framework used with React and Node.js.
Pytest is the most widely used testing framework for Python.
Both Jest and pytest enable test-driven development (TDD) practices.
TDD improves software reliability by catching errors early in development.
Jest provides a zero-configuration setup for most JavaScript projects.
Pytest supports fixtures for setting up test environments efficiently.
Mocks and stubs are critical concepts for isolating unit tests.
Jest uses “mock functions” to simulate dependencies and measure calls.
Pytest allows dependency mocking through “monkeypatch” or “unittest.mock.”
Coverage reports in Jest help identify untested code paths.
Pytest integrates easily with coverage.py for code coverage analysis.
Continuous testing ensures that every code change is validated automatically.
Unit tests should run quickly to maintain fast CI/CD feedback loops.
Jest snapshots help ensure UI components render consistently.
Parametrized testing in pytest enables multiple input combinations.
Good test naming conventions improve clarity and debugging.
Assertions validate expected behavior in each test case.
Jest’s “expect” API offers intuitive syntax for writing assertions.
Pytest’s assert rewriting makes test failures highly readable.
Integration with GitHub Actions ensures tests run automatically on commits.
Unit tests form the foundation of software quality assurance.
Writing testable code requires modular and decoupled architecture.
Testing asynchronous code is essential for modern web applications.
Jest provides built-in utilities for handling async/await and promises.
Pytest supports async testing using the pytest-asyncio plugin.
UI/UX design focuses on user experience and interface interaction.
A good UI is visually appealing and intuitive.
UX emphasizes how users feel when interacting with a product.
Accessibility is a key component of UX design.
Responsive design ensures usability across devices and screen sizes.
Consistent color schemes and typography improve UI aesthetics.
Minimalism in UI design helps users focus on core tasks.
Wireframing helps visualize layout before development.
Prototyping allows user testing before final implementation.
UI/UX design should always be guided by user research.
Usability testing provides insight into how users interact with the product.
Design systems maintain consistency across large projects.
Tools like Figma and Adobe XD are common for UI/UX prototyping.
UX heuristics guide usability improvements.
Feedback loops, such as visual cues or animations, enhance interactivity.
RESTful APIs follow the principles of Representational State Transfer.
REST uses standard HTTP methods such as GET, POST, PUT, DELETE.
Each REST endpoint represents a specific resource.
REST APIs are stateless, ensuring scalability.
JSON is the most common data format for REST responses.
HTTP status codes communicate success or failure.
REST APIs must be versioned to manage backward compatibility.
GraphQL provides a flexible alternative to REST APIs.
GraphQL allows clients to request exactly the data they need.
It reduces over-fetching and under-fetching of data.
GraphQL schemas define types and relationships.
Queries in GraphQL describe the desired data structure.
Mutations in GraphQL modify data on the server.
Subscriptions in GraphQL enable real-time updates.
Apollo Client is a popular GraphQL implementation in front-end apps.
GraphQL servers are typically implemented with Apollo Server or Hasura.
REST endpoints are easier to cache compared to GraphQL queries.
Both REST and GraphQL can be secured using authentication and tokens.
API documentation is essential for developer usability.
Swagger or OpenAPI is used for REST documentation.
GraphQL has built-in introspection for API exploration.
REST endpoints should follow predictable naming conventions.
Pagination in REST APIs helps handle large datasets.
GraphQL supports cursor-based pagination for efficiency.
REST APIs should return consistent response structures.
Error handling in REST includes standardized error codes and messages.
In GraphQL, errors are embedded in the response body.
REST APIs can be tested with Postman or cURL.
GraphQL queries can be tested using GraphiQL or Apollo Sandbox.
Security best practices include input validation and rate limiting.
JWT (JSON Web Tokens) are commonly used for API authentication.
REST APIs can be deployed on AWS API Gateway or Azure API Management.
GraphQL endpoints can be integrated with serverless backends.
Performance monitoring ensures API scalability under load.
Caching improves performance for frequently accessed endpoints.
Jest can mock REST or GraphQL API calls for isolated testing.
Pytest integrates with requests-mock for simulating API behavior.
Testing API endpoints helps maintain reliability during changes.
End-to-end testing complements unit testing for full system validation.
UI tests validate user flows through the interface.
Jest supports UI testing with tools like React Testing Library.
Pytest can automate UI testing with Selenium or Playwright.
CI/CD pipelines automate both unit and integration testing.
Test reports should be integrated into development dashboards.
Automated testing improves deployment confidence.
UI/UX feedback should guide iterative design improvements.
REST and GraphQL both support mobile and web integration.
Developers must understand both back-end and front-end API interactions.
Consistent error messaging improves the developer experience.
API rate limits protect services from abuse.
API gateways manage traffic and enforce security policies.
REST APIs can leverage HTTP caching headers for optimization.
GraphQL requires query complexity limits to avoid performance issues.
Unit tests should cover all logic branches and edge cases.
Regression testing ensures new changes don’t break existing functionality.
UI design should adapt to changing accessibility standards.
REST and GraphQL evolve continuously, requiring ongoing learning.
Effective testing, design, and API integration define product quality.
Mastery of these areas ensures robust, user-friendly, and maintainable applications.