IntegroAI Core Algorithm: Step-by-Step

Phase 1: Knowledge Ingestion & Management

1.​ Input Source Identification:

○​ A. User Uploaded Files: Identify incoming files (PDF, DOCX, XLSX, CSV, JSON) via the
Dashboard.
○​ B. Website Scraping: Identify URLs provided for information extraction.
○​ C. API Integrations: Identify external APIs connected for real-time data feeds.
2.​ Data Extraction & Pre-processing:
○​ A. Document Parsing:
■​ For PDF/DOCX: Extract text, tables, and images.
■​ For XLSX/CSV: Parse tabular data into structured formats.
■​ For JSON: Parse structured data.
○​ B. Web Content Extraction: Scrape specified web pages, extract relevant text, and
filter out boilerplate content (headers, footers, ads).
○​ C. Text Cleaning & Normalization:
■​ Remove special characters, HTML tags, and irrelevant formatting.
■​ Correct common typos (optional, can be done during embedding).
■​ Split large texts into smaller, manageable chunks (e.g., paragraphs,
sentences) for better retrieval.
3.​ Knowledge Representation (Embedding & Vector Database):
○​ A. Semantic Embedding: Use Sentence Transformers to convert text chunks into
dense numerical vectors (embeddings). This captures the semantic meaning of the
text.
○​ B. Vector Database Storage: Store these embeddings, along with their original text
chunks and metadata (source, timestamp, etc.), in a scalable vector database
(Pinecone, Weaviate, or Milvus). FAISS can be used for local indexing if not using a
cloud vector DB.
○​ C. Knowledge Graph Construction (Optional/Advanced): For complex relationships,
an underlying knowledge graph could be inferred or constructed to enhance
retrieval.
4.​ Automated Data Refresh (Continuous Learning - Backend Task):
○​ A. Schedule Monitoring: Periodically check configured sources (websites, APIs, or
designated file directories) for updates.
○​ B. Delta Detection: Identify new, modified, or deleted information.
○​ C. Re-processing: For changes, repeat steps 2 and 3 to update the vector database.
○​ D. AI Retraining Trigger: If significant changes occur, flag for a potential AI model
retraining cycle (see Phase 4).

Phase 2: Chatbot Interaction & Core Reasoning

1.​ User Input Reception:

 ○​ A. Multimodal Input: Receive user input via text (Dashboard widget, integrated
channels) or voice (LiveKit integration).
○​ B. Speech-to-Text (Voice Input): If voice input, use Cartesia STT to convert speech to
text in real-time. Silero VAD (Voice Activity Detection) can ensure only relevant
speech is processed.
2.​ Initial Input Processing:
○​ A. Intent Recognition & Entity Extraction: (Optional, can be handled by LLM directly)
Analyze the user's query to understand the user's goal and extract key entities.
○​ B. Sentiment Analysis: Use built-in sentiment analysis to gauge the emotional tone
of the user's query.
3.​ Knowledge Retrieval (RAG Pipeline - LangChain/LangGraph):
○​ A. Query Embedding: Convert the user's processed query into a vector embedding
using the same Sentence Transformer model used for the knowledge base.
○​ B. Semantic Search: Query the vector database (FAISS/Pinecone/Weaviate/Milvus)
to find the most semantically similar knowledge chunks to the user's query. Retrieve
a ranked list of relevant passages.
○​ C. Contextual Assembly: Combine the original user query with the retrieved
knowledge chunks to form a comprehensive prompt for the LLM.
4.​ Response Generation (Cerebras GPT-J / LangChain Orchestration):
○​ A. Prompt Engineering: Craft a detailed prompt for Cerebras GPT-J that includes:
■​ System instructions (e.g., "You are IntegroAI, a helpful customer service
assistant.").
■​ User's query.
■​ Retrieved knowledge chunks as context.
■​ Instructions on desired tone, personalization, and multilingual response.
■​ Sentiment analysis insights (if applicable).
○​ B. LLM Inference: Send the prompt to the Cerebras GPT-J model.
○​ C. Response Filtering & Refinement: (Optional) Post-process the LLM's raw output to
ensure coherence, remove redundancy, and align with brand guidelines.
5.​ Multimodal Output & Human Handoff:
○​ A. Text-to-Speech (Voice Output): If voice response is required, use Cartesia TTS to
convert the generated text response into natural-sounding speech.
○​ B. Response Delivery: Deliver the text or voice response to the user via the
appropriate channel.
○​ C. Human Escalation Check:
■​ If the LLM's confidence score is below a threshold.
■​ If the user explicitly requests to speak to a human.
■​ If sentiment analysis detects high frustration.
■​ Handoff Workflow: Trigger a LiveKit-powered human agent handoff, passing
the conversation history and relevant context to the live agent.

Phase 3: Dashboard & Management

1.​ Dashboard User Interface (HTML/CSS/JS):

 ○​ A. Knowledge Management Interface: Allow users to upload files, enter URLs, view
existing knowledge, and trigger refreshes.
○​ B. Testing Sandbox Interface: Provide a chat interface for simulating interactions,
debugging, and viewing underlying RAG context.
○​ C. Customization Interface: Allow users to configure chatbot branding, avatars,
greetings, and tone.
○​ D. Integration & Deployment Interface: Generate and display embed codes, provide
options for channel integrations (WhatsApp, Telegram, etc.).
○​ E. User Management Interface: Administer user roles and permissions.
2.​ Analytics & Reporting (Backend - Celery/Redis, PostgreSQL):
○​ A. Interaction Logging: Log every user query, chatbot response, retrieved
knowledge, sentiment score, and human handoff event into PostgreSQL.
○​ B. Metrics Calculation: Aggregate logged data to calculate:
■​ Total chat volume.
■​ Common queries/FAQs.
■​ Customer satisfaction scores (explicit feedback or inferred from sentiment).
■​ Human handoff rates.
■​ Query resolution rates.
○​ C. Dashboard Visualization: Present these metrics and trends through interactive
charts and reports on the Dashboard. LangSmith can be used for debugging and
monitoring of the LLM pipeline.

Phase 4: Continuous Improvement & Security

1.​ AI Training Loop (Backend - Celery/Redis, LangChain/LangGraph):

○​ A. Feedback Collection: Collect explicit user feedback (e.g., "Was this helpful?") and
implicit feedback (e.g., human agent corrections, unresolved queries).
○​ B. Anomaly Detection: Identify queries that consistently lead to poor responses or
human handoffs.
○​ C. Data Annotation/Refinement: Human experts review these problematic
interactions, correct responses, and potentially refine the knowledge base.
○​ D. Model Fine-tuning/Re-training (Optional): If sufficient new annotated data is
gathered, fine-tune the Cerebras GPT-J model or re-train embedding models to
improve accuracy. This is a complex, resource-intensive step usually done
periodically.
○​ E. Deployment of New Models: Seamlessly deploy updated models in the
production environment with minimal downtime.
2.​ Security & Compliance:
○​ A. Data Encryption: Implement end-to-end encryption for data in transit and at rest
(PostgreSQL, Vector DB, knowledge files).
○​ B. Access Control: Enforce role-based access control (RBAC) for the Dashboard and
API access.
○​ C. Audit Logging: Maintain detailed audit logs of all user actions and system events.
○​ D. Compliance Checks: Ensure adherence to regulations like GDPR, especially
concerning personal data handling and retention.
Deployment & Scalability (Docker, Kubernetes, Cloud)

1.​ Containerization: Package all IntegroAI services (FastAPI backend, Celery workers, LiveKit,
etc.) into Docker containers.
2.​ Orchestration: Deploy and manage these containers using Kubernetes for high availability,
auto-scaling, and self-healing capabilities.
3.​ Cloud Infrastructure: Utilize cloud providers (AWS/GCP/Azure) for scalable compute, storage,
and networking resources to host Kubernetes clusters and databases.
4.​ Load Balancing: Distribute incoming user requests across multiple chatbot instances to
handle high traffic loads.

Here's a visual representation of the core IntegroAI architecture:

IntegroAI: Independent Components for Development
We can categorize the components into "Core Services," "Interfaces," "Auxiliary Services," and
"Infrastructure."

I. Core Services (Backend Logic & Data)

These are the brain and memory of IntegroAI. They can be developed as separate microservices.

1.​ Knowledge Ingestion & Processing Service:

○​ Purpose: Handles all aspects of taking raw data and turning it into a usable
knowledge base.
○​ Inputs: Raw files (PDF, DOCX, etc.), URLs, API configurations.
○​ Outputs: Embeddings, processed text chunks, metadata stored in the Vector
Database and PostgreSQL.
○​ Key Modules:
■​ File Parsers (PDF, DOCX, XLSX, CSV, JSON)
■​ Web Scraper
■​ Text Cleaner & Chunking
■​ Embedding Generator (Sentence Transformers integration)
■​ Vector Database Interaction Module (writes to Pinecone/Weaviate/Milvus)
■​ Scheduled Refresh Logic
○​ Dependencies: External libraries for parsing, Sentence Transformers, Vector
Database client.
○​ API Endpoints: POST /ingest/file, POST /ingest/url, PUT /knowledge/{id} (update),
DELETE /knowledge/{id}
2.​ Core Reasoning & Chatbot Logic Service:
○​ Purpose: Orchestrates the chatbot's decision-making, from query understanding to
response generation.
○​ Inputs: User query (text from Chatbot Widget or Speech-to-Text Service).
○​ Outputs: Chatbot response (text), human handoff trigger.
○​ Key Modules:
■​ Query Embedding
■​ RAG Orchestrator (LangChain/LangGraph)
■​ Vector Database Query Module (reads from Pinecone/Weaviate/Milvus)
■​ LLM Interaction Module (Cerebras GPT-J API calls)
■​ Sentiment Analysis Module
■​ Human Handoff Trigger Logic
○​ Dependencies: Vector Database client, LLM provider API, LangChain/LangGraph.
○​ API Endpoints: POST /chat, POST /chat/history
3.​ Analytics & Reporting Service:
○​ Purpose: Collects, processes, and stores all interaction data for insights.
○​ Inputs: Interaction logs (user query, bot response, sentiment, handoff events) from
Core Reasoning Service.
○​ Outputs: Aggregated metrics, reports, raw logs stored in PostgreSQL.
 ○​ Key Modules:
■​ Data Ingestion/Logger
■​ Metrics Aggregator
■​ PostgreSQL Interaction Module (writes/reads analytics data)
■​ Report Generator
○​ Dependencies: PostgreSQL database.
○​ API Endpoints: GET /analytics/dashboard, GET /analytics/report/{type}

II. Interfaces (User-Facing & External Communications)

These components handle interactions with users and other external systems.

1.​ Admin Dashboard Frontend (Web Application):

○​ Purpose: Provides a user interface for businesses to manage IntegroAI.
○​ Inputs: User actions (clicks, form submissions).
○​ Outputs: API requests to Knowledge Ingestion, Analytics, User Management,
Customization services.
○​ Key Modules:
■​ Knowledge Base Management UI (upload, view, edit)
■​ Testing Sandbox UI
■​ Customization UI (branding, avatars)
■​ Integration & Deployment UI (embed code generation)
■​ Analytics Visualization UI
■​ User/Role Management UI
○​ Dependencies: All backend API services.
○​ Technology: HTML/CSS/JS (e.g., React, Angular, [Link]).
2.​ Chatbot Widget Frontend (Embeddable JavaScript Component):
○​ Purpose: The actual chatbot interface embedded on client websites.
○​ Inputs: User text input, user voice input (through browser microphone).
○​ Outputs: Text queries to Core Reasoning Service.
○​ Key Modules:
■​ Chat UI/UX
■​ Microphone input handling
■​ Voice Activity Detection (Silero VAD - browser-side)
■​ API calls to Core Reasoning Service
○​ Dependencies: Core Reasoning Service API, Speech-to-Text (browser-side or
dedicated service).
○​ Technology: HTML/CSS/JS (vanilla or lightweight framework).
3.​ Real-time Communication Service (Voice & Human Handoff):
○​ Purpose: Manages real-time voice conversations and live agent handoffs.
○​ Inputs: User voice streams from Chatbot Widget, agent voice streams.
○​ Outputs: Transcribed text to Core Reasoning Service, synthesized speech to Chatbot
Widget, connection to human agents.
○​ Key Modules:
■​ LiveKit Server/Integration
 ■​ Speech-to-Text (Cartesia STT integration for server-side)
■​ Text-to-Speech (Cartesia TTS integration)
■​ Agent Routing Logic
○​ Dependencies: Cartesia API, Core Reasoning Service (for text input/output).
○​ API Endpoints: WebSocket connections for real-time streams.

III. Auxiliary Services (Support & Enhancements)

1.​ User Management & Authentication Service:

○​ Purpose: Manages user accounts, roles, permissions, and authentication.
○​ Inputs: User registration, login attempts, role updates.
○​ Outputs: Authenticated tokens, user profiles, role assignments.
○​ Key Modules:
■​ User Registration/Login
■​ Role-Based Access Control (RBAC) Logic
■​ Token Generation/Validation (JWT)
○​ Dependencies: PostgreSQL (for user data).
○​ API Endpoints: POST /auth/register, POST /auth/login, GET /users/{id}, PUT
/users/{id}/roles
2.​ Third-Party Integrations Service:
○​ Purpose: Handles connections to external messaging platforms (WhatsApp,
Telegram, Slack, Facebook).
○​ Inputs: Messages from external channels.
○​ Outputs: Formatted messages to Core Reasoning Service, responses back to external
channels.
○​ Key Modules:
■​ Platform-specific API Clients (WhatsApp Business API, Telegram Bot API, etc.)
■​ Message Normalization/De-normalization
○​ Dependencies: Core Reasoning Service API.
○​ API Endpoints: Webhooks for incoming messages, POST requests to send messages.

IV. Infrastructure & Databases

These are shared resources that multiple services depend on.

1.​ Vector Database:

○​ Purpose: Stores and efficiently retrieves semantic embeddings.
○​ Technology: Pinecone, Weaviate, Milvus (or self-hosted FAISS + disk storage).
○​ Dependencies: Accessed by Knowledge Ingestion (write) and Core Reasoning (read).
2.​ Relational Database (PostgreSQL):
○​ Purpose: Stores structured data like user accounts, chatbot configurations, analytics
logs, and metadata for knowledge chunks.
○​ Technology: PostgreSQL.
○​ Dependencies: Accessed by User Management, Analytics, Knowledge Ingestion
(metadata).
3.​ Task Queue & Cache (Redis/Celery):
 ○​ Purpose: Manages background tasks (e.g., knowledge base refresh, heavy report
generation) and provides caching for frequently accessed data.
○​ Technology: Redis (for message broker and cache), Celery (for task management).
○​ Dependencies: Used by Knowledge Ingestion, Analytics, potentially Core Reasoning
for async tasks.
4.​ Deployment & Orchestration Platform:
○​ Purpose: Manages the deployment, scaling, and monitoring of all services.
○​ Technology: Docker (containerization), Kubernetes (orchestration), Cloud Providers
(AWS/GCP/Azure).
○​ Dependencies: Hosts all other services.

Development Flow with Independent Components:

1.​ Define APIs: Start by clearly defining the API contracts (endpoints, request/response
formats) for each service. This allows teams to work in parallel.
2.​ Develop Core Services First: Knowledge Ingestion, Core Reasoning, and User Management
are foundational.
3.​ Build Interfaces: Once core services have stable APIs, Admin Dashboard, Chatbot Widget,
and Real-time Communication can consume them.
4.​ Integrate Auxiliary Services: Analytics and Third-Party Integrations can be built and hooked
in as core functionalities mature.
5.​ Database Setup: Set up and manage the Vector Database and PostgreSQL early, as they are
central dependencies.
6.​ Infrastructure: Implement Docker, Kubernetes, and cloud deployment strategies throughout
the development lifecycle, allowing for continuous integration and deployment (CI/CD).
IntegroAI: Suggested Learning Paths by Component
I. Core Services (Backend Logic & Data)

1.​ Knowledge Ingestion & Processing Service

○​ Core Skills: Python programming, Data Parsing, Text Processing, Natural Language
Processing (NLP), Vector Databases.
○​ Courses:
■​ Python Fundamentals:
■​ Coursera: Python for Everybody Specialization (University of
Michigan) - Excellent for beginners.
■​ Udemy: 100 Days of Code: The Complete Python Pro Bootcamp -
Project-based, very comprehensive.
■​ NLP & Text Processing:
■​ Coursera: NLP Specialization ([Link]) - Covers embeddings,
transformers, and more. Essential for understanding how to process
text for models.
■​ Pluralsight: Core Python: Understanding the Data Science Ecosystem
(specifically sections on Pandas for structured data, NLTK/SpaCy for
text).
■​ Vector Databases:
■​ Official Pinecone/Weaviate/Milvus Documentation & Tutorials: Start
with their quickstarts. They often have dedicated courses or
extensive guides.
■​ YouTube: "Introduction to Vector Databases" / "RAG with [Vector DB
Name]" - Many free resources explain the concepts.
■​ Web Scraping:
■​ Udemy: Python for Data Science and Machine Learning Bootcamp
(often includes Beautiful Soup/Scrapy sections).
■​ Official Scrapy Documentation: Learn to build robust web crawlers.
2.​ Core Reasoning & Chatbot Logic Service
○​ Core Skills: Advanced Python, Large Language Models (LLMs), Prompt Engineering,
RAG Architectures, LangChain/LangGraph, API Integration.
○​ Courses:
■​ LLMs & Prompt Engineering:
■​ [Link]: Prompt Engineering for Developers - Crucial for
effective LLM interaction.
■​ [Link]: LangChain for LLM Application Development -
Direct training on using LangChain.
■​ Coursera: Generative AI with Large Language Models (Google Cloud)
- Broader understanding of LLMs.
■​ Advanced Python (for orchestrators like LangChain):
■​ Udemy: Advanced Python Programming - Covers design patterns,
async programming.
■​ Vector Database Interaction (Reading):
 ■​ Same as Knowledge Ingestion, but focus on query methods.
■​ API Design & Development (if you build your own LLM wrapper):
■​ Udemy: FastAPI and Python: The Complete Developer Guide - Learn
to build efficient APIs for your service.
3.​ Analytics & Reporting Service
○​ Core Skills: SQL, Data Warehousing, Data Visualization, Backend Development
(Python/FastAPI).
○​ Courses:
■​ SQL for Data Analysis:
■​ Coursera: SQL for Data Science (UC Davis) - Strong foundation.
■​ Udemy: The Complete SQL Bootcamp with PostgreSQL - Hands-on
with PostgreSQL.
■​ Data Warehousing Concepts:
■​ Coursera: Data Warehouse Concepts, Design, and Data Integration
(University of Colorado) - Understand how to structure data for
analytics.
■​ Backend Development (Python/FastAPI):
■​ Udemy: FastAPI and Python: The Complete Developer Guide - Use
FastAPI to expose analytics data via APIs.
■​ Data Visualization Principles:
■​ Coursera: Data Visualization with Python (IBM) - If you want to build
internal visualization logic.

II. Interfaces (User-Facing & External Communications)

1.​ Admin Dashboard Frontend (Web Application)

○​ Core Skills: HTML, CSS, JavaScript, a modern JavaScript framework (React, Angular,
or [Link]).
○​ Courses:
■​ Web Development Fundamentals:
■​ The Odin Project (Free, comprehensive curriculum) - Project-based,
covers full-stack but strong frontend.
■​ freeCodeCamp (Free, interactive lessons) - Excellent for core HTML,
CSS, JS.
■​ JavaScript Framework (Choose one):
■​ Udemy: React - The Complete Guide (incl Hooks, React Router,
Redux) - Most popular choice.
■​ Coursera: Front-End Web UI Frameworks and Tools: Bootstrap 4
(Hong Kong University of Science and Technology) - For Angular.
■​ Udemy: Vue JS 3 - The Complete Guide (w/ Composition API) - For
[Link].
■​ API Integration (Frontend perspective):
■​ Look for sections in framework courses on "fetching data" or "API
calls."
2.​ Chatbot Widget Frontend (Embeddable JavaScript Component)
 ○​ Core Skills: HTML, CSS, JavaScript (vanilla or lightweight framework), Web APIs (Web
Speech API for browser STT/TTS), WebSockets.
○​ Courses:
■​ JavaScript Fundamentals:
■​ MDN Web Docs (JavaScript Guide) - Excellent free resource for
in-depth understanding.
■​ Udemy: The Complete JavaScript Course 2024: From Zero to Expert!
■​ Web Sockets:
■​ Tutorials on building real-time apps with WebSockets (e.g., using
[Link] or vanilla WebSocket API).
■​ Voice in the Browser:
■​ Google Developers: Web Speech API documentation & examples.
■​ Search for "browser speech recognition javascript tutorial."
3.​ Real-time Communication Service (Voice & Human Handoff)
○​ Core Skills: WebRTC, WebSockets, Audio Processing (basic), Backend Development
(e.g., Python/FastAPI or [Link]/Express for LiveKit server).
○​ Courses:
■​ WebRTC & Real-time Communication:
■​ Official LiveKit Documentation & Tutorials: Start here. They have
client SDKs and server setup guides.
■​ Udemy: WebRTC & WebSockets: Build Real-time Applications -
Focuses on the underlying technologies.
■​ Speech Processing (Integration):
■​ Cartesia API Documentation: Learn to integrate their STT/TTS
services.
■​ Basic Audio Concepts: Understanding codecs, latency, etc.
■​ Backend Development:
■​ Udemy: FastAPI and Python: The Complete Developer Guide (if
building the LiveKit wrapper in Python).
■​ Udemy: [Link], Express, MongoDB & More: The Complete
Bootcamp 2024 (if building in [Link], often used with WebRTC).

III. Auxiliary Services (Support & Enhancements)

1.​ User Management & Authentication Service

○​ Core Skills: Backend Development (Python/FastAPI), Database Interaction
(PostgreSQL), Security (Hashing, JWTs, OAuth2), API Design.
○​ Courses:
■​ API Security & Authentication:
■​ Udemy: Master Microservices with Spring Boot and Spring Cloud
(even if not using Java, the security principles are universal).
■​ Look for tutorials on "JWT authentication in Python/FastAPI."
■​ Database Interaction:
■​ Same as SQL courses above, plus ORMs like SQLAlchemy.
■​ Backend Development (Python/FastAPI):
 ■​ Udemy: FastAPI and Python: The Complete Developer Guide - Focus
on database integration and authentication patterns.
2.​ Third-Party Integrations Service
○​ Core Skills: Backend Development (Python/FastAPI), API Integration (various
platforms), Webhooks.
○​ Courses:
■​ Backend Development (Python/FastAPI):
■​ Udemy: FastAPI and Python: The Complete Developer Guide
■​ Specific Platform APIs:
■​ Official WhatsApp Business API Documentation
■​ Telegram Bot API Documentation
■​ Facebook Messenger Platform Documentation
■​ Slack API Documentation
■​ Focus on understanding webhooks and REST API calls.

IV. Infrastructure & Databases

1.​ Vector Database

○​ Core Skills: Database Fundamentals, Specific Vector DB Concepts (indexes, distance
metrics).
○​ Courses:
■​ Official Documentation for Pinecone, Weaviate, Milvus: They are usually the
best source for setup, integration, and best practices.
■​ YouTube: "Getting Started with [Vector DB Name]" - Many free introductory
videos.
2.​ Relational Database (PostgreSQL)
○​ Core Skills: SQL, Database Administration, Database Design.
○​ Courses:
■​ Udemy: The Complete SQL Bootcamp with PostgreSQL
■​ Coursera: Database Management Essentials (University of Colorado)
■​ LinkedIn Learning: PostgreSQL Essential Training for Data Professionals
■​ For Administration: Udemy: The Ultimate PostgreSQL Bootcamp
3.​ Task Queue & Cache (Redis/Celery)
○​ Core Skills: Asynchronous Programming, Caching Strategies, Message Queues.
○​ Courses:
■​ Redis:
■​ Redis University (Free courses from Redis Labs) - Excellent official
resource.
■​ Udemy: Learn Redis from Scratch with Python Examples
■​ Celery:
■​ Official Celery Documentation: Comprehensive guides.
■​ YouTube: "Celery Python Tutorial" / "Asynchronous Tasks in Python" -
Many practical guides.
4.​ Deployment & Orchestration Platform
○​ Core Skills: Linux Fundamentals, Docker, Kubernetes, Cloud Computing
(AWS/GCP/Azure basics).
○​ Courses:
■​ Docker:
■​ Udemy: Docker & Kubernetes: The Practical Guide
■​ Coursera: Docker Essentials (IBM)
■​ Kubernetes:
■​ Udemy: Certified Kubernetes Administrator (CKA) with Practice Tests
- Very comprehensive, prepares for certification.
■​ Coursera: Architecting with Google Kubernetes Engine (Google
Cloud) - If focusing on GCP.
■​ Cloud Computing (Choose one):
■​ AWS Certified Cloud Practitioner (Exam Prep) - Good entry point for
AWS.
■​ Google Cloud Digital Leader (Exam Prep) - Good entry point for GCP.
■​ Azure Fundamentals (AZ-900 Exam Prep) - Good entry point for
Azure.
■​ Linux Fundamentals:
■​ LinuxAcademy (now A Cloud Guru) or Udemy: Linux Mastery: Master
the Linux Command Line in 11.5 Hours