MeerMost

How I Learned Swift from Scratch in December 2022 — and Why My First Product Failed

In December 2022, I decided to learn Swift and build my own app. A year and a half of development, a release on the App Store, 500 downloads, and exactly zero rubles in revenue. This isn't a success story. It's a breakdown of how I learned and where I could have saved myself a year if I'd known then what I know now.

December 2022. Why iOS at all

By that point I already had experience in sales, CRM, and business process automation. I wrote SOPs, built funnels in AmoCRM, and handled integrations through contractors. I had the technical basics, but I couldn't write code myself.

The idea for the app came out of personal experience. I was learning English and couldn't find a tool that had what I actually needed. My own dictionaries, simple flashcard practice, social mechanics. Duolingo is a strong social product, but the content isn't yours. Quizlet gives you your own content, but the wrapper is boring. I wanted a hybrid.

I chose native iOS and Swift. Not Flutter, not React Native. The logic was simple: learn the whole platform, so I could take on any project later.

A lot of people tried to talk me out of it. The usual arguments. "It's too late," "everyone's going into AI now," "native development is dying." Three years later it's clear: it's all nonsense. Today I have more than six apps on the App Store, I lead client projects as a lead developer, and native iOS is alive and kicking.

The first three months. Fog

December, January, February — I simply didn't understand anything. And that's not a figure of speech. I'd literally open the documentation and not understand a single word. What an optional is. What a generic is. Why a function has three ways to be declared. How a ViewController differs from a View.

I learned intuitively. I watched everything I could find. I read chunks of code from other people's projects. I tried to build examples from tutorials and broke them. It was wildly interesting and wildly slow.

The main takeaway from that period: in the first months, what matters isn't understanding, it's getting used to things. Getting used to the syntax, to the project structure in Xcode, to type and method names. Understanding comes later, once your brain stops panicking at the sight of unfamiliar words.

I wouldn't sign up for courses at that stage. A course takes you from point A to point B, but in the first months you don't know where your A is, and you don't understand whether you need point B. Better to watch and copy something concrete and personally useful to you.

February 2023. The mentor

In mid-February I started working with a mentor. And that was the turning point.

Not because the mentor "poured knowledge into me." But because I started getting feedback on my code. I'd write something, he'd look at it and say, "here you're doing it this way because you don't know about this other thing." Every session gave me five to ten specific questions I hadn't even known I needed to look up answers to.

The first working screen came together in February. A translate form with translation via the Google Translate API. Five or six elements, a text field, a button, the result. The joy was like closing my first deal in sales. Seems like nothing much, but it's yours — you built it yourself.

And right away, the first technical trap. Connecting Google Translate seemed simple. There's documentation, I got the key, I sent the request. But in reality everything broke at every step. Responses came back in the wrong format, async was confusing, network-layer errors told me nothing. I started drawing request and response diagrams on paper. Not to make them pretty, but to keep track of what was happening. That habit stuck with me. I still draw diagrams today, especially for complex data flows.

March, May. The slump

From March through May I started spending less time on Swift. Other things came up, day-to-day chores piled on, and my programming hours shrank to an hour and a half to two a day. The output of finished screens started slipping. Motivation tanked right along with the results.

A vicious circle. You work little, you move slowly, you get frustrated, you want to work even less.

During that period I temporarily stopped my sessions with the mentor. The logic was: "if I can't keep up with the assignments, there's no point in doing this." That was a mistake. The right move was the opposite — increase the frequency of feedback and shrink the size of the tasks. But I couldn't see that at the time.

What did work in the end. Pulling myself together by the end of June and raising my time from three to six or eight hours a day. Not because inspiration struck, but because I told myself honestly: either I finish it this year, or I never will.

The release. Reality vs. the plan

In July 2023 I wrote in the channel that there were seven weeks left until the first release. I sincerely planned a release by September and earnings by the end of the year.

Reality: the release happened on March 1, 2024.

A six-month slip. And that's a typical story, not an anomaly. I've talked to dozens of indie developers, and the picture is the same for all of them. Time estimates for your own projects are always underestimated by two to three times. When you work for a client, you count hours, because they're tied to money. When you work for yourself, you count hopes.

500 Downloads. 0 Revenue

Launch. The App Store approved it on the first try (already a good sign — see the separate article about rejections). I published it, shared the link in my channel, and asked friends to download it.

500 downloads. And that was it.

Revenue: 0 rubles. Conversion to a paid subscription was built in: three tiers — guest, signed-in, premium — with different limits. But nobody paid, because the app didn't solve anyone's real pain point. I built what I wanted to build, not what the market needed.

That failure was inevitable, and I'll explain why.

What I Learned in Hindsight

The main mistake was the order of the steps. I started by learning Swift. Then I started building the app. Only after that did I wonder whether anyone needed it. The right order is exactly the opposite: first validate demand, then learn what that demand calls for.

Here's what it should have looked like. I could have built a Telegram bot in a month that serves users word flashcards and collects usage stats. That's validation. Do people actually come back to those flashcards? Are they willing to pay for advanced features? And only once I saw the numbers, move to native iOS.

I applied that lesson on the projects that followed. When MeerGuard came along, I didn't go straight to an iOS app — I started with a Telegram bot. The hypothesis held up, and only then did we expand the product into a Mini App, a website, and an iOS client. Today MeerGuard has 12,000+ users, and 2,000+ of them have paid for a subscription. The difference in approach is obvious.

You can learn a programming language by starting from a product instead of theory. I genuinely envy people who can read theory for months and then apply it. That's not how I work. I need to learn whatever a specific task requires right now. It leaves huge holes in my fundamentals, but it keeps me moving. Theory-first people are the exact opposite: they know a lot and do little.

A mentor pays off when you have no rhythm. In January, when I didn't even understand syntax yet, I didn't really need a mentor. I wasn't asking the right questions. By June, he was invaluable. When you have code you just wrote and someone can take an hour to explain what you did wrong — that's the most expensive and highest-return form of learning.

Motivation works as a function of results, not the other way around. For a long time I waited for the "inspiration to work" to appear. It never came. The opposite happened. When I started actually working six to eight hours a day, the inspiration showed up a week later. Action first, emotion after.

Where Things Stand Now

I'm relaunching Meerno from scratch on SwiftUI. v1 was on UIKit with programmatic layout, no storyboards. I wouldn't pick that architecture now. SwiftUI is faster and cleaner, and the ecosystem has matured over the past two years. Monetization and onboarding are completely reworked. There's no illusion anymore that "great features sell themselves."

In parallel, I'm running client projects, and each one adds real knowledge to the bank that no tutorial can give you. On No Sugar Challenge, I worked through moving from monolithic JSON to an event-driven architecture with Firestore sync. On Calorie Counter — AI food recognition via GPT-4o. On Loyalty Cards — Apple Wallet integration through PassKit with certificate signing.

If I could go back to December 2022, I'd tell myself one thing. First, find someone who will pay you at least 5,000 rubles to solve their problem, and then learn the language for that task. Everything else will follow.

What's Next

Planning your own iOS app? Don't repeat my first attempt. Estimate the cost and timeline or get in touch, and we'll pressure-test your hypothesis before you spend six months on development.

All articles

Related articles

iOS App Development: The Stages and What's Inside Each One
Development

iOS App Development: The Stages and What's Inside Each One

iOS app development stages from the inside: product, UI, server, subscriptions, push notifications, and the App Store. Short how-tos for setting up each part, with Xcode and App Store Connect screenshots.

24 min read
App Promotion with No Ad Budget: ASO Step by Step
Marketing

App Promotion with No Ad Budget: ASO Step by Step

How to promote an app in the App Store and Google Play without ads: where to find keywords for free, what to put in the three fields, and why you need to get it done before release.

6 min read
How Much Does Mobile App Development Cost and What Goes Into the Price
Business

How Much Does Mobile App Development Cost and What Goes Into the Price

We break the cost of an app into three parts: the work itself, everything that wraps around the release, and the price of a mistake in review. With an open price list and the items that usually don't make it into an estimate.

6 min read