A comprehensive, production-ready data analytics platform demonstrating expertise in data processing, visualization, and machine learning. Built with modern microservices architecture and designed for scalability and performance.
- 🏗️ Microservices Architecture - Scalable C# API + Python Analytics Engine
- 🎨 Modern UI/UX - React TypeScript with Material-UI and Dark/Light themes
- 🤖 Machine Learning - Multiple algorithms with real-time training and prediction
- 📈 Interactive Visualizations - Dynamic charts and dashboards with Plotly.js
- 🔒 Enterprise Security - JWT authentication with role-based access control
- ⚡ High Performance - Redis caching, database optimization, async processing
- 🐳 DevOps Ready - Docker containerization with CI/CD pipeline support
- Data Processing: Advanced data cleaning, transformation, and preprocessing
- Machine Learning: Support for multiple algorithms including Random Forest, XGBoost, and Neural Networks
- Data Visualization: Interactive charts and dashboards using Plotly.js
- Statistical Analysis: Comprehensive statistical tools and correlation analysis
- Real-time Processing: Asynchronous job processing with Redis message queues
- Caching: Redis-based caching for improved performance
- Authentication: JWT-based authentication with role-based access control
- Microservices Architecture: Separate C# API and Python analytics engine
- Scalable Design: Docker containerization with horizontal scaling support
- Performance Optimized: Database indexing, connection pooling, and caching strategies
- Comprehensive Testing: Unit tests, integration tests, and API documentation
- Modern Frontend: React TypeScript with Material-UI components
- API Documentation: OpenAPI/Swagger documentation for all endpoints
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ React Frontend │ │ C# ASP.NET │ │ Python FastAPI │
│ (TypeScript) │◄──►│ Core API │◄──►│ Analytics Engine│
│ │ │ │ │ │
└─────────────────┘ └─────────────────┘ └─────────────────┘
│ │
▼ ▼
┌─────────────────┐ ┌─────────────────┐
│ PostgreSQL │ │ Redis │
│ Database │ │ Cache & Queue │
└─────────────────┘ └─────────────────┘
- C# ASP.NET Core 8.0: Main API service with Entity Framework Core
- Python FastAPI: Analytics engine with async support
- PostgreSQL: Primary database with JSONB support
- Redis: Caching and message queue system
- React 18: Modern UI framework
- TypeScript: Type-safe JavaScript
- Material-UI: Component library
- Plotly.js: Interactive data visualizations
- React Router: Client-side routing
- Docker & Docker Compose: Containerization
- Nginx: Reverse proxy and load balancing
- Prometheus: Metrics and monitoring
- Serilog: Structured logging (C#)
- Loguru: Advanced logging (Python)
- scikit-learn: Core ML algorithms
- XGBoost: Gradient boosting
- pandas: Data manipulation
- NumPy: Numerical computing
- Plotly: Data visualization
- statsmodels: Statistical analysis
- Docker and Docker Compose
- .NET 8.0 SDK (for local development)
- Python 3.11+ (for local development)
- Node.js 18+ (for frontend development)
-
Clone the repository
git clone <repository-url> cd data-analytics-platform
-
Start the platform
docker-compose up -d
-
Access the application
- Frontend: http://localhost:3000
- C# API: http://localhost:5000
- Python Analytics: http://localhost:8000
- API Documentation: http://localhost:5000/swagger
cd backend/DataAnalytics.API
dotnet restore
dotnet runcd analytics-engine
pip install -r requirements.txt
uvicorn main:app --reload --port 8000cd frontend
npm install
npm start# Start PostgreSQL and Redis
docker-compose up -d postgres redis
# Run database migrations
cd backend/DataAnalytics.API
dotnet ef database updateimport requests
# Upload dataset
files = {'file': open('data.csv', 'rb')}
response = requests.post('http://localhost:5000/api/datasets/upload',
files=files,
headers={'Authorization': 'Bearer <token>'})
# Process data
processing_request = {
"datasetId": response.json()['id'],
"operations": ["clean", "normalize"],
"configuration": {
"remove_duplicates": True,
"handle_missing": "drop"
}
}
requests.post('http://localhost:5000/api/analytics/process-data',
json=processing_request,
headers={'Authorization': 'Bearer <token>'})training_request = {
"datasetId": "dataset-id",
"algorithm": "random_forest",
"targetColumn": "target",
"features": ["feature1", "feature2", "feature3"],
"hyperparameters": {
"n_estimators": 100,
"max_depth": 10
}
}
response = requests.post('http://localhost:5000/api/analytics/train-model',
json=training_request,
headers={'Authorization': 'Bearer <token>'})viz_request = {
"datasetId": "dataset-id",
"chartType": "scatter",
"xColumn": "feature1",
"yColumn": "feature2",
"configuration": {
"title": "Feature Correlation",
"colorColumn": "target"
}
}
response = requests.post('http://localhost:5000/api/analytics/visualize',
json=viz_request,
headers={'Authorization': 'Bearer <token>'})This project demonstrates proficiency in:
- ✅ Modern React TypeScript frontend with Material-UI
- ✅ RESTful API design with ASP.NET Core
- ✅ Microservices architecture with inter-service communication
- ✅ Database design and optimization with PostgreSQL
- ✅ Data preprocessing and feature engineering
- ✅ Multiple ML algorithms (Random Forest, XGBoost, Neural Networks)
- ✅ Model evaluation and hyperparameter tuning
- ✅ Real-time prediction APIs
- ✅ Docker containerization and orchestration
- ✅ Redis caching and message queues
- ✅ Performance optimization and monitoring
- ✅ Security best practices and authentication
- ✅ Clean architecture and SOLID principles
- ✅ Comprehensive testing (unit, integration, API)
- ✅ API documentation with OpenAPI/Swagger
- ✅ Error handling and logging strategies
data-analytics-platform/
├── 🎨 frontend/ # React TypeScript UI
│ ├── src/components/ # Reusable UI components
│ ├── src/pages/ # Application pages
│ ├── src/contexts/ # React contexts (theme, auth)
│ └── src/services/ # API service layer
├── 🔧 backend/ # C# ASP.NET Core API
│ ├── DataAnalytics.API/ # Web API controllers
│ ├── DataAnalytics.Core/ # Business logic
│ ├── DataAnalytics.Data/ # Data access layer
│ └── DataAnalytics.Tests/ # Unit tests
├── 🐍 analytics-engine/ # Python FastAPI service
│ ├── src/api/ # API routes
│ ├── src/services/ # ML and data services
│ ├── src/models/ # Data models
│ └── tests/ # Python tests
├── 🗄️ database/ # Database scripts
│ ├── migrations/ # Schema migrations
│ └── seed-data/ # Sample data
├── 🐳 docker/ # Docker configurations
├── 📚 docs/ # Documentation
└── 🚀 scripts/ # Deployment scripts
Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
- Fork the repository
- Create your feature branch (
git checkout -b feature/AmazingFeature) - Commit your changes (
git commit -m 'Add some AmazingFeature') - Push to the branch (
git push origin feature/AmazingFeature) - Open a Pull Request
This project is licensed under the MIT License - see the LICENSE file for details.
Your Name
- GitHub: @yourusername
- LinkedIn: Your LinkedIn
- Portfolio: Working on now
- Built with modern technologies and best practices
- Inspired by real-world data analytics challenges
- Designed for scalability and maintainability
⭐ If you found this project helpful, please give it a star! ⭐