Building Settla: An AI-Powered Payment & Settlement Automation Platform

This is a submission for the MLH x DEV Writing Challenge

What I Built

For the Paytm AI Hackathon, I built Settla, an AI-powered payment and settlement automation platform designed to simplify payment operations, refunds, vendor management, and workflow automation.

The idea came from a simple observation: payment operations can become complicated when you have to deal with multiple transactions, vendors, refunds, and settlement processes manually.

I wanted to build something where AI wasn't just used as a chatbot, but could actually become part of the workflow.

That's where Settla came in.

The goal was to create a platform where users could interact with payment operations through an intelligent interface while the underlying system handled the actual business logic, integrations, and automation.

The Architecture

I built Settla as a full-stack application with an architecture focused on automation and extensibility.

The overall workflow looks like this:

User
  ↓
Settla Frontend
  ↓
Backend API
  ↓
AI / MCP Layer
  ↓
Payment Services
  ↓
n8n Automation
  ↓
Settlement / Refund Workflow

The backend handles the core application logic, while the automation layer is designed to connect different services and execute workflows.

I also focused heavily on testing during development.

The project currently includes:

• 135 backend tests
• 9 frontend unit tests
• 13 browser E2E tests

This was important because payment-related workflows need predictable behavior. A small mistake in a payment or refund workflow can have much bigger consequences than a normal application bug.

What I Learned

One of my biggest takeaways from building Settla was that AI is only one part of an AI-powered product.

The difficult part is building everything around it.

You need:

• Reliable APIs
• Authentication and authorization
• Proper business logic
• Tool permissions
• Error handling
• Testing
• Workflow automation
• External service integrations
• Observability and maintainability

The AI becomes much more useful when it can safely interact with these systems.

That changed the way I think about AI applications.

Instead of:

"Let's add an AI chatbot."

I started thinking:

"What can the AI actually do inside the system?"

That's a much more interesting engineering problem.

Demo

I built Settla as a working full-stack application during the hackathon.

Project Links

GitHub: https://github.com/dev-shamsali/settla-frontend , https://github.com/dev-shamsali/settla-backend

Live Demo: https://settla.devcodehub.cloud/

Demo Flow

The intended Settla workflow is:

User Request
     ↓
AI Agent
     ↓
Tool / MCP
     ↓
Payment Operation
     ↓
Automation Workflow
     ↓
Settla Backend
     ↓
Result

The goal is to make complex payment operations easier to understand and automate instead of requiring users to manually perform every individual step.

Partner Technologies

One of the most interesting parts of building Settla was working with n8n and exploring Model Context Protocol (MCP).

n8n

I used n8n as the foundation for the automation layer.

Instead of putting every automation directly into the backend, n8n allows workflows to be composed visually and connected to different services.

For Settla, this opens up possibilities such as:

Payment Created
      ↓
Validate Transaction
      ↓
Process Workflow
      ↓
Update Settla
      ↓
Trigger Settlement
      ↓
Notify User

This makes the system easier to extend as more integrations are added.

MCP

I also explored Model Context Protocol to connect AI systems with external tools.

This was one of the most interesting technical parts of the project.

Instead of having an AI model simply generate text, MCP allows the AI layer to interact with tools that expose real application functionality.

Conceptually:

User
 ↓
AI
 ↓
MCP
 ↓
Tool
 ↓
External Service
 ↓
Result
 ↓
AI
 ↓
User

This approach made me think about AI agents differently.

The model doesn't need to know everything.

It needs access to the right tools, with the right permissions, and the application needs to enforce the business rules.

That separation between intelligence, tools, and business logic is something I found particularly valuable while building Settla.

Hackathon Experience

I participated in the Paytm AI Hackathon with Settla.

We didn't win this time.

Honestly, we weren't as prepared as we should have been.

But the experience was still extremely valuable.

The hackathon brought together developers, AI enthusiasts, builders, and people experimenting with completely different ideas.

I got the opportunity to discuss AI agents, payment systems, automation, MCP, architecture, and product ideas with other developers.

What I enjoyed most was the environment.

Everyone was trying to build something under a limited amount of time.

That creates a completely different development experience.

You have to constantly ask:

What should we build first?

What can we realistically finish?

What needs to be tested?

What should we leave for later?

And most importantly:

Can we actually demonstrate what we built?

That last question is something I learned the hard way.

Building the product is one thing.

Building it, testing it, preparing the demo, and presenting it effectively are completely different challenges.

What I'll Remember

I didn't leave the hackathon with a trophy.

I left with something else:

experience.

I learned more about building AI-powered systems, explored MCP and workflow automation, met developers and AI enthusiasts, discussed ideas with other builders, and understood where we need to improve for the next hackathon.

Most importantly, Settla gave me an opportunity to experiment with an idea that combines:

AI + Payments + MCP + Automation + Full-Stack Engineering

And that's something I'm proud of building.

Final Thoughts

Settla started as a hackathon project.

But while building it, it became much more than just an idea.

It became an experiment in how AI can interact with real systems instead of simply generating responses.

I didn't win the hackathon.

But I built something.

I tested it.

I learned from it.

I met great developers.

And I know exactly what I need to improve for the next one.

Sometimes the most valuable outcome of a hackathon isn't the prize.

It's knowing what you're capable of building next.

Built by Shams Ali Shaikh.