MindMaze

Share what you really think. Discover what others rarely say out loud. In MindMaze, how your posts are rated shapes your Status — and what you're likely to discover next.

Comment

Inspiration

MindMaze started with a simple question: how can we discover what people really think but rarely say out loud?

There are thoughts we keep to ourselves because they feel too personal, too unusual, or simply difficult to bring up in everyday conversation. Sometimes, just discovering that someone else thinks the same way can make us feel less alone. At other times, we want to know what other people genuinely think or wish for, especially in relationships, but those honest perspectives can be difficult to hear directly.

I wanted to create a place for those hidden perspectives.

At the same time, I did not want MindMaze to become another social media app where people compete for followers, likes, or attention. I wanted the incentive to be different: contribute something meaningful if you want to discover something meaningful from someone else.

That idea became MindMaze.

What it does

MindMaze is an anonymous social app built around a simple exchange:

Post one perspective, discover one perspective from someone else, and rate it.

The app has two modes: Thoughts and Wishes.

Thoughts is a place to share honest opinions, feelings, experiences, and ideas that people may not normally say out loud.

Wishes focuses on what people genuinely want from others, particularly in relationships and social interactions.

MindMaze deliberately avoids endless scrolling. Posting gives you the opportunity to discover another person's post, and after receiving it, you must rate it from 0 to 100 before continuing.

The rating system is also part of a larger idea: improving the quality of what people contribute.

MindMaze calculates a user-level score from the ratings their posts receive. Its matching algorithm then uses that score when selecting posts for the user. In other words, how your posts are rated influences the kinds of posts you are more likely to discover next.

This creates an incentive that is very different from likes or follower counts. Ratings are not about publicly displaying popularity. They help create a private feedback loop in which contributing something valuable can lead to discovering something valuable.

How we built it

MindMaze is my first app.

I built it using React Native, Expo, TypeScript, Supabase, RevenueCat, ChatGPT, and Cursor.

When I had the idea for MindMaze, I decided I wanted to turn it into a real app. While figuring out how to make that happen, I discovered Shipaton and decided to take on the challenge. From the initial idea to submitting MindMaze for App Store review, the entire journey took about one week.

Because I started with very little app development experience, AI became an important part of my development workflow.

I used ChatGPT extensively to discuss product design, reason through architecture and edge cases, learn unfamiliar concepts, and plan implementation and testing.

I used Cursor to help inspect, write, debug, and verify the actual code and backend changes.

AI accelerated the implementation, but I still had to decide what MindMaze should be. I designed the product concept, interaction rules, monetization model, rating and matching system, and user experience, and repeatedly tested the resulting behavior on a physical iPhone.

When something did not behave as intended, I went back through the design, investigated it with these tools, changed the implementation, and tested it again.

The app uses Supabase for authentication, the database, server-side logic, and access control. The backend manages profiles, posts, ratings, discovery state, matching, blocking, reporting, moderation, daily limits, and Premium access.

As part of Shipaton, I integrated RevenueCat to build MindMaze Premium. Rather than treating the subscription requirement as a separate feature added just for the hackathon, I wanted Premium to fit naturally into the product.

MindMaze Premium unlocks:

  • Wishes
  • History
  • Increased daily posting limits

I implemented monthly and yearly subscriptions, purchase restoration, entitlement handling, and a webhook that synchronizes subscription events with the backend.

One important design decision was not to rely only on the client to decide whether someone is Premium. Features such as access to Wishes and higher posting limits are also enforced on the backend using subscription state synchronized through RevenueCat.

I also separated the development and production environments and tested the complete production flow on a real iPhone before submitting the app to the App Store.

Challenges we ran into

The biggest challenge was time.

This was my first experience developing an app. I had the idea for MindMaze, decided to build it, and discovered Shipaton while figuring out how to turn the idea into a real product.

I decided to take on the challenge and bring the app from an idea to App Store review in about one week.

That meant learning how mobile app development works while simultaneously designing, building, testing, monetizing, and preparing a real application for the App Store.

I decided to fully commit to it.

AI tools made it possible for me to move much faster than I could have on my own, but moving faster also meant I had to be careful not to confuse generated code with a finished product.

I still needed to understand what behavior I wanted, identify edge cases, verify changes, test them on a real device, and make the final decisions when different approaches were possible.

Along the way, I had to deal with many things I had never encountered before:

  • Authentication
  • Database design
  • Row-level security
  • RevenueCat subscriptions and webhooks
  • Production environments
  • TestFlight
  • App Store Connect
  • Account deletion
  • Moderation
  • Release testing

Getting a subscription to appear in an app is one thing. Making sure purchase, restore, expiration, client-side entitlement state, and backend authorization all remain consistent is another.

I spent significant time testing those flows on the actual production build rather than stopping once the paywall worked.

The interaction model itself also created difficult edge cases.

MindMaze is not a normal feed. A user can have an unrated post waiting for them, an unused discovery from a previous post, no eligible post currently available, a daily posting limit, or a change in Premium status. Thoughts and Wishes also have independent state.

All of these states need to work without letting users:

  • Skip required ratings
  • Repeatedly see the same post
  • See their own posts
  • Lose an earned discovery
  • Bypass Premium restrictions

Another major challenge was designing the system around quality rather than simply quantity.

Anonymous apps can easily encourage low-effort content, so I spent a lot of time thinking about how the product itself could give users a reason to make better contributions.

That led to the rating and matching system that became one of the core ideas behind MindMaze.

Accomplishments that we're proud of

What I am most proud of is getting MindMaze all the way from an idea to App Store review.

This is my first app. I had the idea for MindMaze, decided to turn it into a real app, discovered Shipaton, and took on the challenge.

In about one week, I went from an idea to submitting MindMaze for App Store review.

I am proud not because I wrote every line without help, but because I learned how to use the tools available to me to turn an idea into something real.

ChatGPT and Cursor dramatically accelerated the process, but there was still a long chain of decisions between "I have an idea" and "I have submitted an app."

I had to define the product, decide which features mattered for v1, work through unexpected behavior, test repeatedly, configure production services, integrate monetization, and keep pushing until the app was actually ready to submit.

In about one week, MindMaze went from an idea to a functioning production app with authentication, subscriptions, backend authorization, moderation, account deletion, matching logic, and a tested production environment, and finally to App Store review.

I am also proud that I did not simply build an anonymous posting app.

A central design goal was to think about incentives.

If users can consume unlimited content regardless of what they contribute, there is little reason to put effort into a post.

MindMaze instead connects contribution and discovery, and its matching algorithm creates an additional incentive:

The quality of what you contribute can affect the quality of what you discover.

There is still much more I want to do with this idea, but creating that foundation in v1 is one of the parts of MindMaze I am most proud of.

What we learned

Building MindMaze changed my understanding of what it means to build software.

One of the biggest things I learned was how powerful AI-assisted development can be for someone entering an unfamiliar field.

ChatGPT and Cursor allowed me to learn and build at the same time.

Instead of spending weeks learning every technology before starting, I could encounter a real problem, understand what I needed, work through it, test the result, and move on to the next one.

At the same time, I learned that AI does not remove the need for judgment.

A feature is not finished just because code was generated or because it works once.

I had to think about what happens:

  • After restarting the app
  • When a subscription expires
  • When there is nobody eligible to match with
  • When a user blocks someone
  • When an account is deleted
  • When the client and backend disagree about state

I also learned the importance of designing incentives.

For MindMaze, the most interesting question became not just:

"How do I let people post anonymously?"

but:

"How do I make people want to contribute something worth reading?"

That question influenced the one-post-for-one-discovery structure, mandatory ratings, user-level scores, and the matching algorithm.

RevenueCat also taught me that monetization is not just about putting a paywall in front of a feature.

I had to think about the complete subscription lifecycle: purchase, restoration, entitlement state, backend authorization, webhooks, expiration, and how all of those pieces remain consistent.

Because RevenueCat was a core requirement of Shipaton, it pushed me to implement monetization in my very first app. What began as a hackathon requirement became an important part of learning how a real production app works.

Most importantly, this project showed me how much can be accomplished in about one week when I combine strong commitment with tools that allow me to learn and execute quickly.

What's next for MindMaze

Submitting v1.0 is only the beginning.

The current version already creates an incentive to make better posts through ratings and matching, but I have more ideas for strengthening that loop.

I want to introduce features that make users actively want to improve the quality of their next contribution, rather than treating posting as merely the price of seeing another post.

Some of those ideas are already designed conceptually, but I deliberately kept them out of v1 so I could focus on making the core experience reliable first.

After launch, real usage will help determine which of those ideas should come next.

I also want to continue improving matching, moderation, safety, and the overall discovery experience as the community grows.

The long-term goal is to make MindMaze a place where anonymity does not reduce the quality of conversation, but instead makes it possible to discover perspectives that people would otherwise never share.

The core idea will remain simple:

The more meaningful your contribution, the more meaningful your discovery can become.

Built With

Share this project:

Updates

Submission history