This week, I focused on improving the UI for UV-Buddy. I realized that adding an AI insight was fun, but something was missing—showing just text felt a bit boring. So I decided to add animation, specifically animating the character to make the UI more engaging.

Animating the character and integrating it into the UI consumed all my time this week. Using AI to create the animation? That was actually the easy part. The real challenge was doing it without breaking the bank.

After testing several options, Midjourney gave me the best results for animated characters. Other AI tools were either too expensive or completely changed the character’s face. But then came the next hurdle: creating a transparent background. I tried multiple solutions, but they were all too costly and didn’t deliver great results.

That’s when I discovered ComfyUI—a node-based AI tool that runs locally. It gave me exactly the control I needed. The final step was optimizing the file size and making it iOS-ready, which meant converting everything to Lottie files.

It’s not the easiest workflow by any stretch. Getting there required a lot of patience and trial and error. But I finally cracked the code: I found the right file formats, figured out how to create Lottie files that aren’t too grainy, and successfully added them to the app.

Here is the result:

This week threw me a curveball—I got sick and had to pump the brakes on everything. You know that frustrating feeling when your mind is ready to work but your body just says “nope”? That was me for most of the week. I’d sit down to tackle my projects, only to realize I could barely focus on my screen.

There’s something humbling about being forced to rest. Part of me wanted to push through (classic overthinking), but my body had other plans. And honestly? It was probably right. Sometimes we need that forced downtime, especially when we’re under the weather.

On the days I did feel human again, I made some solid progress on my side projects’ UI. I’ve fully decided to embrace the glass effect design—and here’s the kicker: I’m dropping iOS 18 support entirely. The decision was actually pretty straightforward since all my users have already upgraded to iOS 26. Why hold back for an outdated version when I can lean into the latest features?

This shift also opened up another exciting possibility: integrating Apple Intelligence to provide personalized insights based on user profiles. It’s one of those decisions that feels both bold and obvious at the same time.

Looking back, this “slow” week actually packed in some pretty significant strategic moves. Sometimes the best progress happens when you’re not forcing it—when you give yourself permission to rest and let the bigger picture come into focus.

I'm hitting the restart button once more on documenting my journey as an indie developer. Though technically, I suppose I already earned that title—I've got two apps live in the Apple Store: UV-Buddy and Money Map. But the path forward still feels uncertain, still feels like I'm figuring it out as I go.

This time, I'm writing differently. Instead of crafting posts hoping to capture everyone's attention, I'm writing for future me. I want to look back months or years from now and remember these exact moments—the small victories, the frustrating setbacks, the daily grind of building something from nothing. These posts will be my breadcrumbs through the journey, reminders that growth only comes through the messy combination of successes and failures.

This Week's Progress: Wrestling with Screen Sizes

I finally tackled something that's been nagging at me for weeks: making my app work across all Apple screen sizes without completely breaking the layout. It's one of those unglamorous tasks that users will never notice when it's done right, but would definitely notice if it's wrong.

The results look solid on most devices, but when I pulled it up on the biggest display... well, let's just say there's a problem. There's this awkward dead space at the bottom that makes the whole interface feel cramped toward the top. It's like all the content is huddling together for warmth while leaving half the room empty.

After staring at it longer than I'd like to admit, I think I've got a solution: flip the counters to stack vertically and redesign the timer layout to run horizontally. It should fill that space more naturally and give the whole thing better balance.

That's my mission for the coming week—assuming life cooperates and gives me the time to implement these changes. Fingers crossed I'll have something worth showing in next week's post.

Every ambitious person faces this familiar crossroads: you're sitting at your desk after a long workday, and that exciting side project is calling your name. Maybe it's the app you've been sketching out, the blog you want to launch, or the small business idea that keeps you awake at night. The question that haunts us all eventually surfaces: "How do I balance my day job with building something meaningful on the side?"

The answer isn't as straightforward as we'd like it to be. While the theory seems simple enough—work during the day, build your passion project in the evenings and weekends—the reality is far more complex.

Two Types of Side Project Builders

Understanding your motivation is the first step toward success. Side project builders generally fall into two distinct camps, each with different challenges and approaches.

The Hobbyists pursue side projects purely for joy and personal fulfillment. They might cook elaborate meals, learn to dance, or play music in their garage band. These builders aren't racing against any clock or chasing external validation. There's no pressure to monetize their next recipe or perform on the biggest stage in town. They simply love what they do and have no plans to replace their day job with their passion.

The Transitioners view their side projects as stepping stones toward a complete career pivot. Every project represents a potential breakthrough—a chance to finally make the leap from employee to full-time entrepreneur. For developers like myself, each app becomes a possible gateway to the independent lifestyle we crave. The stakes feel higher because these projects aren't just hobbies; they're investments in our future selves.

Understanding which camp you belong to helps set realistic expectations and prevents unnecessary frustration.

The Time Crunch Reality

Here's the harsh truth that every side project builder must confront: time is your most precious and limited resource. Side projects exist "on the side" for a reason—they must compete with work deadlines, family obligations, social commitments, and basic human needs like sleep and rest.

This constraint creates a dangerous trap. When passion meets limited time, we often respond by trying to do everything at once. We stay up too late, skip social events, and push ourselves beyond our sustainable limits. The initial excitement that fuelled our project gradually transformed into exhaustion and frustration. Eventually, we abandon the project entirely, telling ourselves we'll "get back to it someday"—a someday that rarely comes.

I've walked away from numerous side projects over the years. Some were simply too ambitious for a solo developer to tackle. Others lost their appeal once the initial novelty wore off. Each abandoned project taught me valuable lessons about what works and what doesn't when juggling multiple priorities.

The Birth of Something Personal

The breakthrough came when I realized that successful side projects must solve a problem you personally experience. My budgeting app emerged from genuine necessity—when Mint shut down, I needed a replacement and saw an opportunity to learn mobile development simultaneously. This dual motivation (personal need plus skill development) created the perfect storm for sustained engagement.

The project succeeded because it mattered to me on multiple levels. I wasn't building an app for some hypothetical user; I was building it for myself, which meant I intimately understood the problem and could validate solutions immediately.

Four Principles That Changed Everything

Through years of trial and error, I've discovered four principles that make side projects more manageable and sustainable alongside full-time work responsibilities.

Make It Matter to You Personally

This principle stands above all others in importance. Looking back at every abandoned project, the common thread was always the same: they weren't deeply meaningful to me. When a project lacks personal significance, it becomes easy to rationalize skipping work sessions. "I'll work on it tomorrow" becomes a weekly refrain, then a monthly one, until the project fades into memory.

Your side project should address a problem you face, utilize skills you want to develop, or explore interests that genuinely excite you. Without this personal connection, you're building on shaky ground.

Prioritize Enjoyment Throughout the Process

Fun acts as the fuel that powers long-term commitment. When working on your side project feels like playing your favorite game—where you set the rules and determine the pace—you'll find yourself naturally gravitating toward it during free moments.

This doesn't mean every aspect will be pure joy. Challenging debugging sessions, tedious configuration tasks, and frustrating setbacks are inevitable. However, these difficult moments should be exceptions rather than the norm. If you consistently dread working on your project, it's time to reassess whether it's the right fit.

Establish Clear, Achievable Goals

Goal-setting provides structure and momentum that carries you through challenging periods. I've found that weekly goals strike the perfect balance—long enough to accomplish meaningful work, short enough to maintain focus and motivation.

The key is treating these goals as your minimum viable progress. When you meet your weekly target, anything additional becomes a bonus rather than an expectation. This approach creates positive reinforcement cycles where completing goals fuels your desire to continue, rather than creating pressure that leads to burnout.

Navigate AI Assistance Thoughtfully

This principle is still evolving as I experiment with different approaches. As a developer, I've discovered that AI can be both a powerful accelerator and a creativity killer, depending on how you use it.

Some days, when energy is low or time is extremely limited, letting AI handle routine coding tasks while I focus on review and architecture makes perfect sense. Other days, when I'm feeling creative and want to solve problems hands-on, I prefer coding without assistance to maintain that satisfying flow state.

The key is remaining intentional about when and how you delegate to AI, ensuring it enhances rather than replaces the aspects of your project that bring you joy.

The Next Chapter

After successfully launching my budgeting app and achieving the goals I set for it, the familiar itch for a new project returned. This time, I'm building UV-Buddy, an app designed to track sun exposure and remind families when it's time to apply sunscreen. The concept combines personal utility (protecting my family from sun damage) with engaging features that encourage kids to participate in their own sun safety.

The app exemplifies all four principles I've outlined: it solves a real problem my family faces, it's enjoyable to build, I have clear weekly development goals, and I'm thoughtfully incorporating AI assistance where it adds value without diminishing the creative process.

UV-Buddy is nearly ready for its public debut. Within the next week, I'll be opening TestFlight beta testing for anyone interested in providing feedback. If you'd like to help shape the final product and contribute to my journey toward full-time independent development, I'd be grateful for your participation.

Your Turn

Balancing work with side projects isn't about finding more hours in the day—it's about making the hours you have count toward something meaningful. Whether you're building your next career or simply exploring a passion, remember that sustainable progress beats unsustainable sprints every time.

The path from side project to main project isn't always linear, but with the right approach, it's absolutely achievable. Start with something that matters to you, have fun building it, set realistic goals, and be intentional about the tools you use along the way.

Your side project journey is waiting. What will you build?

It’s been a while since I sat down to write about the journey I started a few months ago. I kept telling myself, “This weekend, I’ll continue writing.” But then I’d look at the list of tickets waiting for me and decide, “No, I need to get to the code. I have to finish the app.”

It often felt like a race—like getting to the finish line first would magically bring in all the users I wanted. And while speed can help, especially in a competitive space, it’s not a guarantee. When you’re working on a side project, that kind of pressure can burn you out quickly.

An update about Money Map

The app has been running on macOS and iOS for over a month now, and I’m genuinely thrilled to have reached that milestone. The goals for Money Map were simple:

1. Help me manage my own finances.

2. Learn everything I needed to build and launch an app on the App Store.

Mission accomplished.

That said, it’s not doing particularly well in the store. Most users are looking for finance apps that connect directly to their bank accounts—something I’ve deliberately chosen not to do. I won’t say never, but it’s definitely not on the roadmap any time soon.

When I launched the iOS version, I realized just how crowded the space is. Many of the top apps offer bank connectivity, which I still don’t fully understand how they manage. From my research, it costs around $12k a year plus a per-user fee to use a third-party integration service. That’s not a path I’m willing to take—especially if it means competing on price alone.

I’d rather compete on quality. But even more important, I want to stay focused on the app’s original purpose. If those goals are being met, I can consider it a success—even if it doesn’t bring in millions. Money Map is a tool I built for myself, and one I’m happy to share.

I’ll keep updating it, though not as frequently—because there’s something new I’m working on that’s demanding most of my time and energy.

Despite not earning a cent, Money Map is still very much alive. I use it daily, I have a list of features I want to add, and above all, I’m still enjoying the process.

Introducing UV-Buddy

I’m really excited to share a sneak peek at my next project: UV-Buddy.

This new app is still in development, but the idea is simple—remind users to apply sunscreen, with help from a friendly little cartoon buddy. More details to come in future posts!

As with Money Map, this app started from a personal need. I have to take special care of my skin, and I figured—why not create something that helps me do that and makes it fun? I also wanted something the whole family could use.

The goals for this app are:

• Deepen my understanding of Apple frameworks

• Launch a proper marketing campaign

• Generate at least $100 MRR

Some reflections

Here are a few takeaways from the past few months:

• Set goals. Seriously. Without clear goals, it’s too easy to get lost in endless tweaks and never feel done.

• Build what you’ll use. At least for now—while indie dev is still my side project—this rule keeps me grounded. If nothing else, I’ll always have one satisfied user: me.

• It’s a marathon. It doesn’t matter how long it takes. What matters is learning something new every day and making sure the journey is fun—even when it’s tough to balance time and avoid burnout.

Thanks for reading.

Let me take you back to the moment I decided to switch my Xcode compiler to Swift 6. I thought this simple flip of a switch would reveal all the necessary errors I needed to fix—boom, done, app updated. Sure enough, I got just two errors, so I patted myself on the back: “Looks like moving to Swift 6 isn’t nearly as difficult as people said!” Well, that blissful optimism didn’t last long.

How I knew I was not fully using Swift 6

I had been working on the iOS version of my app, and as soon as I tested synchronization between iOS and macOS, I noticed something was off: certain transaction data was missing. My categories weren’t showing up. It felt like a data race, where one process swoops in and grabs data while another is still fetching it. But wait—Swift 6 is supposed to prevent data races, right?

I was convinced something deeper was wrong. In a desperate attempt, I forced my data-fetching method in my singleton class to run on the MainActor. I figured, “Hey, if it’s on the main thread, what could go wrong?” Turns out…plenty.

Behind the scenes

Simply flipping your compiler to Swift 6 isn’t enough. Swift 6 will spin up threads automatically for non-UI code if you don’t explicitly confine that code within an actor. Plus, when you move everything to the MainActor, the compiler’s concurrency checks basically shrug, because all the code is now lumped into one actor.

So here I was, staring at no errors yet facing data races. It’s like the compiler was saying, “Everything’s fine!” while the app was clearly shouting, “No, it’s really not!” After reading blog posts galore, I realized I should switch from singletons with classes to singletons with actors in Swift 6. That’s when I decided to go all-in.

Pro Tip: Turn on "Strict Concurrency Checking." I discovered this late in the game, but it’s a lifesaver for catching data races.

Moving to actors

The moment I changed my class to an actor, I was bombarded with more than 99 errors! But ironically, that massive error list reassured me—I was finally making a genuine transition to Swift 6. Of course, this meant updating database calls to await and marking methods as async, not to mention switching UI calls to tasks. Time-consuming? Absolutely. But doable.

Everything was smooth sailing until I hit: "Class Transaction is not sendable." Considering Transaction is a core model, this was a big deal. So, I turned to AI.

Why AI is very far from been AGI or replace Software Developers

I asked AI what Sendable meant and how to handle it. It explained the concept clearly and suggested using @unchecked Sendable on my model, claiming that since it was only accessed by the data actor, it should be safe. Every AI model I tried said the same thing. Skeptical, I gave in and tried it.

The compiler was happy. The error vanished. I thought, “Hooray, I’m officially on Swift 6!” But in reality, I had just buried my errors. SwiftData models aren’t meant to be Sendable, and that @unchecked annotation basically told the compiler to look the other way. Great, now I had even more unaddressed problems under the hood.

Lesson Learned: AI can provide quick answers, but it lacks real-world context. It’s like an ocean of knowledge that’s only a centimeter deep. Beware!

Using Persisten Model ID

Since my model wasn’t Sendable, I tried passing around its Persistent Model ID, which is Sendable. The plan was to fetch the actual object using that ID in the model context.

For me, this didn’t go smoothly. I had to enable a special property—includePendingChanges—in my fetch descriptor to get it to compile without errors. Even after checking various forums, I couldn’t find crystal-clear explanations for why this was necessary.

I used this blog to guide on how to use the ID to fetch and get the object back concurret-programming-in-swiftdata

The final solution

Ultimately, I resorted to DTOs (Data Transfer Objects). Whenever I fetch data, I now create a DTO and pass that around. My model remains tucked away behind the data actor.

Of course, if your model has multiple relationships—like Transaction -> Categories -> Subcategories -> Transactions—you might need multiple DTOs or find a strategy to avoid descending too far. It’s not the easiest fix, but it works and keeps your data race-free.

Here is the blog that I found that explains better how to implement the DTO and how it has been used with SwiftData Use Swiftdata Like A Boss

Conclusion

Migrating to Swift 6 was a bit of a roller coaster, but now that I’m on the other side, I see the benefits. My code is cleaner, the app is faster, and those synchronization issues that once haunted me are finally gone.

I still have a lot to learn about Swift 6 and concurrency, but I’m already experiencing the payoffs, and I hope my journey can spare you some of the same headaches.

P.S. Stay tuned! I’ll be sharing updates on my app soon. In the meantime, feast your eyes on this new logo…

While I’m no expert in indie development, I know that picking the right tech stack is a game-changer—it lays the foundation for everything that follows. For me, the journey started with a simple yet powerful question: What do I want to learn so that even if I fail, I still come out ahead with new skills?

I had already dipped my toes into web development and used Python daily in my job. With that experience in mind, I figured building an app would be the best way to push myself further. After diving into research, I identified three main technologies for app development: Flutter, Swift, and Objective-C. While there may be others, these three seemed to dominate the landscape.

I had heard that developing for Android comes with the challenge of accommodating countless screen sizes, processors, and brands. Flutter promised a way to tackle that complexity while also supporting iOS. But while its versatility was appealing, I was eager to learn a new language from scratch. Flutter felt too similar to web development, and one major downside was that it’s always playing catch-up with the latest Swift updates. As for Objective-C, it seemed to be on its way out, so investing time in it didn’t make much sense.

That left Swift. I chose it because it’s a modern language with Apple’s powerhouse backing, ensuring its longevity. Plus, iOS has a much smaller range of screen sizes to account for, making development smoother. Best of all, with Swift, I can immediately adopt Apple’s latest innovations. The only real drawback? I need a Mac to work with it—an investment I hope will pay off in the long run.

One surprising aspect of my journey has been the role of AI in learning and development. Since Swift is relatively new compared to Python, AI models have less training data on it. While some might see this as a drawback, I view it as an opportunity. It forces me to truly understand the language rather than relying on AI-generated solutions that may not always be accurate.

In the end, choosing Swift wasn’t just about practicality—it was about growth. With Apple’s continued support and a commitment to staying ahead of the curve, I know I’m building something that will stand the test of time. The challenges, from requiring a Mac to working without extensive AI guidance, only push me to become a better developer. And that, to me, is the most exciting part of the journey.

Money Map progress

I’m currently developing my first app—a budgeting tool born out of necessity. When Mint, the budgeting app I relied on, was retired, I wasn’t thrilled about linking my bank account to third-party services like Plaid, which many budget apps use. So, I took matters into my own hands and started building my own solution. Currently, it’s available for macOS, with an iOS release just around the corner. It’s been a fun and challenging ride, and I can’t wait to see where this project takes me!

As for progress, well, let’s just say it’s been a slow crawl this week—especially on the download front. Balancing development with a full-time job isn’t easy, and I haven’t had much time for marketing, posting on X, or spreading the word. But the good news? The accounts section for iOS is officially done! Now, I’ve got four major tasks ahead: Categories view, paywall, onboarding, and settings.

I’m still optimistic that the iOS version will be ready to launch by the end of February. It’s a challenge, but I love the process. And hey—here’s a sneak peek of what’s coming soon!

Quote for this week

Proverbs 3:5–6
“Trust in the LORD with all your heart and lean not on your own understanding; in all your ways submit to him, and he will make your paths straight.”

Short-term vs. long-term goals

Let’s begin by categorizing goals into two buckets: short-term goals and long-term goals. Short-term goals are objectives that can be achieved within a few months to a maximum of six months, while long-term goals take a year or more to accomplish. I’m not here to explain the best way to set goals—there are plenty of blogs on that topic. However, I will emphasize that every goal should have a measurable metric and a clear end date.

I’ve adopted advice from the video From Side Project to Going Indie to structure my goal-setting process. For instance, I set quarterly goals for all aspects of my work. A recent example is: “Complete the iOS app version by the end of March.” To achieve this larger goal, I break it down into smaller, actionable steps. I use Jira to track these goals, not only for coding tasks but also for marketing objectives, ensuring a consistent approach across both domains.

While I make an effort to set and follow these goals, I often find myself creating new ones almost every week. I don’t see this as a problem; rather, I think it’s a sign that I could be more ambitious. Managing short-term goals requires a delicate balance, especially since I’m juggling a full-time job and a side project. The key is developing the discipline to regularly review and adjust goals. This habit helps me manage time effectively, even if achieving perfect balance remains elusive.

Long-term goals, on the other hand, allow for broader aspirations and dreams. For example, my main long-term goal this year is to complete the budgeting app and earn $1,000 in revenue. Looking further ahead, by 2026, I aim to have three apps, each generating at least $10,000 annually. While it’s important to be ambitious, it’s equally critical to prepare for the possibility of falling short. If I give my best effort but don’t fully achieve a goal, I’ll still gain valuable lessons from the process.

I plan to review these long-term goals annually and adjust them as needed. Since I’m just starting this journey, I haven’t had the opportunity to revise any goals yet. My hope is that future adjustments will reflect positive progress—for instance, achieving financial sustainability for my projects sooner than expected.

Ultimately, setting goals is just the first step. The real work lies in acting on them and consistently reviewing them, even if it’s just to keep them top of mind. This practice ensures that I’m constantly taking steps, however small, toward achieving my ambitions.

How Money Map is doing

I’m currently working on an app called Money Map, which you can download here: Money Map.

This week, progress has been similar to last week, with little change in downloads or revenue. My focus has been entirely on the iOS version, and I’m pleased to report that it’s on track. I’ve been hitting my quarterly goals, and the app is shaping up well for a release by the end of February. Things are looking promising!

Quote for this week

“Commit to the Lord whatever you do, and he will establish your plans.”
Proverbs 16:3

For as long as I can remember, I’ve dreamed of creating my own company and embarking on an entrepreneurial journey where I could be my own boss. However, I kept postponing it, partly because I’ve been fortunate to have great bosses and genuinely enjoyed my work.

During the pandemic, I found myself with more free time and decided to explore web development. My goal was to create an app to manage online education—a pressing need at the time as everything was shifting to the web. But after several months, I hit burnout; tackling such a massive project alone proved overwhelming, and I eventually set it aside.

Later, during the Hollywood strikes, which brought movie and TV production to a halt, many artists were left out of work or reduced to part-time roles. I was among the lucky ones working part-time. This extra time gave me an opportunity to reflect on the entrepreneurial journey I had put off for so long. I decided to learn Swift, and the rest of the story can be found in my first post, First post of the journey

Defining “indie”:

For me, being an indie developer is the ideal way to pursue entrepreneurship. It allows me to do what I love while gradually achieving financial independence. I have full creative control over my projects while also learning essential skills like marketing and product sales.

From a financial perspective, this approach is less risky. I can keep my current job while working on my apps, which reduces stress. I don’t want to find myself in a situation where I’m uncertain about how to pay the bills next month.

Freedom is another significant benefit. As an indie developer, I can choose how and when to work on my projects. Don’t get me wrong; being indie often means working longer hours. However, not being tied to a strict 9-to-5 schedule is a huge advantage—especially when you have kids and value family time.

Long-term vision

My ultimate goal is to create apps that I can share with others while earning a living from them. This would be the dream—doing what I love while maintaining a fulfilling career.

I envision a gradual transition. For now, my full-time job pays the bills, but I aim to flip the dynamic: eventually, my apps will generate enough income for me to work part-time, and ultimately, I hope to become a full-time indie developer.

I’m aware the journey may be long or short, depending on luck and the effort I put in. Whether I run or walk, the most important thing is to embrace the journey and learn as much as I can along the way.

I recently took a course about becoming an indie developer, which I highly recommend to anyone considering this path. From Side Project to Going Indie

Update of the journey

This week’s update is fairly light. I’ve had a few downloads for the macOS app, but overall activity has been slow. On the bright side, I’ve made significant progress on the iOS app, particularly the budget view—the most complex part. Once this section is complete, I anticipate releasing the app a few weeks afterward. My target release date is by the end of February.

One unexpected benefit of working on the iOS app is how it’s improving the macOS version. While developing new features and refining the UI for iOS, I noticed several areas for enhancement in the macOS app. It’s exciting to see these improvements come together and elevate the overall quality of both apps.

The first week of 2025 has brought some exciting developments for my macOS app. Downloads have increased noticeably, and the app is appearing more frequently in Apple Store searches. This is a significant improvement, as previously, the app only appeared to a handful of people on the best days.

My Plan Moving Forward

From here, my focus is on analyzing every step potential customers take and improving their experience wherever possible. This is not an easy task, but I believe that without improving these metrics, it will be impossible to reach more users who can enjoy the app.

What Am I Improving?

1. Enhancing Visibility in the Apple Store
Since I’m just starting and cannot afford paid ads or marketing campaigns, I’ve been looking at what successful competitors are doing and finding ways to make my app more attractive without appearing "cheap."

• Improved Screenshots: Competitors use screenshots with phrases that highlight the app’s features. I’ve followed suit, creating polished screenshots and adding captions to emphasize the benefits of the app.

• Expanding Language Support: I translated the app into Spanish to increase visibility in Spanish-speaking markets. Additionally, I discovered that adding more languages can improve visibility in the US Apple Store. While implementing this, I realized that I had only set the app’s language to English (Canada). This oversight meant the app was not listed in the US, UK, or Australian stores. When I tried enabling English (US), an error indicated that another app with the same name already existed. To resolve this, I renamed the app to “Money-Map.”

2. Using Better Tools
I started using the Helm app for macOS, which simplifies the app submission process to the Apple Store. Helm also provides keyword suggestions, making it easier to avoid common mistakes, such as using the same word in both the app’s name and its tags.

3. Preparing for User Interaction
To ensure the app meets users’ needs, I’ve set up analytics to track how users interact with the app. However, maintaining user privacy is one of my core values. I’ve been careful only to track errors and usage of specific features, without logging any personal data that users input into the app.

Looking Ahead

I’m hopeful these improvements will attract more customers, which will, in turn, provide valuable feedback and help improve retention. By continuously refining the app, I aim to create a product that users love and trust.

For over a decade, Python has been my primary programming language. I’ve always believed that learning any new language builds on the fundamentals of programming, making the language itself less important than how you use it. With this mindset, I decided to challenge myself by creating a new app for my phone and chose Swift as the language to learn. The only question left was what type of app to make.

About a year ago, I already had some ideas in mind when I discovered that Mint, the budgeting app I relied on, was shutting down. With only four months to find an alternative for tracking my budget, I explored options like YNAB. However, its high cost and reliance on a third-party library for bank integration left me uncertain. That’s when it clicked: I could build my own budgeting app. It was the perfect solution—a tool tailored to my needs while also serving as a hands-on way to learn Swift.

Even though the budgeting app market is crowded, I was excited by the idea of creating something personal. If nothing else, I’d be its first user—me. This project became more than just a way to transition from Mint; it turned into an opportunity to build a tool I truly wanted while growing my programming skills.

Money Map app

My app is called Money Map and is currently available only for macOS (I’m working on the iOS version). This decision stems from my preference not to support bank linking—I’ve never been comfortable with having my bank credentials stored on potentially vulnerable servers. At the same time, I didn’t want to manually input every transaction, so I started with support for CSV files. Later, I created a Python script (Transactify) that converts Quicken files into JSON, providing more detailed data than standard CSV files. Currently, the app supports both JSON and CSV file types.

After testing with friends, I realized the app needed additional features. Some users wanted to manually add transactions, others needed recurring transactions, and some requested app protection through authentication. These, and other features, have all been implemented in the latest release.

I’m proud of what I’ve accomplished with Money Map. It’s still a work in progress, but seeing it in the Apple Store is incredibly rewarding. There’s so much more I could share—like the libraries I’ve used and the technical challenges I’ve faced—but this is a great start for my first blog.

How am I doing currently?

Having an app in the Apple Store has been a fun and enlightening experience. I’ve learned that creating an app isn’t just about development; it’s also about marketing and getting the word out. So far, I haven’t excelled in that aspect—I’ve had a few downloads but earned $0. I’m optimistic that the iOS version will improve conversions once it’s released.

Thank you for reading

This blog is part of my New Year’s resolution to be more public about what I’m working on. It’s both a way to market Money Map and to document my journey as an indie developer. With any luck, I’ll soon achieve the coveted "ramen profitability" status :).