Revise README for DevIntellect project overview

Updated project title and description to reflect the new focus on DevIntellect, an AI-based cognitive and technical intelligence engine. Revised key features, system architecture, and local setup instructions.

Author: namitha2526

README.md

@@ -1,150 +1,98 @@
-## Cloud-Native CI/CD Deployment Pipeline: FastAPI · PostgreSQL · Docker · GitHub Actions · IBM Cloud
+# DevIntellect – AI-Based Cognitive & Technical Intelligence Engine
 
-A fully automated DevOps pipeline that builds, tests, containerizes, and deploys a FastAPI microservice using Docker and IBM Cloud. The application runs inside containers, with code automatically deployed from GitHub to production. PostgreSQL is used as the persistent data store. The pipeline leverages IBM Cloud Container Registry, IBM Cloud Code Engine, and GitHub Actions — all deployable under free-tier conditions.
+DevIntellect is a cloud-native AI system designed to evaluate a developer’s technical depth and cognitive problem-solving patterns to generate personalized career-path recommendations.
+
+The platform integrates backend intelligence modeling, cognitive assessment, and interactive analytics visualization into a scalable full-stack architecture.
 
 ---
-#### 📌Features:
 
-1. FastAPI backend with modular design (CRUD endpoints, user management)
+##  Key Features
 
-2. PostgreSQL database — local (via Docker) or cloud-hosted via container
+- AI-driven Technical Depth Analysis
+- Cognitive Problem-Solving Pattern Evaluation
+- Personalized Career Path Recommendation Engine
+- RESTful FastAPI Backend Architecture
+- SQLAlchemy-Based Persistent User Analytics
+- Interactive Radar Visualization Dashboard
+- Dockerized Deployment with CI/CD Integration
+- Cloud Deployment (Render)
 
-3. Docker + Docker Compose for containerization and local development
+---
 
-4. Automated CI/CD pipeline using GitHub Actions (test → build → push → deploy)
+##  System Architecture
 
-5. Container image storage via IBM Cloud Container Registry
+Frontend:
+- React.js
+- Chart.js (Radar Visualization)
 
-6. Deployment to IBM Cloud Code Engine (serverless container hosting) — scales automatically and supports container images built from source or registry images
+Backend:
+- FastAPI
+- SQLAlchemy ORM
+- REST APIs
 
-7. API testing using Postman/Newman
+Intelligence Layer:
+- Technical Score Computation Engine
+- Cognitive Profile Vector Generator
+- Rule-Based Career Recommendation Engine
 
-8. Clean environment-based configuration, easy local development and cloud deployment
+Deployment:
+- Docker
+- CI/CD Pipeline
+- Cloud Hosting (Render)
 
 ---
-#### Architecture:
-```
-GitHub → GitHub Actions → Run Tests → Build Docker Image → Push to IBM Container Registry
-                                                                       ↓
-                                                      Deploy to IBM Cloud Code Engine
-                                                                       ↓
-                                        FastAPI Service Container + PostgreSQL Container
-                                                                       ↓
-                                                       Persistent Data & API Exposure
-
-```
-Code changes trigger GitHub Actions.
 
-Successful builds produce container images pushed to IBM Cloud Container Registry.
+##  How It Works
 
-Code Engine pulls the image, deploys the container, and exposes a public endpoint.
+1. User submits technical metrics (languages, repo activity, complexity indicators).
+2. User completes cognitive assessment inputs.
+3. Backend computes:
+   - Technical Depth Score
+   - Cognitive Profile Vector
+4. Intelligence Engine maps results to structured career recommendations.
+5. Results are visualized via radar dashboard and stored in database.
 
-Postgres runs alongside (in another container) or can be replaced with a managed solution.     
-
----
-#### Tech Stack:
-
-```
-| Layer              | Technology                                                               |
-| ------------------ | ------------------------------------------------------------------------ |
-| Backend            | FastAPI, Python, SQLAlchemy                                              |
-| Database           | PostgreSQL (Docker / IBM Cloud container)                                |
-| Containerization   | Docker, Docker Compose                                                   |
-| CI/CD              | GitHub Actions                                                           |
-| Container Registry | IBM Cloud Container Registry                                             |
-| Cloud Hosting      | IBM Cloud Code Engine (auto-scaling, serverless)                         |
-| Testing            | Pytest, Postman / Newman                                                 |
-| CI/CD Flow         | On Git commit → build & test → push Docker image → deploy to Code Engine |
-
-```
----
-#### Project Structure:
-```
-devops-project/
-│
-├── app/
-│   ├── main.py
-│   ├── models.py
-│   ├── schemas.py
-│   ├── crud.py
-│   ├── database.py
-│   ├── config.py
-│   └── requirements.txt
-│
-├── tests/
-│   └── test_api.py
-│
-├── Dockerfile
-├── docker-compose.yml
-├── postman_collection.json
-├── .env.example
-├── .github/
-│    └── workflows/
-│        └── ci-cd.yml
-└── README.md
-```
 ---
 
-### Local Setup:
-```bash
-cp .env.example .env
-docker-compose up --build
-```
-API available at: http://localhost:8000
-#### Testing:
-```bash
-pytest -q
-```
-
-Run API tests via Postman or Newman:
-```bash
-newman run postman_collection.json
-```
----
-#### IBM Deployment:
+##  Sample Output
 
-Deploying to IBM Cloud (Free-tier friendly)
+- Technical Score: 82/100
+- Analytical Strength: 7.5
+- Architectural Thinking: 8.5
+- Recommended Career Path: AI/ML Engineer
 
-Create free IBM Cloud account (no credit card required). 
-IBM
+---
 
-Install IBM Cloud CLI + Code Engine plugin. 
-DEV Community
-```
-Log in: ibmcloud login → ibmcloud target -g Default
+##  Tech Stack
 
-Push Docker image to IBM Cloud Container Registry:
+- Python
+- FastAPI
+- React
+- SQLAlchemy
+- Docker
+- REST APIs
+- Chart.js
+- CI/CD
+- Cloud Deployment (Render)
 
-ibmcloud cr login
+---
 
-docker tag ... <region>.icr.io/<namespace>/<repo>:<tag>
+##  Motivation
 
-docker push <region>.icr.io/<namespace>/<repo>:<tag>
-```
-Deploy with Code Engine: in Console or CLI (ibmcloud ce app create ...) selecting your image. Code Engine will pull image from registry and run container automatically. 
-IBM Cloud
+Many students build projects without understanding their real strengths and cognitive patterns. DevIntellect bridges this gap by combining technical analytics and cognitive modeling into a structured intelligence system.
 
-Get public URL from Code Engine and access your API
 ---
-#### Required GitHub Secrets:
-```
-IBM_CLOUD_API_KEY
-IBM_CR_REGION
-IBM_CR_NAMESPACE
-IBM_CR_REPOSITORY
-IBM_CE_PROJECT
-IBM_CE_APP_NAME
-DATABASE_URL   (optional)
-```
-#### Production Notes:
 
-Use environment variables or IBM Cloud Secrets to manage sensitive data
+##  Future Enhancements
 
-Avoid heavy usage that exceeds free container registry/storage limits (e.g. keep images < 500 MB) 
+- GitHub API Auto-Integration
+- LLM-Based Cognitive Evaluation
+- Vector Embedding Skill Mapping
+- Multi-Agent Career Advisor Framework
+- Market Demand Alignment Engine
 
-For persistence beyond container lifecycle, mount volumes or use managed databases (if you scale beyond free tier)
+---
 
-Monitor logs and container health via IBM Cloud Logging / Monitoring
-#### Summary:
+## 👩‍💻 Author
 
-This project demonstrates how to build, containerize, test, and deploy a backend API using modern DevOps workflows and cloud-native infrastructure. It reflects real-world engineering practices used in production environments.                                                
+Namitha R