Cognify Ops: How I Conceived an AI-Enhanced Project Management Tool

This idea was born from a real challenge I faced in my career. When I joined a software company as a software engineer, I encountered something that would fundamentally shape my thinking about knowledge management in software development.

The product I was tasked to work on, build, maintain, and support was a legacy application built over a decade ago. The scale was staggering—when you tried to expand a table in the database studio (an enterprise-grade tool), it would freeze momentarily just from the sheer volume of tables and relationships. The same happened with procedures and views.

Here's where it gets interesting: the original founder had sold the company, and due to staff turnover, none of the original creators remained when I arrived. For me and my teammates—all new hires—this application was essentially a black box. We were flying blind

Understanding the domain was incredibly challenging and inefficient. While I eventually grasped it through extreme dedication and hard work, helping my teammates—fresh graduates straight out of college—presented another layer of complexity. Having worked in the Drug Discovery Industry as a fresher myself, I understood how overwhelming it can be to tackle both a complex tech stack and a difficult domain simultaneously.

I wanted to make life easier for new developers so they could focus on learning one thing at a time: first the technology stack, then gradually understanding the business requirements.

Around this time, I was exploring Generative AI as a hobby project. I dove deep into understanding how models are trained, what RAG (Retrieval-Augmented Generation) is, how vectors work, and what vector databases can do. As someone who learns deeply rather than skimming the surface, I spent considerable time understanding vectors from the ground up. (Check out my blog posts on vectors if you're curious about this journey.)

I've always had an appreciation for Jira and the Agile process—I know many developers consider it a time-waster, but I find value in structured project management. If I weren't a developer, I'd probably be drawn to project management.

My fascination with Gen AI platforms, particularly ChatGPT, played a crucial role. As someone who doesn't have naturally strong reading comprehension and needs to examine concepts from multiple angles with examples, I used to require 10-15 resources to fully grasp a concept. With Gen AI, I can now feed 3-4 resources into GPT, Claude, Gemini, or Perplexity and ask targeted questions about exactly what I don't understand. This has accelerated my learning tremendously over the past three years.

The breakthrough came when I realized that Jira (or similar tools like ClickUp or GitHub Issues) already contains rich documentation of our work—descriptions, discussions, decisions, and solutions. What if we could combine the structured documentation of project management tools with the conversational intelligence of ChatGPT?

This led to the concept of Cognify Ops: an AI-enhanced project management tool that automatically builds a knowledge base from project documentation. Instead of losing institutional knowledge when team members leave, we create a system where:

• Every task, decision, and solution becomes training data
• New team members can have conversations with the project's knowledge base
• Legacy applications don't become black boxes
• Domain knowledge is preserved and accessible

This is how a real-world problem, combined with curiosity about emerging technologies and a passion for making developers' lives easier, led to the conception of Cognify Ops.

Note: This is just a proof of concept and a side project.

https://dzzb1r47lczqe.cloudfront.net/

1. Scalable Embedding Pipeline

Challenge: Generating embeddings synchronously would drastically increase response times and create fault-tolerance issues.

Solution: Implemented an asynchronous embedding pipeline using Azure Service Bus:

User Action → REST API → Database Update → Message Queue → Embedding Service → Vector Storage

• Decoupled Architecture: Embedding service runs independently of main API
• Fault Tolerance: Failed embeddings don't block user operations
• Scalability: Can handle multiple embedding requests concurrently

2. Intelligent Text Chunking Strategy

Challenge: OpenAI embedding models have token limits, and proper context chunking is crucial for accurate knowledge retrieval.

Implementation:

• Analyzed content structure to determine optimal chunk sizes
• Implemented overlapping chunks to maintain context continuity
• Balanced chunk size vs. context quality for optimal performance

3. Vector-Based Knowledge Retrieval

Architecture:

User Query → Vector Embedding → Cosine Similarity Search → Context Retrieval → LLM Response

Query Process:

1. Project Scoping: Filter embeddings by project_id for relevant context
2. Semantic Search: Use pgvector's cosine similarity for matching
3. Context Ranking: Retrieve top-k most relevant content chunks
4. LLM Integration: Pass retrieved context to OpenAI for response generation pgvector Advantages:

• Native SQL Queries: Vector operations using familiar SQL syntax
• Performance: Optimized indexing with IVFFlat for fast similarity searches
• Integration: Seamless integration with existing PostgreSQL infrastructure

4. Database Architecture: Traditional + Vector Storage

Challenge: Needed to store both traditional project management data and vector embeddings efficiently.

Solution: Implemented a dual-table architecture using Supabase PostgreSQL:

Traditional Data Storage:

• Standard PostgreSQL tables for projects, tasks, users, comments, and all project management data

• Prisma ORM for type-safe database operations

• Relational structure maintaining data integrity Vector Storage with pgvector:

• Separate dedicated table specifically for storing embeddings

• pgvector extension enabled vector operations within PostgreSQL

• Each embedding record linked to source content via foreign keys