Dieudo
Tshibangu
Full Stack Developer & AI Engineer. I build modern web applications and intelligent solutions with React, Next.js, Django, and cloud technologies.
What I Bring to Your Project
I don't just write code. I deliver solutions that help your business grow.
Full Stack Development
End-to-end expertise from backend architecture to frontend implementation. I build complete, scalable solutions.
AI Integration
Experience integrating IBM watsonx, LangChain, and building grounded AI systems that cite real data.
Clean Scalable Solutions
Code that's maintainable, testable, and built to scale. I prioritize architecture over quick fixes.
Client-Focused Approach
Clear communication, realistic timelines, and solutions that actually solve your business problems.
The Problem with Most AI Assistants
They hallucinate. A chatbot that invents task statuses or fabricates risk scores is worse than no chatbot at all. Teams need an AI assistant that cites real data and admits when it doesn't know something.
TeamPilot's Solution: Grounded AI
When you ask "What tasks are blocked right now?", TeamPilot's AI doesn't guess. It queries the PostgreSQL database, retrieves actual blocked tasks, and generates a response citing real task IDs and risk scores. The AI explicitly disclaims: "AI cannot modify any records." This prevents hallucination and builds trust.
Grounded AI Assistant
AI queries the database before responding. Every answer cites real tasks, risks, and data. No hallucination.
Project Management Core
Teams, projects, tasks, and assignments in one platform. Role-based permissions keep data secure.
AI Recommendations
Granite analyzes task dependencies and team workload, then suggests priorities with confidence scores.
Team Workload Analytics
Visual dashboard shows who's overloaded and who has capacity. Balance work distribution intelligently.
Risk Scoring
Automatic risk detection based on task blockers, dependencies, and deadlines. Proactive problem-solving.
Read-Only AI
AI cannot modify records. It can read, analyze, and recommend — but never edit or delete. Trust by design.
5-Minute Product Walkthrough
Watch how TeamPilot's grounded AI assistant works with real project data. This demo uses a seeded environment with sample tasks and teams.
Inside TeamPilot AI
All screenshots from a seeded demo environment. This is what the product actually looks like.
AI Chat — Grounded Responses
AI queries the database first, then cites real tasks and risk scores. No hallucination.
Recommendations Engine
Granite analyzes task dependencies and suggests priorities with confidence scores.
Project Dashboard
Overview of all projects, tasks, team members, and real-time status updates.
Workload Analytics
Visual dashboard showing team capacity, overloaded members, and work distribution.
All screenshots captured from seeded demo environment • Not production data
Engineering Principles
I don't just write code. I design systems. Every technical decision starts with a business question: What problem does this solve? Who benefits? What's the simplest solution that works?
Product Thinking Before Coding
I start by understanding the business problem, not the tech stack. The best code is code that solves a real need. If a feature doesn't serve the user, it doesn't ship.
API-First Architecture
I design APIs before building UIs. This forces clear contracts between frontend and backend, makes testing easier, and enables future integrations without refactoring.
Modular by Default
I structure backends as independent modules (Django apps, microservices). Each module has one responsibility. This makes codebases maintainable, testable, and scalable.
Grounded AI, Not Hallucination
AI should cite real data, not invent facts. I validate every AI response against the database. If the AI doesn't know something, it says so. Trust requires honesty.
Documentation as a Product Requirement
Code without documentation is a liability. I write clear README files, API docs, and inline comments. Future developers (including me) will thank past me.
Simplicity Over Complexity
I resist over-engineering. Use a library if it solves a real problem. Build custom if libraries add bloat. The best architecture is the one that's easy to understand.
Build for the Next Developer
I write code assuming someone else will maintain it. Clear variable names, logical file structure, no clever tricks. Readability > brevity.
Performance Is a Feature
Slow software is bad software. I optimize database queries, lazy-load assets, and cache intelligently. Users notice speed.
System Architecture
TeamPilot uses a modular architecture where each layer has a clear responsibility. This separation makes the system testable, maintainable, and scalable.
Full Stack Architecture
Frontend (React + TypeScript)
Dashboard UI • AI Chat Interface • Task Management • Team Views
API Layer (Django REST Framework)
Authentication (JWT) • Serialization • Permission Control • API Endpoints
Business Logic (Django Apps)
Modular apps for teams, projects, tasks, AI chat, and recommendations
Database
PostgreSQL
AI Layer
IBM watsonx
Each layer is independent and testable. The AI layer queries the database through Django's ORM — this is how grounding works.
How Grounding Works: AI Request Flow
When you ask "What tasks are blocked right now?", here's what happens:
Intent Classification
LangChain analyzes the query and identifies it as a "Task Status Query"
Database Query
Django ORM executes: Task.objects.filter(status='blocked')
Returns 3 blocked tasks with risk scores
Validation
Check: Are there blocked tasks? ✓ Does user have permission? ✓ Is data current? ✓
Response Generation
IBM watsonx Granite generates a natural language response citing the real data
"3 tasks are currently blocked:"
- • Task #47: API Integration (Risk: High)
- • Task #52: Database Migration (Risk: Medium)
- • Task #61: UI Polish (Risk: Low)
Disclaimer: AI cannot modify any records.
Key Technical Decisions & Trade-offs
Every technology choice has trade-offs. Here's why I chose each piece of the stack — and what I gave up to get there.
Django over FastAPI for Backend
Why This Choice?
- •Built-in admin panel (rapid CRUD UI for testing)
- •Strong ORM (reduces SQL boilerplate)
- •Django apps enforce modularity
- •Mature ecosystem (DRF, JWT auth, CORS)
Trade-off
- •Slightly heavier than FastAPI
- •Less async-native (though Django 4+ has async views)
For a product with complex business logic (teams, projects, tasks, permissions), Django's structure outweighs FastAPI's raw speed. I'd choose FastAPI for a pure API microservice.
REST over GraphQL
Why This Choice?
- •Simpler to understand (clients know exactly what endpoints exist)
- •Easier to cache (HTTP caching works out of the box)
- •No over-fetching/under-fetching issues at this scale
- •DRF provides excellent tooling
Trade-off
- •Multiple endpoints instead of one query endpoint
- •Clients can't request custom field sets
GraphQL adds complexity without solving a problem TeamPilot actually has. REST is sufficient and simpler.
PostgreSQL over MongoDB
Why This Choice?
- •Relational integrity (teams → projects → tasks is hierarchical)
- •JSON support (for AI metadata, flexible fields)
- •Strong query optimizer
- •Proven reliability
Trade-off
- •Schema migrations require more planning than schemaless DBs
Project management data is relational. PostgreSQL's integrity constraints prevent orphaned tasks or broken team references.
IBM watsonx Granite over OpenAI GPT
Why This Choice?
- •Built for the IBM AI Builders Challenge (project requirement)
- •Enterprise-grade (designed for business use)
- •Grounding-friendly (no aggressive hallucination)
Trade-off
- •Smaller model (13B vs GPT-4's scale)
- •Less creative/conversational than GPT
Granite is perfect for structured queries ("What tasks are blocked?"). It's not designed for creative writing, which is exactly what I want — predictable, grounded responses.
Engineering Challenges Solved
Real problems I encountered while building TeamPilot — and how I debugged and solved them.
IBM watsonx 403 Authentication Errors
Problem
Initial API calls to watsonx returned 403 Forbidden. The error message was vague ("Authentication failed"), and the IBM documentation didn't clarify the API key format.
Debugging Process
- 1.Inspected request headers in browser DevTools
- 2.Compared with IBM SDK examples (found discrepancy in Bearer token format)
- 3.Regenerated IAM token with correct scope
- 4.Validated API key placement (header vs query param)
Solution
The API key needed to be passed as Authorization: Bearer {IAM_TOKEN}, not as a query parameter. Once corrected, all requests succeeded.
Always inspect the actual HTTP request, not just the SDK wrapper. Tools abstract away details — sometimes you need to see the raw HTTP.
Preventing AI Hallucination in a Safety-Critical Context
Problem
If an AI assistant invents task statuses ("Task X is complete" when it's not), it breaks user trust and creates real project risk.
Debugging Process
- 1.Researched RAG (Retrieval-Augmented Generation) patterns
- 2.Studied LangChain validation chains
- 3.Tested edge cases (empty database, missing permissions)
- 4.Analyzed failure modes (what happens if DB query fails?)
Solution
Built a validation layer: (1) AI never queries the database directly — it asks the Django backend. (2) Backend returns structured data (JSON), not natural language. (3) AI generates response only after receiving validated data. (4) Response includes citation ("Source: Task #47, Risk Score: 8/10"). (5) Explicit disclaimer: "AI cannot modify any records".
Grounding isn't optional for business tools. AI should cite sources like a research paper.
How TeamPilot Was Built
Building software isn't just about writing code. It's about research, architecture, testing, and iteration. Here's the full process.
Phase 1: Research
Week 1I started by researching existing project management tools (Asana, Linear, Jira) and their AI features. Most tools either have no AI or generic chatbots that don't understand project-specific context. I identified the gap: an AI assistant that's grounded in your actual project data.
Phase 2: Architecture
Week 1-2Before writing code, I designed: Database schema (ERD for teams, projects, tasks, users), API endpoints (REST conventions, authentication flow), AI integration strategy (when to query the database vs when to use the LLM), and wireframes (low-fidelity, focus on information hierarchy).
Phase 3: Development
Week 2-5I built in this order: (1) Authentication system (Django JWT, role-based permissions), (2) Core models (teams, projects, tasks), (3) REST API (DRF serializers, viewsets), (4) Frontend UI (React components, Tailwind styling), (5) AI integration (IBM watsonx, LangChain, grounding layer), (6) Recommendation engine (risk scoring, confidence calculation).
Phase 4: Testing
Week 5-6I tested: Edge cases (empty projects, blocked tasks with no risk score), AI grounding (does it hallucinate if the database has no data?), Permission boundaries (can a Member see Admin-only data?), and Mobile responsiveness (dashboard legibility on small screens).
Phase 5: Deployment
Week 6I containerized the app with Docker, configured environment variables for IBM API keys, and deployed to a staging environment. I seeded demo data to create the screenshots used in this portfolio.
Phase 6: Iteration
Post-IBM ChallengeAfter submission, I added: Workload dashboard (visualize team capacity), Confidence scores for recommendations (transparency), French-language UI elements (bilingual support), and Video demo for this portfolio.
What I'd Do Differently
If I rebuilt TeamPilot today, here's what I'd change. Every project has trade-offs — acknowledging them is more credible than pretending everything is perfect.
Add Comprehensive Test Coverage
I focused on shipping features fast for the IBM Challenge deadline.
I'd prioritize unit tests for business logic (risk scoring, permissions) and integration tests for the AI layer. Target: 80%+ coverage.
Catch bugs earlier, enable confident refactoring, reduce manual QA time.
Extract AI Layer as Microservice
Right now, AI logic lives in a Django app.
I'd separate it into a FastAPI microservice — easier to scale independently, easier to swap LLMs, cleaner separation of concerns.
Better scalability, independent deployment, language flexibility.
Implement Rate Limiting on AI Endpoints
IBM watsonx has usage limits, but there's no rate limiting in the app.
I'd add Redis-based rate limiting per user to prevent accidental quota exhaustion. Example: 20 AI queries per minute per user.
Protect API quota, prevent abuse, better cost control.
Add Real-Time Updates via WebSockets
Task status changes currently require a page refresh.
I'd use Django Channels + WebSockets to push updates to connected clients. When a task is marked complete, everyone sees it instantly.
Better UX, feels more responsive, reduces server polling.
Build a Design System
I built UI components ad-hoc as needed.
I'd create a proper design system with Storybook: reusable components, documented variants, consistent tokens. Makes future development faster.
Consistency, faster development, easier onboarding for new devs.
These aren't excuses. They're honest acknowledgments of trade-offs made under time constraints. Every project has them. The difference is whether you pretend they don't exist or learn from them.
Technology Choices
Every technology has a reason. Here's what I use and why each one earned its place in the stack.
Backend
Django
Rapid development, built-in admin, modular app structure
Django REST Framework
Powerful serialization, built-in authentication, browsable API
FastAPI
(Future) High-performance async APIs for microservices
Python
Readable, rich AI/ML ecosystem, rapid prototyping
Frontend
React
Component reusability, rich ecosystem, strong TypeScript support
Next.js
(This portfolio) SSR, file-based routing, excellent DX
Tailwind CSS
Utility-first, rapid styling, consistent design tokens
TypeScript
Type safety reduces runtime errors, better IDE support
Database
PostgreSQL
Relational integrity, JSON support, proven reliability
MySQL
(Legacy projects) Mature, widely supported
AI
IBM watsonx
Enterprise-grade LLM, grounding-friendly, IBM Challenge platform
IBM Granite
13B parameter model, designed for business use
LangChain
Prompt management, retrieval chains, validation layers
Tools
Git/GitHub
Version control, collaboration, CI/CD
Docker
Containerization, environment consistency
Postman
API testing, documentation
What Else I've Built
TeamPilot AI is my flagship product. Here's proof I can build beyond one project.
TToô
CLIENT PROJECTE-Commerce Platform • Armenia
!Problem
Client needed an e-commerce platform in Armenia, but Stripe, PayPal, Apple Pay, and Google Pay don't operate there. No standard payment gateways were available for the region.
✓Solution
Integrated iDram, a local Armenian payment gateway, as a Stripe alternative. Built a complete e-commerce platform with product catalog, cart, order management, and admin panel.
⚙Technologies
★Impact
- •Deployed and actively used by paying client
- •Enabled online sales in region with limited payment options
- •Demonstrated ability to work with regional constraints and third-party APIs
TechShop
E-Commerce • PHP/MySQL
E-commerce platform with product catalog, cart, order management, and admin panel.
More on GitHub
Java desktop applications (Inventory Management, University Management), Bar à Jus (Django), and more projects demonstrating breadth across tech stacks.
View All RepositoriesIBM AI Builders Challenge 2026
TeamPilot AI was submitted to the IBM AI Builders Challenge 2026 (Wildcard track). This competition required integrating IBM watsonx and demonstrating AI applications that solve real business problems.
About the Builder
I'm Dieudo Tshibangu, the developer behind TeamPilot AI.
I built TeamPilot to demonstrate grounded AI — an AI assistant that cites real data instead of hallucinating answers. It was submitted to the IBM AI Builders Challenge 2026, where I competed in the Wildcard track.
I specialize in backend engineering (Django, FastAPI, Python), AI integration (IBM watsonx, LangChain), and full-stack development (React, Next.js, Tailwind). I've also built TToô, an e-commerce platform for a client in Armenia, where I integrated a local payment gateway (iDram) because Stripe and PayPal don't operate there.
I'm based in Burundi, fluent in French and English, and available for freelance work on Upwork and direct contracts.
Tech Journey
Hire the Builder
I build production-ready software — backend systems, AI integrations, and full-stack applications. Available for freelance work and direct contracts.
© 2026 Dieudo Tshibangu · Built with Next.js, TypeScript, and Tailwind CSS
This portfolio is open source on GitHub