DEV Community: Nimash Mendis

I Got Tired of Filling Out Expense Forms… So I Built an AI That Does It for Me

Nimash Mendis — Mon, 03 Aug 2026 13:23:18 +0000

Building Aurefi — a privacy-first personal finance app where adding a transaction is as easy as sending a text message.

Every time I downloaded a budgeting app, the story was the same.

Week one?

I tracked everything.

Coffee.

Groceries.

Fuel.

Subscriptions.

Then life got busy.

A week later, I completely stopped using it.

Not because budgeting wasn't useful.

Because logging every single expense felt like filling out a tiny tax form.

Open the app.

Tap Add Transaction.

Choose Expense.

Choose a Category.

Enter the Amount.

Pick the Date.

Type a Description.

Save.

Repeat.

After doing that fifty times, budgeting becomes the chore instead of the solution.

That's when I asked myself one question.

Why can't adding a transaction be as easy as sending a text message?

That idea eventually became Aurefi.

The Goal

I didn't want to build another finance app.

There are already hundreds of them.

Some connect directly to your bank.

Some automatically categorize everything.

Some are packed with features you'll probably never use.

Instead, I wanted to solve one problem:

Make tracking money so easy that people actually keep doing it.

Everything else was built around that idea.

Meet Aurefi

Aurefi is a privacy-first personal finance application that combines AI with simple budgeting.

Instead of filling out forms, you can simply type something like:

Paid $24.50 for groceries at Walmart this morning.

Received my monthly salary of $2,500.

The AI understands what you meant and prepares the transaction for you.

It automatically identifies:

Expense or Income
Amount
Merchant
Category
Date
Description
Financial diary note

Nothing is automatically saved.

The AI simply prepares everything.

You review it.

You stay in control.

My Favorite Feature: AI Quick Add

This is the feature I'm most proud of.

I wanted adding an expense to feel as natural as sending a message to a friend.

Instead of tapping through multiple screens, you simply write what happened.

For example:

Dinner with friends cost $38 yesterday.

The AI fills the transaction form in seconds.

Even better...

It only suggests categories that already exist in your own budget.

It doesn't invent random categories.

It works with your existing data.

That tiny detail made the experience feel much smarter.

You Can Even Talk to It

Typing is already faster than traditional finance apps.

But sometimes you're walking.

Driving.

Shopping.

Or simply don't feel like typing.

So I added voice input.

Tap the microphone.

Say:

"Paid twenty dollars for lunch."

Your browser converts speech into text.

The AI parses it exactly the same way.

The form fills automatically.

On mobile, it feels surprisingly natural.

AI That Helps Before You Spend

Recording expenses is useful.

But I kept wondering...

Wouldn't it be better if AI could help before the purchase happens?

That's how the AI Money Simulator was born.

Imagine typing:

I'm thinking about buying a laptop for $1,999.

Instead of recording an expense, Aurefi estimates things like:

Monthly financial impact
Yearly financial impact
How it affects your savings goals
Alternative suggestions generated by AI

Sometimes seeing the future cost of a purchase changes your decision entirely.

That became one of my favorite features while building the app.

Building It

Under the hood, the workflow is fairly straightforward.

When the user enters natural language, the client sends:

The text
User currency
Existing categories

to a serverless API.

The API uses Groq's Llama 3.3 70B Versatile model to convert the sentence into structured JSON.

The response is validated before anything reaches the UI.

Amounts are checked.

Categories are matched.

Dates are normalized.

Only then is the transaction form populated.

One lesson I learned quickly:

Never trust AI output directly.

Always validate everything.

AI should speed up workflows—not introduce unpredictable data.

Privacy Wasn't Just a Feature

Finance apps deal with some of the most personal information people have.

I wanted privacy to be part of the architecture—not just a marketing page.

Aurefi follows a privacy-first approach.

Financial records are encrypted before cloud storage and synchronization using modern browser cryptography (AES-256-GCM).

Anonymous users can start immediately without creating an account.

There are:

No advertisements
No data selling
No invasive third-party tracking

My goal wasn't just to build another budgeting tool.

It was to build one people could actually trust.

Tech Stack

Here's what powers Aurefi.

Layer	Technology
Framework	Next.js 16
UI	React 19
Styling	Tailwind CSS v4
Database	Neon PostgreSQL
ORM	Drizzle
Authentication	Auth.js
AI	Groq (Llama 3.3 70B Versatile)
Charts	Recharts
Encryption	Web Crypto API (AES-256-GCM)
Payments	Lemon Squeezy

Building a Finance Dashboard That Actually Helps People Understand Money

One of the biggest challenges wasn't building charts or displaying numbers.

It was deciding which information actually matters.

A lot of finance apps show users endless tables, transactions, and statistics. But having more data doesn't always mean having more understanding.

For Aurefi, I wanted the analytics dashboard to answer simple questions:

Where is my money going?
How much am I earning compared to spending?
Which categories take most of my budget?
How are my financial patterns changing over time?

The dashboard became a visual summary of a user's financial life.

It includes:

Income and expense summaries to quickly understand the overall picture.
Monthly trends to see how finances change over time.
Spending by category to identify where money is going.
Income source tracking to understand earning patterns.
Category breakdowns to discover spending habits.

The hardest part wasn't creating the charts.

It was designing an experience where users can look at their finances for a few seconds and immediately understand what is happening.

Every card, chart, and metric has one purpose:

Turn complicated financial data into simple decisions.

Building this taught me that good dashboards are not about showing more information.

They're about showing the right information at the right time.

What I Learned

Building Aurefi taught me a few lessons.

People don't hate budgeting.

They hate logging transactions.

AI works best when it removes friction.

It shouldn't replace the user's decisions.

It should eliminate repetitive work.

Privacy starts with architecture.

If your system requires reading everyone's financial history, it probably isn't privacy-first.

Simple experiences are incredibly difficult to build.

The less work users have to do, the more work developers usually have to do behind the scenes.

What's Next?

I'm continuing to improve Aurefi based on feedback from real users.

Some of the best ideas have actually come from Reddit and developer communities.

The product today is very different from what I launched because people kept suggesting improvements I hadn't considered.

That's honestly one of my favorite parts of building in public.

I'd Love Your Feedback

Whether you're a developer, designer, finance enthusiast, or someone who's given up on budgeting apps before, I'd genuinely love to hear what you think.

You can try Aurefi here:

👉 https://www.aurefi.xyz

No credit card.

No ads.

You can start immediately.

If you have suggestions, feature ideas, or criticism, leave a comment below.

I read every single one, and there's a good chance your feedback will shape the next update.

Get in Touch

I'm always interested in hearing feedback, discussing ideas, or connecting with other developers and builders.

If you try Aurefi, have suggestions for new features, or simply want to chat about AI, web development, or building SaaS products, feel free to reach out.

🌐 Aurefi: https://www.aurefi.xyz

📧 Email: nimashmendis.dev@gmail.com

You can also leave a comment below—I read every one and often build features based on community feedback.

Thanks for taking the time to read my story. Happy coding! 🚀

What if travel preparation was one place instead of 20 browser tabs?

Nimash Mendis — Tue, 28 Jul 2026 11:58:00 +0000

I have a bad habit when planning international travel.

I open one tab.

Then another.

Before I know it, I'm looking at an embassy website, an airport guide, a Reddit thread, a SIM provider, a hotel site, a packing list, a currency converter, a random travel blog from 2022, and somehow a YouTube video that has nothing to do with the original question.

And I'm still not sure if I've forgotten something.

The funny thing is that booking a trip has become incredibly easy.

Preparing for one is still surprisingly fragmented.

That's where the idea for Tripora came from.

Not another itinerary planner.

Not another "10 best places to visit" website.

Something more like:

I'm going to this country. What do I need to know before I go?

The first version was much smaller

The original idea was basically a checklist.

You enter:

From: Sri Lanka
To: Belarus
Purpose: Study
Duration: 1 year

And instead of searching for everything separately, you get one place containing the things that actually matter.

Visa.

Documents.

Airport.

Accommodation.

SIM.

Transport.

Packing.

Money.

Arrival.

The more I thought about it, the more I realised that a simple checklist wasn't enough.

A person going to Belarus for university needs completely different information from someone spending 10 days in Thailand.

So the system needed to understand the trip, not just the destination.

That became the foundation.

A trip isn't just a destination

The same country can mean completely different preparation depending on who's travelling.

For example:

Sri Lanka
    ↓
Germany
    ↓
Student
    ↓
Long-term

is completely different from:

Sri Lanka
    ↓
Germany
    ↓
Tourist
    ↓
10 days

So Tripora starts by asking a few things:

Where are you travelling from?
Where are you going?
What's your nationality?
Why are you going?
When are you going?
How long are you staying?

Those inputs become the trip profile.

Then the system uses that profile to decide what information is relevant.

197 countries later...

This is where the project got slightly out of hand.

The current database covers 197 countries.

And each country isn't just a name and a description.

There can be information about:

Visa requirements
Processing times
Required documents
Airports
Airport transfers
Transport
SIM/eSIM providers
Accommodation
Costs
Safety
Emergency contacts
Local etiquette
Language
Currency
Useful official links
Arrival information
Packing rules

At some point I stopped thinking of it as a collection of country pages.

It's more like a travel knowledge base.

The interesting engineering problem wasn't the UI

The UI was actually the easy part.

The harder question was:

How do you structure travel information so that it can work across thousands of different trip combinations?

I didn't want this:

if Japan:
    show Japan stuff

if Germany:
    show Germany stuff

if Australia:
    show Australia stuff

That would become painful very quickly.

Instead, the data is separated into different concepts.

Something roughly like:

Country
 ├── Airports
 ├── Visa Requirements
 ├── Transport
 ├── Accommodation
 ├── Internet Providers
 ├── Emergency Contacts
 ├── Arrival Information
 ├── Useful Links
 └── Packing Rules

Then a trip is another layer:

Trip
 ├── Origin
 ├── Destination
 ├── Nationality
 ├── Purpose
 ├── Dates
 └── Duration

And the application combines those things.

So:

Trip Profile
      ↓
Destination Data
      ↓
Relevant Rules
      ↓
Preparation Plan

That's what allows the same system to work for both a short holiday and a year-long move.

Visa information was where things got serious

Travel information is one thing.

Visa information is another.

It's the kind of information where being "mostly correct" isn't good enough.

I didn't want to create pages saying:

"You might need a visa. Check the embassy."

That's technically safe, but not particularly useful.

The system can instead organise information around the traveller's nationality and destination.

Where available, information can include:

Visa type
Processing time
Fees
Required documents
Application information
Official sources
Verification date

And important information is associated with a source.

For example:

Visa requirement

Source:
Official government website

Last verified:
July 2026

That last field matters.

Because a database entry shouldn't quietly become "truth forever".

Visa rules change.

Fees change.

Processing times change.

So one of the principles behind the project is:

If information can change, it should have a source and a verification date.

And for anything involving immigration or entry requirements, the official authority remains the final source of truth.

Then came the Visa Timeline

Knowing:

"Processing takes approximately 30 days"

is useful.

But it's still not quite the same as:

"What should I be doing 90 days before my flight?"

So the visa information became a timeline.

Something like:

T-90
Check requirements

T-75
Gather documents

T-60
Apply

T-30
Check application progress

T-14
Review travel documents

T-7
Final checks

The actual dates depend on the information available for the destination and nationality.

The point isn't to predict the future.

It's to turn a static requirement into an actionable sequence.

Packing turned out to be its own little system

I also didn't want a packing list that just says:

Passport
Toothbrush
Clothes
Charger

because that's technically a packing list for literally every trip ever.

Packing depends on context.

A winter trip to Japan is different from a summer trip to Thailand.

Moving abroad for university is different from a five-day holiday.

So Tripora currently has:

72 packing items

and

74 country-specific rules

The rules can take into account things such as:

Destination
Trip type
Duration
Climate
Country-specific considerations

The result is a checklist that changes with the trip.

And then you can actually tick everything off.

Simple feature, but surprisingly useful.

The T-90 problem

There's another problem with checklists.

A list of 30 things doesn't tell you when to do them.

So there is also a pre-trip timeline.

Instead of:

☐ Visa
☐ Accommodation
☐ Packing
☐ SIM
☐ Documents
☐ Insurance

you get something closer to:

90+ days
Visa research
Important documents

60 days
Visa application
Accommodation

30 days
Travel arrangements
Insurance
SIM research

7 days
Packing
Document backup
Airport preparation

Departure day
Passport
Boarding pass
Money
Phone

The whole idea is to make the preparation feel less like a giant task dumped on you the night before.

The airport is part of the trip too

A flight booking tells you how to get there.

It doesn't necessarily tell you what happens when you arrive.

So destination information also covers things like:

Airport terminals
Getting into the city
Public transport
Taxi options
Wi-Fi
Currency exchange
Lounge information
Useful airport information

And then there's the arrival guide.

Because arriving somewhere you've never been before at 11 PM with no mobile data is a very different experience from looking at the same destination on Google Maps from your bedroom.

The SIM card problem

This is one of those tiny things that can completely ruin the first hour of a trip.

You arrive.

Your normal SIM doesn't work.

You don't know which local provider is good.

You don't know whether the airport sells SIMs.

You don't know whether you should use an eSIM.

So destination guides include:

Local providers
SIM availability
eSIM availability
Where to buy
Data plan information
Provider websites

Again, this is information that changes, so it needs to be maintained rather than treated as permanent.

What about the first few days?

For longer trips, especially study, work and moving abroad, the journey doesn't really end when you reach the hotel.

There are still things to figure out.

Where's the university?

Where do I get essentials?

How does local transport work?

What local formalities might I need to deal with?

Where can I get connected?

So there are also first-days and arrival guides.

The goal is basically:

Don't just help me get there. Help me know what happens next.

Comparing destinations

Then another use case appeared.

Sometimes you're not sure where you're going yet.

Maybe you're comparing:

Japan
South Korea
Thailand

or:

Germany
Netherlands
Australia

Instead of researching each destination separately, Tripora can compare things such as:

Visa requirements
Costs
Weather
Safety
General preparation
Requirements

It doesn't try to decide for you.

It just makes the research less painful.

There is also a human side to the data

Official websites are important.

But official websites don't tell you everything.

A government website can tell you the official visa process.

It usually can't tell you:

"I applied from the US and got my passport back in five days."

That's why Tripora also has Visa Timeline Reports.

Travellers can share their actual experiences.

There are also community posts and comments for destination-specific questions and tips.

The idea is to keep the two types of information separate:

Official information tells you the rules.

Community information tells you what someone's experience was like.

One shouldn't pretend to replace the other.

A few features that came naturally from the same idea

Once the core trip system existed, a few other things made sense:

Trip sharing

Share a complete trip plan with someone you're travelling with.

PDF export

Save the plan as a PDF for offline use.

PWA

Install Tripora on your phone and keep important information accessible while travelling.

Readiness score

Instead of staring at a huge checklist, see how prepared you are.

For example:

76% ready

3 important things remaining

The score is based on actual completed preparation tasks rather than being a random progress number.

The tech stack

The current stack is:

Next.js 16
TypeScript
Tailwind CSS
shadcn/ui
Supabase
PostgreSQL
Vercel
PWA / Service Worker

The application is server-rendered where it makes sense, with API routes handling data operations.

Supabase handles the PostgreSQL database and authentication.

Vercel handles deployment.

Nothing particularly exotic.

And honestly, I think that's a good thing.

The interesting part isn't using 25 technologies.

It's figuring out how to turn messy real-world information into something that is actually useful.

Why I didn't make it an AI chatbot

This was a deliberate decision.

It would be very easy to put a big box on the homepage saying:

"Ask AI anything about your trip."

But imagine asking:

"Do I need a visa?"

and getting a confidently wrong answer.

That's not something I wanted to build around.

So the current system is based more on:

Curated data
      +
Sources
      +
Rules
      +
Trip context
      ↓
Personalised preparation

rather than:

Question
   ↓
LLM
   ↓
Hopefully correct answer

AI could still become useful later.

But I'd rather have AI sit on top of verified information than have it become the source of truth.

There are still a lot of things I'd like to improve

Some of the next problems I'd like to tackle are:

Live flight information
Weather-based preparation
Better currency information
eSIM comparisons
More community reports
Document organisation
Notifications
Better offline functionality
More detailed country-to-country preparation
Native mobile apps
An AI assistant grounded in Tripora's own verified data
Daily update about each country

But I don't want to turn it into a giant feature list just for the sake of it.

The basic idea is still the same:

You shouldn't need to become a travel researcher just to travel somewhere.

There are already plenty of websites that help you decide where to go and what to do when you get there.

The less exciting — but arguably more important — part is everything you have to figure out before you leave.

That's the problem I'm interested in.

If you travel, I'm curious about something

What's the one thing you always end up searching for before an international trip?

Not necessarily something you think Tripora needs.

Just the thing that makes you think:

"Why is this information so damn difficult to find?"

That's the kind of problem I'm interested in solving next.

🌍 Tripora

Built a Modern ERP for Startups & Small Businesses Instead of Another To-Do App

Nimash Mendis — Fri, 24 Jul 2026 08:15:44 +0000

I Built a Modern ERP for Startups & Small Businesses Instead of Another To-Do App

How a simple idea evolved into a customizable business management platform—and why I believe small businesses deserve software that's powerful, modern, and actually affordable.

When developers build side projects, it's common to create another to-do app, weather app, or AI wrapper. There's nothing wrong with that—I built plenty of learning projects myself.

But at some point, I wanted to build something that could solve a real business problem.

That idea became Opero.

A modern, cloud-based business management platform designed for startups and small businesses that need more than spreadsheets—but don't want the complexity and cost of enterprise software.

The Problem I Kept Seeing

When talking to small business owners, I noticed the same challenges over and over again.

Customer information stored in Excel
Inventory tracked manually
Sales managed through WhatsApp
Purchase orders created in Word documents
Invoices scattered across multiple systems
No real-time visibility into the business

As companies grow, these small problems become expensive.

Employees waste time searching for information.

Stock runs out unexpectedly.

Reports take hours to prepare.

Owners don't have a clear picture of what's happening in the business.

Large ERP platforms like SAP or Microsoft Dynamics can solve many of these issues—but they're often too expensive or too complicated for smaller companies.

I wanted to build something different.

Introducing Opero

Opero is a modern ERP platform designed specifically for startups and growing businesses.

Instead of forcing companies to use five different applications, Opero centralizes everything into one platform.

Current modules include:

📊 Dashboard
👥 Customer Management
📦 Product Management
📦 Inventory Management
🏢 Supplier Management
🛒 Sales Orders
📋 Purchase Orders
💰 Invoices
📈 Reports & Analytics
🔔 Notification Center
👤 User Management
🔐 Role-Based Access Control

Everything works together as a single ecosystem.

My Favorite Feature: Smart Reorder Engine

Almost every inventory system has a Low Stock warning.

But here's the problem.

When you see:

Low Stock

it's often already too late.

You should have reordered days earlier.

Instead of another low-stock alert, I built something smarter.

Smart Reorder Engine

The system analyzes:

Historical sales
Daily sales velocity
Current inventory
Supplier lead times

Then predicts:

"This product will run out in approximately 12 days."

Even better, it automatically prepares a purchase order draft that the business owner simply reviews and approves.

Instead of reacting to problems, businesses can prevent them before they happen.

For small businesses without dedicated inventory managers, this feature can save hours every week while reducing both overstocking and stock shortages.

Calculating Stock-Out Predictions

One of the core ideas behind the Smart Reorder Engine is predicting when inventory will run out instead of simply checking if it's has reached a minimum quantity.

const dailySales = salesLast90Days / 90;

const daysUntilStockout =
  Math.floor(currentStock / Math.max(dailySales, 0.1));

const reorderNow =
  daysUntilStockout <= supplierLeadTimeDays;

return {
  daysUntilStockout,
  reorderNow,
};

Instead of displaying:

Low Stock

Opero displays something much more useful:

"Wireless Mouse will run out in approximately 12 days."

Modern Architecture

I wanted Opero to be scalable from day one.

Here's the technology stack I chose.

Frontend

React 19
TypeScript
Vite
Tailwind CSS
React Router
Recharts
Lucide Icons

Backend

Node.js
Express.js
TypeScript
Zod Validation

Database

PostgreSQL
Supabase

Deployment

Frontend → Vercel
Backend → Railway
Database → Supabase

Building for Scale

Rather than placing all logic inside controllers, I followed a clean architecture.

flowchart TD
    A[Controller] --> B[Service]
    B --> C[Repository]
    C --> D[(PostgreSQL)]

This keeps business logic separate from routing and database access, making the application much easier to maintain as it grows.

The platform also includes:

Multi-tenancy
UUID-based entities
Soft deletes
Organization isolation
Role-Based Access Control
Protected frontend routes
Modular API structure
Comprehensive validation
Secure authentication

Repository Pattern

Instead of writing SQL inside controllers, every module follows the Repository Pattern.

class ProductRepository {
  async findById(id: string) {
    return db
      .select()
      .from(products)
      .where(eq(products.id, id))
      .limit(1);
  }
}

This separation keeps controllers lightweight and makes testing significantly easier.

Multi-Tenant by Design

Every query is automatically scoped to an organization.

const products = await db
  .select()
  .from(productsTable)
  .where(
    eq(productsTable.organizationId, organizationId)
  );

This allows multiple companies to use the same application while ensuring every organization only sees its own data.

Role-Based Access Control

Every page and action is protected using permissions.

export function hasPermission(
  user: User,
  permission: Permission
) {
  return user.permissions.includes(permission);
}

if (!hasPermission(user, "products.create")) {
  throw new Error("Unauthorized");
}

Opero currently supports five roles:

Owner
Admin
Manager
Employee
Viewer

Request Validation

Every API request is validated before reaching the business logic.

const CreateProductSchema = z.object({
  name: z.string().min(2),
  sku: z.string(),
  price: z.number().positive(),
  stock: z.number().nonnegative(),
});

Using Zod significantly reduces invalid requests while keeping API responses predictable.

One Platform, Multiple Industries

While developing Opero, I realized something interesting.

The core architecture wasn't limited to inventory management.

It could be adapted to completely different industries simply by changing the workflow.

That's how Opero Agency was born.

Instead of products and inventory, Opero Agency manages:

Candidates
Employers
Deployments
Document Tracking
Visa Status
Service Fees
Compliance

Although the interface is different, both platforms share the same architecture and backend philosophy.

This means new industry-specific solutions can be developed much faster while sharing a proven foundation.

Lessons I Learned

Building Opero taught me much more than writing code.

Software Should Solve Business Problems

The most valuable feature isn't always the most technically impressive.

Sometimes the biggest improvement is eliminating repetitive manual work.

Architecture Matters

As projects grow, structure becomes more important than speed.

Investing time in clean architecture early made adding new modules significantly easier later.

User Feedback Is Everything

Many features I initially considered important changed after talking to business owners.

Listening to users completely reshaped my roadmap.

Shipping Beats Perfection

No software is ever finished.

Instead of waiting until everything was perfect, I focused on shipping improvements continuously.

That approach has helped Opero evolve much faster.

What's Next?

Opero is still actively evolving.

Some of the upcoming features include:

Workflow Automation
Email Notifications
Better Reporting
API Integrations
Mobile Optimization
Additional Industry Modules
AI-Assisted Business Insights
Customer Portals

The long-term vision isn't simply to build another ERP.

It's to create a platform that businesses can customize around their own workflows.

Looking for Early Users

Opero is currently available for early testing.

I'm looking for:

Startup founders
Small business owners
Developers
Operations managers
Anyone interested in modern business software

Your feedback will directly influence the future direction of the platform.

Live Demo

🚀 Opero ERP

Live Demo

https://opero-orcin.vercel.app/

Demo Credentials

Email

demo2@opero.com

Password

Demo1234!

🌍 Opero Agency

Live Demo

https://opero-agency-sys.vercel.app/

Demo Credentials

Email

admin@operoagency.com

Password

Demo1234!

Let's Connect

If you're building a startup, running a business, or simply interested in ERP systems, I'd love to hear your thoughts.

I'm always open to feedback, feature suggestions, and discussions about business software.

If your company needs a custom web-based management system, ERP solution, workflow automation, or a completely tailored business platform, feel free to reach out. My goal is to build software around real business workflows instead of forcing businesses to adapt to generic tools.

About Me

I'm Nimash Mendis, a Full-Stack Software Engineer and a BSc in ICT undergraduate at Sukhoi State Technical University (Belarus).

I'm passionate about building scalable SaaS products and modern business software that help companies simplify operations and grow efficiently.

📧 Email: nimashmendis.dev@gmail.com

🌐 Portfolio: https://www.nimashmendis.xyz

Thanks for Reading! 🚀

If you have any suggestions, feature ideas, or constructive feedback, I'd genuinely love to hear them.

Every conversation helps make Opero better.

⭐ If you'd like to support the project, try the live demo, share your feedback, or get in touch if you're interested in implementing Opero or building a custom business system for your company.