Lovable AI: How to Build an App & Upload to App Store (Tutorial)

Have you ever wondered how apps like this one are making over $20,000 per month while you're still stuck trying to learn code? Well, I just built this exact same app without writing a single line of code.

So, in this screenshot, you can see proof that the original Picture Fish app, which identifies fish species through AI and provides us with detailed marine life information, is generating massive revenue. And now most people think that you need years of programming experience, but nowadays that's completely wrong. I use just one AI tool where you literally prompt your idea and then it builds your entire app for you.

So in this video, I'm going to show you my complete step-by-step process of how I recreated this $20,000 per month app using AI, the exact prompts that I used, and how to get it live on the app store without any coding. Let's go ahead and dive in.

I also added a special link in the description below to all the AI tools that we're going to use today in this video. So, please do go ahead and check them out.

And if you've ever been out fishing or even just strolling along the shoreline and maybe you spotted a fish you couldn't just name off the top of your head, you know that feeling of wanting an instant answer. Well, that curiosity is exactly what makes Fish Identifier app so valuable.

Before the app can recognize anything though, it does need a clean, modern layout that's easy to navigate on mobile. So, the very first step is getting Lovable to set up that foundation for us. Now, I'm going to prompt Lovable with this.

"Hey, Lovable, please build a fish identifier application. Please first build the application's UI. Use mock data for now as we'll build actual functionality later. Build this as a web-based mobile app in mind."

And with that, once Lovable processes that request, it immediately starts assembling the structure of the app, giving us a polished interface to work from. And as you can see a few moments later, the UI is fully generated. And we now have a simple yet modern looking application. And yes, everything is still using placeholders for now, which is exactly what we want at this stage because all the real features will come in the latter part. But the app already includes four main sections here: home, identify, library, and profile, which provides a clear layout that sets the tone for the entire project. And since the visual framework is ready, we can now start turning this into a fully functioning AI-powered fish identifier.

All right, so this is where things really start to get exciting for us. Anyone can build a camera page or an upload button, but giving the app the ability to actually recognize a fish and then describe it in detail is what turns it into something special. And I get it though, most people assume that you need machine learning experience or a whole full team to build image recognition, but Lovable makes it surprisingly accessible, especially once we bring in our own OpenAI API key.

Before we connect anything inside Lovable, we will start by setting up our access on the OpenAI side. So, let's head over to the OpenAI platform, create a new project, and generate a fresh secret API key. And now that the key is copied and ready, the rest of the process will happen directly inside of Lovable.

Now, to activate the feature, we are going to give Lovable the exact prompt and it defines how the entire system should behave. Something like this.

"Please enable cloud and integrate OpenAI for the image recognition process. Whenever a user takes a photo or uploads a photo of a fish, scan it with OpenAI and have it return with detailed information such as its biological characteristics, behavioral traits, dietary habits, breeding information, potential environmental impact, and similar species comparison. Enable cloud, then ask me for the API key to be used for OpenAI."

And once Lovable processes the instruction, it is going to ask us to enable cloud. Enabling cloud allows Lovable to use SDKs and external APIs. So when the prompt appears, I'll just simply click allow. And after that, Lovable requests the OpenAI API key. Here I'm going to paste the secret key we created earlier and then just submit it. After that, Lovable takes care of the full implementation all on its own, writing up the back end so the app can analyze photos and then return detailed fish information.

When the integration is complete, the feature is ready to test. So, let's go ahead and upload a photo of a fish. And within a few seconds here, the app returns a full breakdown of the species. And the response includes all the details that we requested: biological characteristics, behavior patterns, diet, breeding info, environmental notes, and even a comparison to similar species. And better yet, we're also able to save the identified fish into our own collection directly from the results. And at this point, the app officially steps into true AI territory with OpenAI fully integrated and image recognition responding exactly the way we designed it. The core intelligence of the app is now in place and it's all built from a single structured prompt and one API key.

Now, one thing is for sure because once the app can identify a fish, most people start wanting a little bit more. Anyone who fishes knows that the hobby isn't just about recognizing what you caught, but also about knowing the seasons, the rules, the best practices, and the environment you're fishing in. Now, here I want the app to start to evolve from a simple scanner into a real fishing companion. I want to give my users tools that help them plan their trips, to understand regulations, and learn more about the ecosystems that they're exploring.

And in order to build that out, I'm just going to ask Lovable something like this.

"Build additional features such as fishing and marine utilities. Give the app some fishing season recommendations, local fishing regulations, size and weight guidelines, catch and release recommendations, and marine ecosystem insights. Make this as comprehensive as possible to give the user more tools for their fishing journey."

So, after sending in that prompt, Lovable expands the application with a brand new tools section. And here inside we'll find organized topics covering everything that we asked for: seasonal fishing recommendations, local regulations, size and weight guidelines, and even catch and release tips and deeper educational insights about marine ecosystems. And each topic opens into its own detailed content. And I went through the different sections to make sure that everything loaded properly. And with this update, the app feels much richer and far more useful for pretty much anyone who wants guidance beyond just identifying a fish.

So, a big part of fishing is the storytelling, logging what you caught, sharing interesting finds, and checking out what other people are also pulling in. And most anglers love comparing notes, and having a place to do that right inside our app makes the experience feel a lot more personal. So, the next step is to create a community space where our users can post their catches, get feedback, and keep their own private journal of sightings and memorable fishing moments.

So, to set this up, I'm just going to prompt Lovable with:

"Create a dedicated community section where users can submit fish sightings, tag posts, and have the community help verify their catches. Create a fish spotting journal and the ability to share their catches through social media."

Once Lovable starts working on this, it may come back with a few follow-up questions to better understand how the feature should function. And in my case, it's asking me how the verification system should work, whether the journal should be private, and what method to use for social sharing. So, let's respond that verification could simply be shown with a badge. The journal should be private by default and social sharing can use a generic share mechanism.

After Lovable processes all of that, the new features begin appearing inside of our app. You'll see a fishing journal widget right here on the dashboard and you can open it to log an entry right here on the spot. And once you save it, the entry immediately shows up confirming that the journal works exactly the way it should. And now from there, let's head into the community section. Let's open up any post and tap the verify badge to help confirm someone's catch. Let's also try to scroll through the comments to leave our own and then interact with others just like you would within a real fishing community. All I can say is this app is now a space where people can get together and connect to share their experiences and keep track of their fishing journey.

At this point, all the features inside of Lovable, they're ready to go. So, the final step here is to make the project publicly accessible. So, Despia can then package it into a native app. Now, this part is simple but essential. So, all right, we'll start with clicking the publish button. Then, we are going to set who can access to anyone, update the URL ID to something cleaner, and then we'll publish the project.

Once the app is live, we do need to copy the generated link. And that link is what we'll bring into Despia in the next video as we move into the iOS build process.

Now that the app is published on Lovable, it's time to bring everything into Despia so that we can turn our web build into a full iOS app. And I'll start by heading over to Despia and creating a new project. After that, let's fill in the basic details including the app name. In this case, "fish identifier" and then paste the web app start URL that I copied from Lovable. And once the project is created, we can now move to the left panel here and scroll down until we reach the iOS icon upload section. Here we are going to upload the app's main icon. And just below that is the upload area for the splash screen. So, I'll go ahead and drop in the splash image as well. And as soon as those assets are uploaded, the Despia project is now fully set up and ready to move forward. And everything is now in place for the next step where we'll connect the Apple developer account.

So, Despia can handle building and submitting the app to the App Store. Now before Despia can build and submit our app to the app store, it does need permission to communicate with our Apple developer account. So this step is all about just connecting those two systems so that everything can work together behind the scenes. And we're going to start by opening up my Apple developer dashboard here and then going to Certificates, Identifiers & Profiles. So here at the top right, let's go ahead and grab my Development Team ID and then paste it into the Development Team ID field inside of Despia. Next, we'll switch over to App Store Connect and then open Users and Access. Under the Integrations tab, copy the Account Issuer ID and paste that into Despia as well. For the final part, we do need to generate an API key that Despia will use for submitting builds. Now still inside Users and Access, we'll also create a new App Store Connect API key, give it a name like "daspia-fishfinder," and then set the access level to App Manager. So after generating the key, let's copy the Key ID, download the .p8 file, and then upload both into Despia. Once all three sections are filled in, we can now click the "Link with Apple" button. After that, Despia connects everything together and we have to make sure to select our newly linked account so the app is ready for the next step.

All right, so keep in mind that an app can't go anywhere near the App Store without being properly registered inside Apple's system. And that means we need to give your app its official identity card. Apple wants to know exactly what the app is, what features it plans to use, and what components belong to it. And that's why configuring the app project and creating bundle identifiers is such an important part of the process here. These identifiers act like anchors that tie everything together: push notifications, app groups, widgets, App Clips, Share extensions, all of it. And without them, Despia won't be able to build or sign the app correctly. So, this may not be the most glamorously visual part of the build, but it is the foundation that allows every feature you've added so far to actually function on a real iPhone.

So, to begin configuring everything, let's go to the Identifiers section here inside Certificates, Identifiers & Profiles, and my Apple developer account. So, the first item that we need to create here is the App Bundle ID. I'll take the bundle ID that Despia generated for our project and then head back into the Apple developer dashboard and from there we will create a new identifier. Choose App IDs, select App, and paste the bundle ID into the field. I'm also adding the app's name in the description and enable the required capabilities: App Groups, Associated Domains, iCloud with CloudKit support, and Push Notifications with broadcast capabilities. And then we need to save the identifier to lock it in.

So next, we're going to set up the OneSignal target, which is responsible for handling push notifications for our app. Now, Despia provides a separate bundle ID specifically for this. So, I will copy the OneSignal bundle ID and then head back into the Apple developer dashboard to create a new identifier. And here I'm going to create a new identifier, choose App IDs, select App, and paste the bundle ID into the field. For the description, I'll just write the app's name followed by "OneSignal" so it's easy to identify later. Then I'll enable the necessary capabilities like App Groups, Associated Domains, and Push Notifications with broadcast capabilities. And then after that, I'm just going to save the identifier.

And since we are done with those, now we will now create the corresponding App Group that OneSignal needs. I'm going to create another identifier, but this time I'm just going to select App Group. So I'll copy the Group ID from Despia, paste it into the identifier field, and then name it using the app's name plus "OneSignal App Group." So after saving this, we need to return to the OneSignal identifier that we just created earlier. And under the App Groups capability, let's open the configuration settings here and then add the newly created App Group. And after saving those changes, the OneSignal target is now fully linked and ready for Despia to use.

After completing the OneSignal setup, we're going to register the App Clip version of the app. So, an App Clip is a lightweight mini version of the app that users can access quickly without installing the full application. And Apple requires its own identifier and App Group for it to function properly. Now, again, to set this up, I'm going to create a new identifier in the Apple developer dashboard here and I'm going to choose App IDs. From there, I will select App Clip as a type and in the Product Name, I'll just write "Clip." And in the Parent App ID field, I will also choose our main app bundle ID. So the Clip is correctly tied to the full app. After clicking continue, I'll give it a clear description using the app's name and again followed by "App Clip." Then I'll enable the required capabilities for this one: App Groups, Associated Domains, and Push Notifications. And then I'm going to save the identifier.

Once the App Clip identifier is created, we will set up the App Group it needs to access shared data. I'm going to create another identifier. Then I'll select App Group and paste in the Group ID provided by Despia. For the description, I'll write the app's name followed by "App Clip App Group." After saving that group, I will return to the App Clip identifier that we created earlier. Under the App Groups capability, I'll open the configuration settings and attach the App Clip App Group that we just registered. And once it's saved, the App Clip setup is complete and ready for Despia to use.

Next up, we're going to set up the Share Target, which allows the app to receive shared content directly from other apps on iOS. So, to begin, I will copy the Share Target bundle ID provided by Despia and head back to the Apple developer dashboard to create a new identifier. It's the same process here. I'm just going to choose App IDs, select App, and paste the bundle ID into the Bundle ID field. So for the description, let's write the app's name followed by "Share Target" so it is easy to recognize later. And since this feature only needs shared data access, we do need to enable the App Groups capability and save the identifier. After that, we will create the App Group that the Share Target will use. And we need to create another identifier. So select App Group and paste the Group ID from Despia into the identifier field. I'll name it using the app's name followed by "Share Target App Group." Then I'm going to save the group. And now let's go back to the Share Target identifier here under the App Groups capability. I will open the configuration panel and attach the Share Target App Group that we just registered. After saving all those changes, the Share Target is fully linked and ready for Despia to include in the final build.

So the next component we need to register now is the Widget. This one allows the app to show glanceable information right onto the user's home screen. So to start this part of the setup, we will again follow the same old process where we're going to copy the Widget bundle ID from Despia and then head back into the Apple developer dashboard to create a new identifier. Now I'm going to choose App IDs, select App, and paste the bundle ID into the field. So for the description, we'll just use the app's name followed by "Widget." Then we need to enable the App Groups capability and save the identifier. And once that part's done, we will create the corresponding App Group the Widget will rely on. Now I'm going to create another identifier here. Select App Group and paste the Group ID provided by Despia. As for the name, I'll just write the app's name followed by, you guessed it, "Widget App Group." After saving it, we can now return to the Widget identifier that we just created. Under the App Group section, I'll open the configuration menu and attach the Widget App Group. And with that saved, the Widget component is now fully configured.

Now after completing all the individual targets: OneSignal, App Clip, Share Target, and Widget, we need to link every App Group back to the main bundle so that the full app can access all shared data properly. So to do this, we need to open the main app bundle identifier, go to the App Groups category, and select all of the App Groups that we created earlier. And saving that final step ensures everything is connected exactly the way that Apple expects.

Once these identifiers are in place, we can move into App Store Connect to register the actual app. So, let's go to the Apps section in App Store Connect and create a new iOS app. Here, I'm just going to enter the app's name, "Fish Identifier," "ScanFish" in my case, and set the language to English. For the Bundle ID, we'll select the main app bundle ID that we just configured. And for the SKU, I'll write the app's name in all caps. We will also set the user access to Full Access. And after creating the app, we need to go to the App Information page and copy the Apple ID assigned to it. Then let's return to Despia and then paste that Apple ID into the App Store App ID field so that everything stays synced. At this point, the entire Apple configuration is now complete and the next project is ready for the next phase.

We're going to integrate RevenueCat to handle subscriptions and paywalls. All right, so once the app is taking shape visually and technically, the next big question is how is it actually going to make money? A lot of people want to offer a free experience upfront, but lock more advanced tools or unlimited scans behind a subscription. And that's exactly where RevenueCat comes in. It'll handle all the subscriptions, the paywalls, and purchase logic so we don't have to build all of that from scratch. So in this part, we're going to connect RevenueCat to our project through Despia so that the app can support real in-app purchases and recurring subscriptions in a clean, reliable way.

All right, so let's start here. I'm going to go to RevenueCat and I'm going to create a new project. Let's make a fresh project and give it a name that matches my app. Something like "Fish Identifier" works pretty good, but you can call it whatever fits your app. I'll also set the category to Lifestyle so it lines up with how the app will be positioned in the store. And for the platform, I'm going to choose Native Apple since Despia will be handling the iOS build and we do want RevenueCat to be ready to work directly with the Apple ecosystem. Okay, so after creating this project, we'll have the base space inside RevenueCat where all of our products, our entitlements, offerings, and payments will live.

The next part of the setup is configuring the app inside RevenueCat. So, it knows exactly which Apple project it belongs to. And this is what allows RevenueCat to communicate with App Store Connect on our behalf and then manage subscriptions without any manual handling later on. I'll start by going to the Apps and Provider section in RevenueCat here and then creating a new app configuration. When prompted, I am going to choose the App Store as the platform since that is where our subscription products will live. Now, to link everything correctly, let's copy the App Bundle ID again from Despia and then paste it into RevenueCat. RevenueCat also needs the Apple credentials that allow it to read subscription information and process purchases. After that, let's head into App Store Connect. Open the In-App Purchase area and create a new key. I'm going to give it a name, something clear like "Fish Identifier Revenue." Then I'm going to download the .p12 key file. And back in RevenueCat, we will upload that file and then return to App Store Connect to copy the Issuer ID, which I am going to paste into RevenueCat as well.

Now, there's one more connection that RevenueCat needs and that's the App Store Connect API key. So to create this, we need to go to the App Store Connect API section in App Store Connect, generate a new API key, and name it "Revenue API," and then let's set the access level to App Manager so it has the proper permissions. Then download the key file. We'll upload that key into RevenueCat and paste the same Issuer ID from earlier to keep everything consistent. Now, the last detail RevenueCat is asking for is the Vendor Number. And here we have the link. I'm going to click it. I'm going to copy the Vendor Number shown in the top left corner. And then I'm just going to paste it back into RevenueCat. And once you're done filling out all of those fields, I'm going to save the configuration. And there you go. RevenueCat is officially connected to the Apple side of our app.

Once RevenueCat is linked to our Apple project, we can set up the actual subscription that the app will offer. Now, this happens inside App Store Connect where all in-app purchases are officially registered. I'm going to open the Subscription section in the Apps dashboard and create a new subscription group. I'll name the group "Pro Access" since this will be the identifier we use throughout both RevenueCat and our app to reference the premium features. Next, I'll add a new subscription inside it. Now, for the reference name, I'll use "Monthly Subscription" and I'll set the product ID to "monthly_paywall," which keeps everything clear and easy to track across systems. Now, let's choose the regions where the subscription will be available. I'm setting it to worldwide so that users everywhere can access it. And then enter the subscription price, which in my case is $9.99. And finally, after saving it, the subscription is now officially created and ready to be tied into RevenueCat.

The next step is to bring that product into RevenueCat so the two systems stay perfectly in sync. I'm going to go to the Product Catalog inside RevenueCat and open the Products tab and the App Store section. There's an option to import products directly from my App Store Connect account. So, I'm going to click import. RevenueCat will list the available in-app purchases from the app and I'm going to select the "monthly_paywall" product that we just created. And after that, RevenueCat officially recognizes the subscription and this will become available for attaching to entitlements and paywalls later in the setup.

So, let's now take a look at Entitlement, which represents the premium access users unlock when they purchase a subscription. Here in the Product Catalog, we will go to the Entitlements tab, and I'm going to create a new one. We're going to name the identifier "pro_access" and give it a display name like "Pro Access." After that, we will attach the subscription product to it by selecting "Add your first product," opening the associated products field, and then just choosing the App Store product that we imported earlier. And doing this links the subscription to the actual benefit users receive once they subscribe.

And we will now move over to the Offering section to define how the subscription will appear inside of the app. RevenueCat uses Offerings to structure paywalls. So we're going to create a new Offering and name it "Default" since this will be our primary offering. Inside of that Offering, we will add a Package and select "monthly" as the identifier. In the description, we'll write "Monthly Subscription" and then assign the same "monthly_paywall" product that we created earlier. After saving that, RevenueCat now has a complete setup. The subscription exists. It unlocks a specific entitlement and it will be displayed inside the Default paywall offering.

The next step is setting up the actual paywall that users will see inside of the app. In RevenueCat, this is done through the Paywalls section. We will start by creating a new paywall and RevenueCat will display a variety of templates to choose from. Now, these templates give us a quick preview of different layouts and styles, so it is easy to pick one that matches the look and feel of our app here. After choosing a template, the paywall can be customized further to fit the branding. Everything from the header text to the overall layout can be adjusted. The offering for this paywall should be set to the Default offering that we created earlier. And under the Package settings, we will assign it to the monthly subscription product. And once the main structure is in place, the rest of the paywall can be personalized. So in this build, we're going to change the header to "Scan Everything." And we will also remove the extra buttons to keep the design more clean and focused. And now since everything is already looking pretty good, we can now publish the paywall by selecting "Publish Paywall" and confirming the changes.

So the final step in the Despia setup is connecting the project to RevenueCat so the app can access the paywall and subscription features we just started. So to do this, we're going to open RevenueCat and head to the API Keys section. Here we will copy the App Store API key assigned to the project. Then returning to Despia, we scroll down the left sidebar here until we find the RevenueCat integration panel and paste the API key inside the iOS Public SDK Key field. Next, RevenueCat needs to provide one more piece of information, the Project ID. We will go back to RevenueCat. We're going to open up the project settings, copy the Project ID, and then paste it into the Global Project ID field inside Despia. After both fields are finally filled in, everything is properly connected between Despia and RevenueCat. And it's at this point we can click "Publish Project" and let Despia process the update. And once that finishes, the app is officially configured to handle subscriptions through RevenueCat.

So at this point, the subscription system is fully configured behind the scenes, but the app itself still doesn't know anything about RevenueCat. So to make the paywall actually appear inside the app and allow users to purchase or restore access, we need to integrate RevenueCat's SDK directly into our Lovable project. This lets the app talk to RevenueCat in real time, checking if a user is subscribed, opening the paywall, listening for renewals or cancellations, and unlocking premium features. This step brings everything together so that the whole subscription system feels seamless from the user's perspective.

So to begin the integration, we're going to prompt Lovable to install RevenueCat's packages and configure them based on the entitlement we created earlier. Inside Lovable, we will use this prompt:

"Integrate RevenueCat and install its packages. Add a button to the dashboard page to open the default offering. Make sure the external user ID is the ID of the logged-in user. The entitlement is called pro_access. Listen for initial purchases, renewals, cancellations, and plan changes."

Okay. So after submitting this, Lovable will start preparing the setup and eventually ask for the RevenueCat API key. Instead of giving it the key, we will inform Lovable that Despia will handle that part. We only need the dependencies installed so the webhook can be wired correctly. And when Lovable asks for the key, we will respond with this: "Despia will handle the secret key. Just add the implementation."

Once Lovable finishes those changes, the next step is retrieving the webhook URL so that RevenueCat can send events back to the app. So to accomplish that, we're going to ask Lovable, "What is our RevenueCat webhook URL?" Depending on how the setup progresses, Lovable may either give us the URL or ask whether we want it created. If it asks, we simply respond with "Yes, please set it up." And after the webhook is generated, Lovable will request the secret key for securing the webhook. Now, this is a password we will create ourselves. Any random string of numbers and letters will work. And once the password is ready, we can just paste it into Lovable's field and complete the setup.

When the webhook URL is ready, we will copy it and switch over back to RevenueCat. In the RevenueCat dashboard here, we'll open up the Integrations panel, select Webhooks, and add a new webhook configuration. Here we will enter any name we want. Paste the webhook URL provided by Lovable and then type in "Bearer" followed by the password we created earlier for the Authorization header value. After saving the webhook settings, RevenueCat gives us the option to test it out. And by clicking "Send Test Event," RevenueCat will ping the webhook and show a response. If a green 200 code appears, that means the connection is successful and the integration is working properly. And that also means the app, Despia, and RevenueCat are all fully communicating with each other and premium access can be accurately tracked and managed.

All right, so the final stage of this build is submitting everything to App Store Connect. And this part simply just walks us through each requirement Apple needs before an app can go into review. So we'll go through the entire submission process step by step so every section is completed correctly. So starting from here, we need to generate a privacy policy. We'll go to privacypolicygenerator.info. Select the app option and create the policy for a full production release. Keep in mind that the answers should accurately reflect how your app handles data. But since this is a demo, we can just keep things simple and select "No" for the data collection fields. After generating the policy, we'll copy the link to use later in the submission process.

The next step is completing the Distribution Requirements inside App Store Connect. Now, this is where we provide Apple with the visual assets and app details they need before the review can begin. On the Distribution page, we'll start by uploading the screenshots: three iPhone screenshots and also a set of iPad screenshots. After uploading the images, we need to fill out the required text fields. Beginning with the Promotional Text set to "Fish Identifier, ScanFish," and a short description that reads "Fish Identifier is an advanced AI-powered fish collecting tool." All right. So now we're going to include terms in the Keywords field like "identification," "fishes," "hobbies," and the Support URL can be either the privacy policy link or a dedicated support page. We will also need to make sure the version number is set to 1.0.0 so it matches the configuration from Despia. Then add the copyright label "Fish Identifier 2025." After we complete all of that, we'll now scroll down and select the build that was uploaded from Despia earlier. Under the App Review Information section, we will also uncheck "Sign-in Required" since this demo doesn't use authentication. If your app uses login features, this setting should remain enabled. And finally, after reviewing everything we've done so far, we'll scroll back to the top and click "Save" to lock in all the changes.

And now the next part of the submission is setting up the App Information section. Here we'll fill out a few remaining details that help categorize and properly label the app within the App Store. We'll start by adding the subtitle "Fish Identifier, ScanFish," which appears right under the app name. For the Category, we'll select Utilities since that best aligns with the app's functionality. And because this app doesn't collect personal data, the Content Rights field can be set to "No." After that, we'll complete the Age Rating questionnaire by answering "No" to each item since the app doesn't contain any sensitive or restricted content. And once all of those fields are completed, we'll click "Save" to confirm the changes.

Next, we'll set the Pricing and Availability for the app. In the Pricing and Availability section, we start by selecting "Add Pricing" and choosing the "$0.00" option. Since this app will be released for free. After selecting the price, we review how it appears across different countries and regions. Then click "Confirm" to apply it. We can now move to Availability. Let's select "Setup Availability." Then let's choose "All Countries and Regions" to make the app accessible worldwide. After confirming the full list of regions, the app's pricing and distribution settings are now finalized.

Now, the last requirement we need to complete before submitting the app is the Privacy section. In the App Privacy area, we'll start by editing the Privacy Policy field and pasting the link we generated earlier. Then, we need to save it. And after that, let's click "Get Started" to begin Apple's data usage questionnaire. And even though this app doesn't collect personal information, Apple still requires the form to be completed. So we'll answer "Yes" to data collection. Now we will select "Other" as the data type since that best fits the type of content the app interacts with. We will now move through the remaining steps of the setup. We'll review the summary and then save the configuration. And since everything looks correct, we can now click "Publish" to finalize the app's privacy details.

Since all of the required information is now complete, the final task is submitting the app for review. So, we'll head back to the "Prepare for Submission" page here where each section of the setup is listed. And when everything shows as "Ready," we can just click "Add for Review," select the submission, and confirm it. And after that, the app is officially placed into Apple's review queue. And that's it. Our AI-powered fish identifier just went from concept to Lovable to Despia and to the App Store. All of that without touching a traditional code editor once. Not bad for a build that started as a blank canvas.

Now, if this process clicked for you too, then you're basically holding a blueprint you can reuse for any app idea you've been sitting on. Thanks for following along with me today and investing your time here.