From Idea to AppStore

Half a year ago I had an idea, and a few days ago (03/27/18) an application called "***" was published in the AppStore. But first things first.

It all started with a simple idea.

In our life some events constantly occur, good, bad, it doesn’t matter. I always wanted to record such things in order to later understand what led me to where I am.

All references to the name of the application are replaced by "***", because this article primarily carries an informational meaning, not an advertising one.

Notepad and pen, although a reliable way, but still you need to carry them with you and do not forget to write down, in addition, it is often just physically difficult to write something. However, we always have phones with us, so it was decided to create a website with functionality for recording such events.

Each event can somehow be described.

This is how the concept of the “ Type ” of the event arose , for example - you won the competition, this is a good event.

Since the types need to be marked somehow, and it so happened that at the beginning of development I read a lot of literature on web design - it was decided to use colors (everywhere they are mentioned about their influence on our mind).

At first the types were predefined - Good (Green) and Bad (Red). Of course, two types are not enough to describe our life, and other types began to appear - Fun, Stress, Problem, and so on.


With the appearance of the “Problem” type, a new vision has appeared - after all, problems appear, for some time affect our lives, and then they are solved (in most cases). It turns out that this event does not occur at the time, but in the interval! This means that events should also have the ability to have a duration.

Moreover, those events that occur now have a greater impact on us than those that have already ended. Combining all this into one concept, I came to the following - the event has a start date and an end date, and the type of event, in turn, has a separate color for current and past events (For example, for current Bad events, I used a bright red color, and for past Bad events - faded).

Everything was fine, but new types constantly appeared, and when tired of adding them manually - it was possible for the user to add their own types and customize their color.

Somewhere at this moment I decided to abandon the idea of ​​a website

There were two reasons:

  1. I wanted to be able to add events offline
  2. Using a website, no matter how adapted it is, is still inconvenient from a mobile

From a PC, of ​​course, memories could also theoretically be added, but in practice this always happened from the phone.

Memory golem

The name of the application has changed to the release in the AppStore, so you will not find such an application there

So the mobile application “Memory Golem” was born. The title deserves special attention, firstly, “ Events ” became “ Memories ”. Secondly, the word " Golem ", like a mythical creature from Jewish fairy tales, implied a kind of protection of these same memories.

For development, a hybrid option was chosen, namely the ionic framework . The reason for choosing is simple - I knew the angular , I knew Cordoba , and there was no particular desire to learn swift.
The server backend has always been in Java, specifically SpringMVC.

All current functionality migrated to the application, except for one detail - the way to save the memory. From now on, they were saved on a mobile device, completely offline. That is, the application can be used even on an airplane with all the functionality available.

However, if desired, the user can register and be able to save their memories on a remote server, and moreover, synchronize these memories between different devices (even on different OS).

The synchronization process deserves a short article, here I can only say that I have worked very seriously to ensure that any possible situations are resolved as the user would have expected.

Mobile platform made it possible to expand horizons

The first important step was the adaptation of the application to the state of the user. The meaning is this: the

user has “current” memories of a certain type, they by definition affect his life. Each type has a separate color for the current memory. So we can uniquely determine by transitivity which color now has an impact on the life of the user!

And if we can determine it, then we can display it. This is what I did - the application got the opportunity to change its color to the color of the most popular type among current memories.

There is a problem

The application has labels, what if the label is the same color as the color of the application? The answer is simple - the inscription should change its color.

Having studied this question in detail, I settled on the following solution: in order not to confuse the user with the number of colors, the possible text colors are only black and white, and in order to determine which one to use I used simple logic - the color that has a greater Euclidean distance from the current color applications.

Back to our Golem

He must protect. Accordingly, there should be a way to protect memories from third-party viewing. The classic solution is a password code that is set in the application and is used to lock / unlock memories.

The only difference from the same kind of solution in other applications is the ability to block not the entire application, but only individual memories. Such locked memories cannot be viewed or edited until you unlock them, but otherwise you can freely use the application.

Touch id
Of course, if touch / face ID is available, then it is used to unlock

Further statistics appeared

It is only logical if we write something down - we might want to see how much we wrote there. The statistics are simple:

  • amount of all memories
  • number of current memories
  • number of past memories

grouped by type of memory. All this is displayed in a nice-looking diagram, which can also be switched: Column -> Circular -> Radial.

At this stage, it seemed to me that the application can be released

But by chance, I caught the eye of the 3D model of the periodic table , and how it happened to me - I need to do the same at home.

I set to work, and a month later the application could already boast of the so-called “Memory Matrix” - a 3D model of the user's memory list, presented in 3 forms: Sphere, Spiral and Matrix. These models can be twisted, moved and edited memories directly on them.

Someone may say that the implementation is completely ripped off, but I do not agree - firstly, I transferred all the code from the example with the periodic table to a taip script in Angular realities, secondly, only calculated values ​​are given there, I calculated the surface area of ​​the sphere, the rise of the spiral and etc., to place all the memories there, as well as calculate the distance to the camera. Again, the elements in the table example are set, but I generate them dynamically. In general - I think the work has been done seriously.

The most difficult part was not even analytic geometry, but the number of displayed memories. And the thing is actually not the quantity, but the fact that it was intended for mobile devices, and the first time it was possible to display only 130 at a time (more than 200 applications crashed immediately), but after optimization this number was increased almost 4 times, and now 512 of the last memories are displayed.

This is not the limit for flagship smartphones, but a reasonable compromise in terms of weaker devices.

In the initial version, these figures were built only from existing memories, but to be honest, it only began to look decent from 30+ memories, which in theory would negatively affect the initial user experience


The application was almost ready for release, I looked at the icon, the name - and was depressed. Not that they were terribly bad, but the icon was frankly cheap (he painted it in inkspace), and the name, well, it was at least too long.

I started the change with the icon. My friend helped me a lot in choosing the latter, because I loved the details too much, so I wanted something like this:

But he reasonably noticed that minimalism was now in fashion, and helped me choose the one that now decorates the page in the AppStore.

And already with the change of the icon a new name was invented.

Release rejected

On the hub there are dozens of articles about the publishing process in the AppStore, I think many people know what the process is there, but if not, I’ll briefly tell you: Create an application in iTunes connect, fill in information like descriptions, screenshots, etc., then upload the build and publish it on the so-called Review.

I did not pass my first Review

The reason was just ridiculous: when you just download the application, it has no data, and since it adjusts its color to the data, it is initially black and white.

Apple representatives compared this result with screenshots where, for clarity, the memories were already filled, thought it was a bug, and redirected the application.

Of course, I appealed their decision, and as a result, they were allowed to publish, but by then I was already working on simplifying UX

Important lesson

It was unpleasant, but it allowed me to take a fresh look at UX. As a result, I redid almost the entire UI, added the initial data initialization, and simplified a lot of things. So, I think, as a result, it only improved the application. In the end, even if an Apple representative could not figure it out, then what should be expected from an ordinary user

Usability testing
I ran a couple of usability tests on those familiar with the new UX. In truth, not everything was perfect, but in general, a person will be able to create a memory with a very high probability

Finish line

After the debacle with the review and revision of the UI, I was ready to release the application. I added the privacy policy, made beautiful screenshots, came up with a tempting description, created a website for the application, put in a fairly detailed usage guide, updated the information for the reviewer just in case, so that it would understand everything and fill in the new build for the review.

The status of your app, "***", is now Ready for Sale

I received such a message from Apple at 5 in the morning, was incredibly happy, quickly checked everything in Test Flight, generated promotional codes for friends, published the application and went to study.

What is the moral of this story?

Like anyone who has gone through some difficulties, I want to help others avoid them, here is what I would like to know BEFORE I embarked on this path:

  • Be sure to check that what the reviewer sees when you install your application matches what is on the screenshots, even if the application behaves differently the first time it starts. Otherwise, you can run into a redject. It seems okay, but the sediment remains. (Another option is to describe all the differences and their causes in the notes to the review)
  • Usability testing is a must. By the end of development, you get so accustomed to the application that you can’t even imagine how any concept may not be understandable to the user, especially if the idea in your head has evolved for a long time before you come to what it has become
  • If the hybrid application is localized via js, this does not mean that the AppStore will know about it. You must configure localization in Xcode (EXCEPT localization in iTunes connect), otherwise it will work out like mine - although the application has a Russian name in the Russian-language AppStore and all the texts inside are correctly localized - when installed on the device, it has a name in English, therefore that I did not configure localization in Xcode. I hope to fix this in the next update.
  • If you plan to release a hybrid application on iOS - without a poppy just nowhere.
  • The ability to test a hybrid application in a browser is certainly convenient, but useful only at the very beginning. After connecting any plug-in that works with native functions, all testing must necessarily take place on the device or simulator.


Open libraries that really helped in building the application (even wondering if there are some of these things on swift)

Also popular now: