DEV Community: Keiler Guardo Herrera

How I Created Keppli Finance: An AI-Driven App That Transforms Personal Money

Keiler Guardo Herrera — Sat, 28 Jun 2025 02:19:00 +0000

Introduction

The lack of financial education has been a constant obstacle in my close circle. Growing up without a strong guide for managing money, I witnessed firsthand the consequences of not understanding basic personal finance concepts. It’s not just a personal observation: a recent report found 38% of surveyed individuals said their lack of financial literacy cost them at least $500 USD in 2022. 15% said it set them back $10,000 or more. Determined to change this reality, I channeled my software development experience into creating Keppli Finance, a mobile application designed to give users the tools and knowledge that so many of us have lacked. Incorporating artificial intelligence (AI) into the project emerged as a natural response to this challenge: why not leverage cutting-edge technology to help others (and myself) take control of our finances in an intelligent, secure way? That’s how Keppli Finance was born. It was conceived not just as an expense tracker, but as a personal financial advisor in your pocket, aimed at helping anyone improve their financial well-being in a transparent and user-friendly manner.

Technical Architecture

From the outset, I knew I needed a solid and scalable architecture. I chose Flutter for the frontend because of its multi-platform capability: with a single Dart codebase, I can deliver a native experience on both Android and iOS, speeding up development without sacrificing UI quality. Flutter excels in performance and has a growing community, and its “write once, run everywhere” promise fit perfectly with the need to iterate quickly on a mobile product. For the backend, I selected NestJS, leveraging my background in JavaScript/TypeScript and modern backend frameworks. Built on Node.js, NestJS provides a modular, robust structure to the project: its design pattern of controllers, modules, and providers made it possible to keep the code organized and maintainable as the application grew.

This combination of Flutter and NestJS allowed me to work with strongly-typed languages on both ends (Dart on the client, TypeScript on the server), and even to share some logic and data models between the frontend and backend, reducing errors and duplicated effort. In terms of infrastructure, the architecture follows a clear separation of concerns: Flutter handles the presentation and user interaction, while NestJS exposes a secure, efficient REST API that orchestrates business rules, data management, and integration with external services. Thanks to these technology choices, Keppli Finance enjoys a frontend that is both visually appealing and responsive, combined with a backend that is scalable and maintainable – a strong foundation upon which to build the app’s intelligent, AI-driven features.

AI-Powered Features

One of the pillars that differentiates Keppli Finance is the integration of AI-based features to simplify and empower the user’s financial management. From the start, I identified key areas where artificial intelligence could add value:

Automatic Expense Categorization

When logging a new expense, the app uses natural language processing to interpret the transaction’s description and amount, automatically assigning it an appropriate category (for example, “Food”, “Transportation”, or “Entertainment”). This automated classification removes the burden of manually tagging each transaction and it learns from the data over time to improve accuracy. In practice, this means if you note “Uber $20”, the app understands it as a transport expense and categorizes it accordingly. Behind the scenes, a machine learning model trained on common transaction descriptions and categories analyzes the text and other parameters of the entry. Based on linguistic and numerical patterns, the algorithm predicts the most likely category for each new expense. Thanks to this feature, Keppli Finance can give users a clear picture of where their money is going without requiring them to have advanced financial knowledge. Intelligent automation of categorization saves time and reduces human error; in fact, today’s AI algorithms are capable of categorizing transactions quickly and efficiently while minimizing errors a capability we have fully leveraged in the app.

Personalized Insights Generation

Recording expenses and setting budgets is only the beginning. The real added value of Keppli Finance comes from its AI-powered financial advisor, which analyzes a user’s financial habits to offer personalized tips and insights. Each week, the NestJS backend compiles the user’s spending, income, and savings data and feeds it into an AI engine that applies pattern recognition algorithms. For example, the AI might detect that your dining-out expenses increased by 20% this month compared to last, or that you are nearing (or exceeding) your leisure budget. Based on findings like these, the system generates natural-language recommendations that are easy to understand. These insights range from savings suggestions (“You spent more on takeout this month than usual; cooking at home a bit more could save you money”) to proactive alerts (“You’re 80% to your savings goal – keep it up!”). The goal is for the user to receive actionable information tailored to their situation – in essence, having a virtual financial coach. User feedback has been very positive: many feel that “it’s like having a financial expert giving clear recommendations” on how to optimize spending and improve savings Technically, this feature was achieved by integrating third-party AI models specialized in financial analysis and language generation, combined with our own business rules. The insights are delivered securely and privately, via in-app notifications and weekly summary emails.

Future Vision: Conversational Voice Interface

Looking ahead, one of the most exciting features on the Keppli Finance roadmap is the addition of a conversational voice interface. The idea is that users will be able to interact with their virtual financial advisor through voice commands or even natural dialogue – similar to assistants like Siri or Alexa, but focused on personal finance. Imagine being able to ask the app, “How much did I spend this week?” or give it instructions like “Log a $50 grocery expense”, and receive an immediate spoken response. This conversational approach, powered by AI, aims to remove usage barriers and make managing finances as easy as having a conversation. To achieve this, I plan to integrate voice recognition technologies and advanced natural language models that can interpret user intent and generate coherent responses. In fact, the current interface already hints at this direction – for example, an “Add expense with voice” button exists in an experimental form, backed by AI to understand spoken commands. The vision is that in upcoming iterations, Keppli Finance will evolve into a true voice-based financial assistant capable of maintaining a dialogue: explaining trends in your finances, answering questions (“How much did I save last month?”), and even giving encouragement or reminders (“Remember, you have a subscription payment due next week”). This future feature builds upon the rapid advances in conversational AIs; we are laying the groundwork to integrate it seamlessly once the technology is ready to deliver an optimal experience.

Agnostic Architecture

To support all these AI functionalities and integrations, it was essential to design a flexible and automated architecture. For this, I used an agnostic architecture approach, which allowed me to orchestrate the application and its automated flows efficiently.

This approach is based on principles and tools applied in Keppli Finance to make the platform as independent as possible from specific technology providers and AI models. In practice, this means we can connect to different AI services and external APIs without relying exclusively on any single one. This way, we can swap or add new models as needed without affecting the stability of the main system. For example, if tomorrow a more precise expense analysis service appears, the architecture will allow us to incorporate it with minimal changes.

Another key aspect was the automation of internal processes. Keppli Finance runs several background tasks automatically: from sending personalized weekly financial reports by email, to performing cloud backups and updating expense categories in real time. Many of these tasks are defined in an automation layer that significantly reduces operational load and minimizes human errors.

To implement this, I used NestJS modules and queues along with cloud services under the serverless paradigm, ensuring functions only run when truly needed. Regarding external integrations, we connect multiple AI models from different providers for features like categorization, insights generation, voice recognition, statistics, and other upcoming functionalities. The coordination between these models is transparent to the user. Thus, if any service fails or delays, the agnostic architecture allows switching to an alternative AI model or retrying the task, guaranteeing the end-user experience is not affected.

We also integrated complementary services like Resend for sending transactional emails and summary reports. Thanks to Resend’s API, Keppli Finance can reliably send weekly reports without needing to build an email infrastructure from scratch.

Next Steps

Developing Keppli Finance has been an exciting journey that combines a personal motivation with cutting-edge technical challenges. In hindsight, the lack of financial education that was once a disadvantage became the driving force to create a solution that now helps others make better financial decisions. Along the way, it reinforced my belief in the power of technology—especially AI—to democratize financial education and improve people’s daily lives. Every technology choice, was made with the goal of building a solid foundation upon which to keep innovating.

Looking ahead, Keppli Finance isn’t stopping here. I will continue iterating and learning from user feedback, refining the app experience and adding new features. The vision of a fully conversational voice interface, for example, comes closer to reality each day as conversational AI technologies mature. I also plan to integrate more data sources and to offer even smarter, more personalized insights as the platform grows.

I invite everyone reading this article to learn more about the project and follow its evolution. Maintaining a professional, transparent, and user-centered approach has been essential to the success of this initiative, and I will continue to uphold these values as Keppli Finance moves forward. While the journey of a developer building their own product as a side project comes with challenges, it also brings great satisfaction in seeing real-world problems solved through code. Keppli Finance is a reflection of my passion for creating useful solutions, and I’m excited for what’s to come. Thank you for joining me on this technological and personal journey, and I encourage you to stay tuned for the upcoming updates from Keppli Finance!

If you want to read more blogs, you can find them at keilerguardo.com.

From Cloud to Device: The Shift Toward a First Local Architecture

Keiler Guardo Herrera — Sat, 21 Jun 2025 17:20:22 +0000

Lately, I’ve started integrating the First Local approach into my applications—most notably in Keppli Finance, a personal finance app designed to help people manage their money more effectively. Through internal analysis using tools like Sentry, I noticed that several users were experiencing connectivity issues. Most of these cases were from people in rural areas or those relying on unstable mobile data connections. This brought to mind a conversation I had with my tech lead at the company I currently work for. We were discussing how the First Local development paradigm is becoming increasingly popular within the developer community, and how it can be used to significantly improve user experience, especially in contexts where internet access is unreliable. That conversation inspired me to write this article, where I’ll share some key concepts, benefits, and personal experiences applying this approach—both in Keppli Finance and other side projects. To get started, let’s briefly define what First Local actually means.

Introduction

In software development, the First Local approach—also known as local-first or offline-first is based on the idea that applications should manage and store data primarily on the user’s device, then synchronize it with the cloud whenever possible. In other words, the primary copy of the data lives locally—for example, in a database like SQLite—and the application doesn’t rely on a remote server to function continuously. Picture a collaborative document, for instance: instead of being hosted exclusively on a Google data center or any other provider, each user maintains a local copy on their device. They can make edits offline, and once they're back online, the changes are synced automatically. This paradigm aims to offer the best of both worlds: the benefits of the cloud—such as multi-device access and real-time collaboration—while always prioritizing the user’s local experience.

Why Is the “First Local” Approach Trending?

Several factors have fueled the recent rise of the First Local approach. First and foremost, user expectations have shifted: today, we use mobile apps in subways, on airplanes, or in areas with poor signal—and we expect them to work regardless of connectivity. An app that becomes useless without an internet connection creates a frustrating experience. As a Supabase blog points out, “the worst version of your app is the one that can’t be used”. That’s why developing with an offline-first mindset ensures that users can continue using the app even with unstable connections—dramatically improving satisfaction and reliability. There’s also a major added benefit: performance. Since apps don’t rely on a remote server for every interaction, First Local architectures provide ultra-low-latency experiences. Operations are executed directly against the device’s local database, removing network delays and creating a sense of instant response.

In a world where smartphones and laptops are increasingly powerful, it only makes sense to take advantage of that local hardware. On top of that, the First Local approach offers greater autonomy and can significantly reduce costs. By relying less on the cloud, infrastructure fees drop, and single points of failure are avoided. At the same time, users benefit from having more control over their data—it stays with them, rather than being locked behind a remote platform’s policies.

Benefits of the First Local Approach

The approach of storing and processing data locally before syncing it with the cloud brings multiple advantages over traditional cloud-centric models or simple caching mechanisms:

Offline Availability and Resilience

The app continues to work without an internet connection. All core functionalities operate against the local database, allowing users to open the app on a plane, in a tunnel, or in a rural area—and still view or input data normally. An offline-first design ensures that being offline doesn’t disrupt the user: they can continue working without interruption. Additionally, the app becomes more resilient to server or cloud outages. If the backend experiences downtime, users still retain their local data and can keep using the app as usual.

Faster User Experience (Low Latency)

By removing the need to wait for a server response with every action, First Local apps feel instantaneous. Reads and writes happen in milliseconds directly on the local database, avoiding network delays altogether. This results in snappier interfaces, free from constant loading spinners. Even when online, working locally improves overall speed, reduces data usage, and delivers a much smoother experience.

Optimistic and Non-Blocking Interactions

First Local apps make it easy to implement optimistic updates. When a user performs an action—like adding an item or editing a field—the interface reflects the change immediately using the local copy, without waiting for server confirmation. Most modern sync tools track these changes and push them later. If the backend rejects them, they can even be rolled back. This way, the user experiences instant feedback, with no blocking or interruptions.

Real-Time Collaboration Without Sacrificing Performance

While it might seem that a local-first approach limits collaboration, the reality is quite the opposite. By maintaining synchronized local copies, data can be updated in real time across users using notifications, CRDTs, or WebSockets. This enables collaborative experiences—such as text editors or real-time boards—while preserving local performance and smooth interactions, without relying entirely on the network.

Lower Data Usage and Efficient Operation

By reducing the frequency of server calls, these apps help save on mobile data usage. Sync operations can be configured to run only on Wi-Fi, or when there’s a strong signal or sufficient battery—optimizing resource consumption. This is especially valuable in regions where connectivity is limited or expensive.

Reduced Infrastructure Dependence and Costs

For startups and small teams, lowering the load on the backend means fewer expenses on servers and bandwidth. By processing more on the client side, it's possible to scale with less infrastructure. Additionally, simplifying—or even eliminating—multiple endpoints can reduce development and maintenance time. This allows teams to focus on what truly matters: the user experience.

Challenges and Limitations of the First Local Approach

Although the First Local approach offers numerous advantages, it also presents significant technical and design challenges:

Sync and Conflict Resolution

Maintaining multiple copies of data—one per device—synchronized with a central version introduces the risk of conflicts, especially when multiple users edit the same record while offline. Automatically resolving these conflicts without data loss is a complex task. Technologies like CRDTs (Conflict-free Replicated Data Types) enable all edits to converge eventually, but integrating them isn’t always straightforward. Tools like ElectricSQL already implement mathematically proven models for conflict resolution, but if you're building from scratch, you’ll need to carefully design merge algorithms. Even with simpler strategies like “last write wins”, precise decisions must be made to avoid losing valuable data or introducing inconsistencies.

Partial Replication and Managing Local Scope

It’s not always desirable to sync the entire database to every device. Due to space limitations, privacy concerns, or data volume, it’s necessary to define which subset of data should be kept locally. This requires additional logic to predict what to fetch and when. Some solutions implement dynamic partial replication, for example, downloading only a list of projects and syncing the details when one is opened. However, it's also important to consider how to clean up old data to prevent local storage from growing uncontrollably.

Client-Side Validation and Business Rules

In traditional architectures, validations and business rules live on the server. In an offline-first model, many of these rules need to be moved to the client—at least temporarily. For example, if only an admin is allowed to create a certain resource, how do you prevent an offline client from doing so? The server can reject the action once reconnected, but by then, the app has already shown a change that will be reverted, leading to confusion. Solutions like Postgres RLS (Row-Level Security) policies (as used in Supabase) can be adapted to the client with tools like ElectricSQL, but ensuring consistency without compromising the user experience remains a challenge.

Storage and Performance on Devices

Loading more data onto the device exposes physical limitations. Lower-end devices may struggle with limited storage, CPU, or RAM. Local databases must be optimized (using indexes, efficient queries) and stale data should be cleaned up regularly to prevent the app from becoming slow or unstable. On the web, there are also storage quotas in IndexedDB, and on mobile platforms like iOS, the system may terminate background processes—potentially interrupting sync operations if not handled properly.

How I’ve Used It in Personal Projects

In my personal projects, I’ve started actively incorporating the First Local approach as a key strategy to improve user experience—especially in contexts where connectivity is limited or intermittent. One of the most representative examples is Keppli Finance, a personal finance app I developed to help users understand, organize, and improve their relationship with money. During the initial testing phase, tools like PostHog and Sentry revealed that several users—particularly users in rural areas of Colombia who were experiencing issues loading data or recording transactions when they didn’t have a stable internet connection.

To address this, I implemented local storage using SharedPreferences in Flutter. While SharedPreferences is ideal for simple offline persistence, more complex or larger-scale syncing may require SQLite, Hive, or Isar.. Every time a user adds an income or expense, the data is temporarily saved on the device. Then, once connectivity is restored, the app automatically syncs this data with the backend (built with NestJS and Supabase), keeping track of any pending changes.

This allowed users to:

View all transaction history
Record transactions offline with a seamless experience.
Avoid data loss if the app closes unexpectedly before syncing.
Automatically sync changes in the background when the connection returns.

Additionally, local flags are used to track pending syncs, ensuring basic persistence of critical data until it can be sent to the server. This approach not only improved the app’s overall stability but also delivered a much smoother and more reliable user experience—even under poor connectivity conditions.

Final Thoughts

The First Local trend represents a natural evolution in software development, driven by the need to enhance user experience and increase application resilience. By prioritizing local data storage and processing before syncing with the cloud, apps become faster, functional offline, and offer users greater control over their information.

Of course, this model is not without its challenges. Distributed sync, conflict resolution, partial replication, and offline data validation all require a more complex architecture and a shift in mindset from the traditional client-server model. Even so, the ecosystem has responded with increasingly powerful tools—such as Supabase + ElectricSQL, and Replicache, that make it possible to implement local sync without having to rebuild your entire app from scratch. First Local isn’t just a technical improvement—it’s a paradigm shift. Instead of forcing the user to adapt to the limitations of the network, it’s the application that adapts to the user’s environment. As one quote from the Expo documentation perfectly puts it: “The availability of another computer (a server) should never prevent you from working.”

This approach will continue to gain traction. In the near future, we’re likely to see more and more frameworks and libraries adopting local-first capabilities by default. And that’s good news it means faster, more reliable apps that respect and empower their users. For developers, First Local is an opportunity to rethink how we build software putting the user and their context first. And for users, it translates into more human experiences: apps that respond instantly, work anytime, and give them back control over their data.

Thank you so much for making it this far and reading this article. Writing it has been a great learning experience for me, and I hope it has been helpful—or even inspiring—for you as well.

If you're interested in more topics on development, technology, software architecture, and real-world product-building experiences, feel free to visit keilerguardo.com, where I’ll be publishing more content like this.

I’d love to hear your thoughts, ideas, or experiences with the First Local approach in the comments.

Have a great day, and thank you for being part of this conversation about the future of software!

Important skills for web developers

Keiler Guardo Herrera — Tue, 29 Dec 2020 20:03:17 +0000

When we start in the world of programming we would like to have a learning path where they explain where to start, what is the first step we have to take in order to launch ourselves to create our own projects and have our first job. We have all had a learning path where we have learned a lot or a little, so I have taken the time to share with you a learning path that can encompass the essential skills you need to get started.

Mastering English

If you speak English fluently, you can simply skip this step, but if not, you have to focus on learning English first, this should be done because the main tools, both documentation, articles and online courses are in English, and not to mention that many times are a little more updated with respect to others, of course you can find a documentation and translated courses, but knowing some English is necessary, I think it is one of the main skills if you want to start.

Teamwork

Knowing how to work as a team is one of the other "Skills " that we have to master. We can say that we master it easily, but not all of us have the same patience and the same way of communicating with others, for that simple reason I think it is very important to be open to be able to work in a team, since in most of us, we will find ourselves in big teams in which we have to interact and at the same time communicate our ideas.

HTML and CSS

We started talking a little with the route of web development, if we want to get fully, we have to know HTML and CSS, we do not have to master it completely, that we dominate in 85% or 90% percent, this okay, even more if we want to take the next step to a programming language.

JavaScript

The fashionable language, JavaScript, could not be missing. If we have already decided and have chosen to go for web development, we have to learn this programming language, JavaScript is one of the most used languages in the web environment, when we have mastered JavaScript we can take the next step to learn a library or framework, in addition JavaScript is not only web development, also mobile development, augmented reality, machine learning, etc.

Git and GitHub

Git is a version control system designed for the efficiency, reliability, and maintenance of the versions of our applications, as well as access to files and source code. And Github is a platform that we use to host our projects using Git version control. We can also manage our projects and review our code among other features it offers. Not only is there GitHub, but there is also GitLab and others that offer many features, but Github is the most popular platform.

Backend programming languages

After mastering all of the above among other tools, you can make a leap to the Backend programming languages, which are responsible for managing the layer that is not directly accessible to users, and also contains all the application logic. Some backend languages are Python, PHP, Go, among others.

Databases

The databases are an organized collection of structured information, through our backend we can connect to them, and usually are controlled by a database management system, among which we can find one of the most used or popular as MySQL which is a relational database management system based on SQL, and not only there is MySQL also this PostgreSQL, Microsoft SQL Server among others.

In conclusion, we can say that after seeing all the above, you would be ready to create your portfolio and start offering your services, if you want to go from there you could jump to multi-platform development with Flutter, React Native or Ionic. Being a programmer is not something that is done overnight, it requires time, effort and dedication.

If you want to go a little deeper, here are some resources:
Frontend Developer: https://roadmap.sh/frontend
Backend Developer: https://roadmap.sh/backend

5 tricks to complete your task list

Keiler Guardo Herrera — Mon, 28 Dec 2020 01:33:07 +0000

Since the isolation began some of us have more time than usual, and we want to invest that time in things that will help us improve either, finish that project we have pending for months, complete the tasks of our home, etc.

We live full of chores and distractions in our daily lives, which affect our performance, which is reflected in our activities, when we start a task we do not finish it either because we did not have enough time or simply lost interest in completing it.

That is why in this article I have taken the liberty of writing down 5 tips that can help you complete your postponed tasks.

Wake up early

Many people don't like the first advice, I know, it's hard sometimes to wake up early, but believe me it's worth it, it was from people who used to go to bed late at night, and wake up in the morning and feel that my day was gone. Which was not good for me, during the day it seemed that I was not performing and my usual tasks could not be completed, but I started to wake up a little earlier, I set a time, 5 in the morning, at first it was difficult to get used to, but every day it became easier to get up in the morning, then I set another goal, to wake up at 4 in the morning, now without having my alarm clock I can get out of bed invigorated, it's just a matter of starting and repeating it over and over again. Your body will adapt.

Create a task list

Write down at least three important tasks that you think you can do during the day, try to write them down a day before, so that you have a little time to think about what you want to do the next day, dedicate your day and set that goal to finish the tasks you set for yourself the day before, so that you can concentrate and finish quickly. Then you can continue with the less important tasks or take a break, your body will thank you.

Use the pomodoro technique

The Pomodoro technique has proven to be very efficient, it is a method to improve the administration of the time dedicated to an activity. It is based on using a timer to divide time into fixed intervals, called pomodoros, of 25 minutes of activity, followed by 5 minutes of rest, with longer pauses of 20 or 30 minutes every four pomodoros. Personally I highly recommend it, it is a technique that has helped me to complete my daily tasks.

Use the airplane mode

I know you suddenly depend on it to answer calls from work, family or friends, but seriously, the cell phone distracts us for about 2 to 3 hours a day, we are dependent on it, which often affects us greatly. Every time a notification arrives we unlock our mobile to see who has written or called us, by putting your mobile in airplane mode you avoid all these distractions, try it is not impossible.

Create your workspace

Sometimes it is good to have our space, a space where we can clear our minds, work free of noise and other distractions, of course, we can work from anywhere in our home, but it is better to have our own space to work properly, try to create your environment according to your occupation, also remember to have a bottle of water, it will help you stay hydrated.

In conclusion some of these tips can be improved or modified, I have applied them in my day to day, I will not lie to you it has cost me a lot, but it has been worth it, do not try to implement them all at once, but you can start with one and then add another and so on, until you can implement them all, human beings are easy to adapt to changes, it is only a matter of time and repetition.