AI Engineer Projects in DelhiAI Engineer Projects in DelhiThe project focuses on automating vehicle insurance certificate workflows using a scalable microservices architecture. The solution streamlines insurance certificate processing by reducing manual intervention, improving data handling, and enabling seamless communication between services through APIs and system integrations.
The architecture is designed to support efficient workflow execution, reliable data exchange, and scalability as transaction volumes increase. By modernizing insurance operations, the solution helps create a more consistent, maintainable, and efficient process for managing vehicle insurance certificates.
Business Impact
1. Increased Operational Efficiency: Reduced repetitive manual tasks and streamlined certificate processing workflows.
2. Faster Processing: Improved workflow execution to support quicker handling of insurance certificate requests.
3. Scalability: Enabled independent services to scale as business demand and transaction volumes grow.
4. Improved Reliability: Supported better service isolation and maintainability through a modular microservices architecture.
5. Reduced Operational Overhead: Helped minimize manual effort and workflow complexity.
6. Enhanced Integration: Enabled smoother communication between systems through APIs and service-to-service interactions.
7. Business Growth Readiness: Established a flexible foundation for future automation, integrations, and enhancements.
Overall Outcome
The project demonstrates how workflow automation and scalable microservices can modernize vehicle insurance operations, improve process efficiency, and provide a flexible technical foundation for future business growth. Hit a classic Django trap this week and figured it's worth sharing since so many people are running into it now.
I was adding an LLM feature to a Django app. The AI call takes a few seconds, so naturally I made the view async so it doesn't block a worker while waiting. Wrote the async view, called the ORM like I always do, and boom:
SynchronousOnlyOperation: You cannot call this from an async context.
Turns out Django's ORM can't just be called normally inside async code. The classic sync API isn't safe in an event loop, so Django protects it and throws this error instead.
The fix is simpler than most people think. Since Django 4.1 the ORM has async versions of everything, same names with an "a" prefix. So objects.get() becomes await objects.aget(), create() becomes acreate(), save() becomes asave(). For loops over querysets, async for works directly. And for old sync code or third party libraries you can't change, wrap them with sync_to_async().
Why this matters right now: everyone is bolting AI features onto Django apps, and LLM calls are exactly the slow I/O that async is made for. Which means a lot of devs who never touched async Django are suddenly hitting this error for the first time.
One honest caveat: transactions still don't fully work in async mode, so if you need atomic blocks, keep that path sync and wrap it.
Anyone else made the jump to async views yet, or still happily on WSGI? Problem:
Many organizations still process invoices manually by reading PDF documents and entering key details (invoice number, vendor, amount, etc.) into systems. This process is slow, error-prone, and difficult to scale, and it also makes it harder to detect duplicate invoices or incorrect totals.
Solution:
This project builds an automated invoice processing pipeline that converts uploaded invoice PDFs into structured data. It uses OCR to extract text, LLMs to identify invoice fields, validation checks to ensure correctness, and Kafka-based event streaming to manage the processing pipeline. The extracted data is stored in PostgreSQL and visualized through a dashboard, enabling faster, scalable, and more reliable invoice processing. 
