A todo application that evolved from a Python console script into a production-grade, event-driven microservices platform — featuring an AI chatbot with MCP integration, bilingual Urdu/English support, voice commands, and Kubernetes deployment on Oracle Cloud. Perfect hackathon score: 1,600/1,600.
The Panaversity / PIAIC / GIAIC Hackathon II challenged participants to demonstrate how the role of a software engineer is shifting — from writing boilerplate code to becoming a System Architect who uses AI agents to build complex systems from structured specifications.
Every line of code had to be generated by Claude Code from a validated specification. The process, prompts, and spec iterations were all part of the evaluation.
The project had to evolve through five stages — from a simple console app to a full cloud-native microservices platform. Each phase built on the previous and could not be skipped.
The system had to include a functional AI chatbot with Model Context Protocol (MCP) tool integration — allowing users to manage tasks through natural language.
The final system had to run on Kubernetes with real cloud deployment on Oracle Cloud (OKE) — not just a local development environment.
TaskFlow was built in five strictly progressive phases over 12 weeks, each introducing a new architectural layer on top of the previous.
A Python command-line tool with in-memory task management — add, list, complete, and delete. No persistence, no auth. The foundation for all data structure and validation decisions that would recur at scale.
FastAPI backend with PostgreSQL (Neon serverless), JWT authentication, and RESTful CRUD. Next.js 16 frontend with React 19, TypeScript, and Tailwind CSS 4. User isolation — every user sees only their own tasks.
OpenAI Agents SDK with Model Context Protocol — five tools (add, list, complete, delete, update task) exposed to the AI agent. Users can now manage tasks entirely in natural language. The agent always calls list_tasks first for fuzzy matching — "dentist" resolves to "Dentist appointment Friday."
Multi-stage Dockerfiles for backend and frontend. Kubernetes manifests for Deployments, Services, ConfigMaps, and Secrets. Helm charts for templated, environment-aware deployment. Local cluster on Minikube with kubectl port-forwarding.
Monolithic backend decomposed into three independent microservices: Chat API, Notification Service, and Recurring Task Service. Apache Kafka (via Strimzi) as the event backbone. Dapr as the infrastructure abstraction layer — services never talk to Kafka directly. Deployed on Oracle Cloud OKE (Always Free tier).
The final system consists of three independent microservices, a Next.js frontend, Apache Kafka managed by the Strimzi operator, Dapr as the infrastructure abstraction layer, and PostgreSQL — all orchestrated on Kubernetes.
┌─────────────────────────────────────────────────────────┐
│ FRONTEND (Next.js 16 · port 3000) │
│ Home · Login · Signup · Tasks · Chat · Monitoring │
│ React 19 · TypeScript · Tailwind CSS 4 │
└────────────────────────┬────────────────────────────────┘
│ REST API calls (JWT Bearer)
┌────────────────────────▼────────────────────────────────┐
│ CHAT API — FastAPI (port 8000) │
│ Auth · Task CRUD · AI Chatbot · MCP Tools │
│ Publishes events → Dapr Sidecar (port 3500) │
└────────┬──────────────────────────┬─────────────────────┘
│ │
┌────────▼────────┐ ┌──────────▼──────────────────┐
│ PostgreSQL │ │ Dapr Sidecar (port 3500) │
│ Neon Serverless│ │ HTTP → Kafka abstraction │
│ Tasks · Users │ │ Pub/Sub · Jobs · Invoke │
│ Conversations │ └──────────┬──────────────────┘
└─────────────────┘ │
┌──────────▼──────────────────┐
│ Apache Kafka (port 9092) │
│ Strimzi Operator · KRaft │
│ topic: task-events │
│ topic: reminders │
└──────┬──────────┬────────────┘
│ │
┌────────────────▼──┐ ┌────▼──────────────────┐
│ Notification Svc │ │ Recurring Task Svc │
│ (port 8001) │ │ (port 8002) │
│ Reminders · Dapr │ │ Daily/Weekly/Monthly │
│ Jobs Scheduler │ │ Auto-recreates tasks │
└───────────────────┘ └───────────────────────┘
| Component | Port | Purpose |
|---|---|---|
| Frontend | 3000 | Next.js web application |
| Chat API | 8000 | Main backend — auth, tasks, AI chatbot |
| Notification Service | 8001 | Task reminders via Dapr Jobs |
| Recurring Task Service | 8002 | Auto-recreates daily/weekly/monthly tasks |
| Dapr Sidecar | 3500 | Infrastructure abstraction layer |
| Kafka Broker | 9092 | Event streaming backbone |
| PostgreSQL | 5432 | Persistent data store |
OpenAI Agents SDK (v0.6.5) with five MCP tools for full task management via natural language. Agent behavioral rules: always call list_tasks before updates, fuzzy match task names, chain multiple tool calls, respond in the user's language, parse natural language dates ("next Monday", "this weekend").
Every task CRUD operation publishes a Kafka event via Dapr — services never touch Kafka directly. Changing from Kafka to RabbitMQ or Redis Streams requires only a Dapr component YAML change — zero application code changes. Strimzi manages Kafka in KRaft mode (no ZooKeeper).
Full RTL rendering for Urdu messages using per-message Unicode range detection (U+0600–U+06FF). Noto Nastaliq Urdu font via Next.js next/font. A single conversation can mix English and Urdu freely — the AI agent detects language per message and responds in kind.
Frontend-only voice input using the browser's SpeechRecognition API — zero backend changes required. Supports English and Urdu voice recognition. Only the transcribed text (not audio) is sent to the backend. Gracefully hidden in Firefox where the API is unsupported.
Full Helm umbrella chart with sub-charts for each service. Two namespaces: todo-app and kafka. Deployed on Oracle Cloud OKE (Always Free tier) using ARM64 nodes. Cloud-agnostic by design — deployable on AKS, GKE, or any Kubernetes cluster without code changes.
No manual code written. All implementation generated by Claude Code from validated specifications using Spec-Kit Plus. Every code file contains a comment linking it to its Task ID and Spec section. The constitution enforces: Dapr-first, event-driven CRUD, test-first, cloud-agnostic design — non-negotiable throughout all phases.
The hackathon awarded points across five base phases and four bonus categories. TaskFlow achieved the maximum score in every single category.
| Phase / Bonus | Max Points | Earned |
|---|---|---|
| Phase I — Console App | 100 | 100 |
| Phase II — Full-Stack Web App | 150 | 150 |
| Phase III — AI Chatbot | 200 | 200 |
| Phase IV — Kubernetes Deployment | 250 | 250 |
| Phase V — Cloud Deployment | 300 | 300 |
| Bonus — Reusable Intelligence (Claude Code Skills) | +200 | +200 |
| Bonus — Cloud-Native Blueprints via Agent Skills | +200 | +200 |
| Bonus — Multi-language Support (Urdu) | +100 | +100 |
| Bonus — Voice Commands | +200 | +200 |
| Grand Total | 1,600 | 1,600 |
--platform build flags ensured images ran correctly across both architectures without code changes.
dapr.io/enabled: "true" and dapr.io/app-id had to be set on every Deployment spec. Pod startup ordering required readiness probes to ensure Dapr was ready before application containers started receiving traffic.
@import caused build errors in Next.js 16. Fixed by using the next/font system with localFont — loading the font file directly as a static asset instead of via CSS import.
Writing specs before code is not overhead — it is the work. SDD produces systems that are auditable, reproducible, and free from scope creep by design.
Abstracting Kafka behind Dapr means the entire event-driven system could switch to a different message broker by changing one YAML file. Architecture flexibility at near-zero cost.
Model Context Protocol gives the AI agent a clean, structured interface to application data. The agent calls tools with typed parameters and gets typed results — no prompt engineering for data extraction.
Building phase by phase forces early decisions to be validated before adding complexity. The monolith that runs correctly is the foundation for the microservices that scale correctly.
Separating Kafka into its own namespace allowed the Strimzi operator to be upgraded independently of the application. Operational boundaries at the namespace level prevent upgrade coupling.
The five Claude Code skills created as bonus deliverables are now loadable into any new project — the OKE deployment blueprint, Helm chart pattern, and chatbot frontend/backend skills are production-ready starting points.
We build cloud-native AI applications with microservices, intelligent chatbots, and production-grade Kubernetes deployments.