Forem: eniamza

PocketPal X DeepScaleR 1.5B Preview | Locally Run a not-shitty reasoning model easily!

eniamza — Thu, 13 Feb 2025 22:34:54 +0000

The Drama and The Breakthrough

After the release of Deepseek R1, the market and the consensus of general consumers of ChatGPT went berserk! Nvidia's stock went roller-coaster mode. Sam Altman had very few nails left to bite and Elon Musk as usual poked OpenAI and offered to buy the Org for 97.4 Billion Dollars which Sam of course declined.

Amid all the drama and media hype, A team named Agentica dropped a distilled 1.5 Billion Parameter version named agentica-org/DeepScaleR-1.5B-Preview based on Deeseek R1 surpassing the o1-preview in the Math 500 benchmark and doing decent in other benchmarks too!

However, I would rather not rely on a benchmark to measure a model's performance. As Goodhart's Law says:

When a measure becomes a target, it ceases to be a good measure

The best way to measure a model is to vibe with it!

On a phone? Really?

Yup! In today's blog, we are going to vibe with the new model on our very little, cute-looking phone and run the model at a decent speed. All thanks to the 1.5B Parameter version!

We are going to use a GGUF Quantized Version from bartowski to achieve the maximum performance possible.

A cool FOSS app named PocketPal AI. Which is absolutely free and open-source to the moon!

Installing the PocketPal AI.

PocketPal AI is both Available for Android and iOS

After the installation, the rest of the process is pretty straightforward.

Step 1: Go to the "Models" Tab

On the models tab, you will find a lot of open-source and ready-to-use LLM models just one click away, but we are interested in something else!

To download DeepScaleR 1.5B, Click on the (+) icon at the bottom-right corner of the screen. and click "Add from Hugging Face"

Step 2: Search the model

On the search box at the bottom of the screen, Type "DeepscaleR" At the top of the search results you should see a model named agentica-org_DeepScaleR-1.5B-Preview by Bartowski.

Step 3: Download the model

Tap on the result and you should see a list of available GGUF (GPT-Generated Unified Format) Files. GGUF is a popular Quantization format designed to be efficient and perform well on consumer-grade hardware.

If you feel confused about which one to download here's a reference for your convenience fetched from Bartowski's Repository.

Filename	Quant type	File Size	Split	Description
DeepScaleR-1.5B-Preview-f32.gguf	f32	7.11GB	false	Full F32 weights.
DeepScaleR-1.5B-Preview-f16.gguf	f16	3.56GB	false	Full F16 weights.
DeepScaleR-1.5B-Preview-Q8_0.gguf	Q8_0	1.89GB	false	Extremely high quality, generally unneeded but max available quant.
DeepScaleR-1.5B-Preview-Q6_K_L.gguf	Q6_K_L	1.58GB	false	Uses Q8_0 for embed and output weights. Very high quality, near perfect, recommended.
DeepScaleR-1.5B-Preview-Q6_K.gguf	Q6_K	1.46GB	false	Very high quality, near perfect, recommended.
DeepScaleR-1.5B-Preview-Q5_K_L.gguf	Q5_K_L	1.43GB	false	Uses Q8_0 for embed and output weights. High quality, recommended.
DeepScaleR-1.5B-Preview-Q5_K_M.gguf	Q5_K_M	1.29GB	false	High quality, recommended.
DeepScaleR-1.5B-Preview-Q4_K_L.gguf	Q4_K_L	1.29GB	false	Uses Q8_0 for embed and output weights. Good quality, recommended.
DeepScaleR-1.5B-Preview-Q5_K_S.gguf	Q5_K_S	1.26GB	false	High quality, recommended.
DeepScaleR-1.5B-Preview-Q3_K_XL.gguf	Q3_K_XL	1.18GB	false	Uses Q8_0 for embed and output weights. Lower quality but usable, good for low RAM availability.
DeepScaleR-1.5B-Preview-Q4_1.gguf	Q4_1	1.16GB	false	Legacy format, similar performance to Q4_K_S but with improved tokens/watt on Apple silicon.
DeepScaleR-1.5B-Preview-Q4_K_M.gguf	Q4_K_M	1.12GB	false	Good quality, default size for most use cases, recommended.
DeepScaleR-1.5B-Preview-Q4_K_S.gguf	Q4_K_S	1.07GB	false	Slightly lower quality with more space savings, recommended.
DeepScaleR-1.5B-Preview-Q4_0.gguf	Q4_0	1.07GB	false	Legacy format, offers online repacking for ARM and AVX CPU inference.
DeepScaleR-1.5B-Preview-IQ4_NL.gguf	IQ4_NL	1.07GB	false	Similar to IQ4_XS, but slightly larger. Offers online repacking for ARM CPU inference.
DeepScaleR-1.5B-Preview-IQ4_XS.gguf	IQ4_XS	1.02GB	false	Decent quality, smaller than Q4_K_S with similar performance, recommended.
DeepScaleR-1.5B-Preview-Q3_K_L.gguf	Q3_K_L	0.98GB	false	Lower quality but usable, good for low RAM availability.
DeepScaleR-1.5B-Preview-Q2_K_L.gguf	Q2_K_L	0.98GB	false	Uses Q8_0 for embed and output weights. Very low quality but surprisingly usable.
DeepScaleR-1.5B-Preview-Q3_K_M.gguf	Q3_K_M	0.92GB	false	Low quality.
DeepScaleR-1.5B-Preview-IQ3_M.gguf	IQ3_M	0.88GB	false	Medium-low quality, new method with decent performance comparable to Q3_K_M.
DeepScaleR-1.5B-Preview-Q3_K_S.gguf	Q3_K_S	0.86GB	false	Low quality, not recommended.
DeepScaleR-1.5B-Preview-IQ3_XS.gguf	IQ3_XS	0.83GB	false	Lower quality, new method with decent performance, slightly better than Q3_K_S.
DeepScaleR-1.5B-Preview-IQ3_XXS.gguf	IQ3_XXS	0.77GB	false	Lower quality, new method with decent performance, comparable to Q3 quants.
DeepScaleR-1.5B-Preview-Q2_K.gguf	Q2_K	0.75GB	false	Very low quality but surprisingly usable.

If you have a phone model of 2024 and later, I would suggest starting with the Q6_K_L Variation and if it performs well, gradually try Q8_0

In this walkthrough, I will be using the Q8_0 for the perfect balance.

Step 4: Wait for it to download and Load the model

After the model is downloaded, it should appear in the Models Tab at the top

Tap on the "Load" button of the model Card and we are good to go!

How's the vibe?

The most fun and controversial prompt for the LLMs is How many Rs are there in the word Strawberry?. On popular demands, of course, I asked it first

The model surprisingly was fast. It reasoned for around 3 minutes and counted the Rs letter by letter. Answered within another minute. The answer was correct.

Q: How many Rs are there in the word strawberry

<think>
Okay, so I need to figure out how many times the letter 'R' appears in the word "strawberry." Let me start by writing out the word to make it clearer: S-T-R-A-W-B-E-R-R-Y. Hmm, wait, no, maybe I should count each letter as I go through it.

First, let's break down the word "strawberry" letter by letter. I know that "strawberry" is a type of fruit, but I'm not sure about the exact spelling. Let me confirm: S-T-R-A-W-B-E-R-R-Y. Wait, actually, I think the correct spelling is S-T-R-A-W-B-E-R-R-Y, but maybe I'm overcomplicating it. Let me just focus on the letters as they are.

The word is: S, T, R, A, W, B, E, R, R, Y. Wait, no, I think I made a mistake here. Let me actually spell it correctly. The correct spelling of strawberry is S-T-R-A-W-B-E-R-R-Y. So that's 10 letters. Let me list them again:

1. S
2. T
3. R
4. A
5. W
6. B
7. E
8. R
9. R
10. Y

Now, looking through these letters, I need to count how many 'R's there are. Let's go step by step:

- The first letter is S, not R.
- Second letter is T, not R.
- Third letter is R. That's one R.
- Fourth letter is A, not R.
- Fifth letter is W, not R.
- Sixth letter is B, not R.
- Seventh letter is E, not R.
- Eighth letter is R. That's the second R.
- Ninth letter is R. That's the third R.
- Tenth letter is Y, not R.

So, counting the R's: the third letter, the eighth letter, and the ninth letter. That makes three R's in total.

Wait a second, I think I might have missed something. Let me recount. The word is S-T-R-A-W-B-E-R-R-Y. So, positions 3, 8, and 9 are R's. That's three R's. Alternatively, maybe I should count the letters more carefully. Let's write them out:

S, T, R, A, W, B, E, R, R, Y.

So, the letters are:

1: S

2: T

3: R (1)

4: A

5: W

6: B

7: E

8: R (2)

9: R (3)

10: Y

Yes, that's three R's. So the answer should be three R's.

But wait, sometimes people might count differently, but in this case, each R is clearly identified. So, I think three is correct.

Final Answer
The number of R's is \boxed{3}.
</think>

To determine the number of 'R's in the word "S T R A W B E R R Y", we need to carefully check each letter:

1. S
2. T
3. R (1)
4. A
5. W
6. B
7. E
8. R (2)
9. R (3)
10. Y

By counting each 'R', we find that there are three 'R's in the word.

The number of R's is 3.

That was accurate!

The next question I asked was about a simple real-world store scenario-based calculation, basically a school-level problem

Q: If a store sells apples for $0.75 each and oranges for $0.50 each, how much would it cost to buy 3 apples and 2 oranges?

<think>
Alright, let's tackle this problem step by step. The store sells apples for $0.75 each and oranges for $0.50 each. We need to find out how much it would cost to buy 3 apples and 2 oranges.

First, I'll calculate the cost of the apples. Each apple costs $0.75, and we want to buy 3 apples. So, I'll multiply the cost per apple by the number of apples:

$0.75 * 3 = $2.25

So, the apples will cost $2.25.

Next, I'll calculate the cost of the oranges. Each orange costs $0.50, and we want to buy 2 oranges. So, I'll multiply the cost per orange by the number of oranges:

$0.50 * 2 = $1.00

So, the oranges will cost $1.00.

Now, to find the total cost, I'll add the cost of the apples and the cost of the oranges together:

$2.25 + $1.00 = $3.25

Therefore, buying 3 apples and 2 oranges would cost $3.25.
</think>

To determine the total cost of purchasing apples and oranges, follow these steps:

1. Calculate the cost of the apples:
   - Each apple costs \$0.75.
   - Number of apples to buy: 3.
   \[
   \text{Total cost for apples} = 0.75 \times 3 = 2.25
   \]

2. Calculate the cost of the oranges:
   - Each orange costs \$0.50.
   - Number of oranges to buy: 2.
   \[
   \text{Total cost for oranges} = 0.50 \times 2 = 1.00
   \]

3. Add the costs together to find the total cost:
   \[
   \text{Total cost} = 2.25 + 1.00 = 3.25
   \]

Final Answer:
\[
\boxed{3.25}
\]

The model reasoned for around 2 minutes and answered correctly! Although there are some formatting errors related to Latex which we used to see on the earlier version of GPT models. But we can easily sanitize that by running it through a lighter model (More on that in a future blog)

Okay, Last question, LLMs are popular for writing crappy, gibberish, and overly complex codes. But hey! if it works, it works!

Q: Write a recursive function for in order traversal

<think>
Alright, I need to write a recursive function for in-order traversal of a binary tree. Let me think about how in-order traversal works. In in-order traversal, we visit the root node, then recursively visit the left subtree, and then recursively visit the right subtree. So the order is left, root, right.

I should define a function that takes a node as an argument. For each call, I first traverse the left subtree. Then, if there's a node (which it always will be in this context), I visit it, typically by printing or something. Then traverse the right subtree.

Wait, but the problem is just about writing the function, not the output. So perhaps the function should count the number of nodes visited, but that might complicate things. Alternatively, perhaps the function should return the count or something else.

But perhaps the function is intended to just traverse the tree in order, without returning any specific value. So maybe I can just implement the traversal logic.

I'll start by writing a function that takes a node as an argument and doesn't return anything. Then, for each call, it will traverse the left subtree, then itself, then the right subtree. That way, it's a standard in-order traversal.

I should make sure that the function handles null nodes correctly. When the node is null, it just returns. Otherwise, it proceeds to the left, itself, and right.

Let me outline the steps:

1. If the node is null, return.
2. Traverse the left subtree.
3. Visit the current node.
4. Traverse the right subtree.

This should implement the in-order traversal correctly.

I think that's the plan. Now I'll write the code accordingly.
</think>

To perform an in-order traversal of a binary tree, we can define a function that recursively visits the left subtree, then the root node, and finally the right subtree. Here's how we can do it step by step:

1. Base Case: If the current node is null (i.e., it's a leaf node or beyond the tree), return immediately.
2. Traverse Left Subtree: Recursively call the function on the left child of the current node.
3. Visit Current Node: This step can be omitted if we just need to traverse the tree and not collect any specific data from each node.
4. Traverse Right Subtree: Recursively call the function on the right child of the current node.

This approach ensures that we visit each node exactly once in the order: left, root, right.

Here is the implementation of the in-order traversal:

void InOrderTraversal(node* node) {
    if (node == nullptr) {
        return;
    }

    // Traverse left subtree
    InOrderTraversal(node->left);

    // Visit current node
    // (Note: If data is needed from current node, add the data here)

    // Traverse right subtree
    InOrderTraversal(node->right);
}
This function correctly traverses each node exactly once in an in-order manner. The time complexity of this algorithm is O(n), where n is the number of nodes in the tree, as each node is visited exactly once. The space complexity is O(h), where h is the height of the tree, due to the recursion stack.

The model reasoned for 5 minutes and wrote the algorithm for inorder traversal recursively as instructed. Interestingly, while most LLMs prefer Python, DeepScaleR replied in C++!

Bonus Question

Q: Write a recursive function to count level-order nodes, you can't pass anything other than the root node as the input parameter as the function

DeepScaleR reasoned for around 12 minutes and then something abruptly stopped the thinking process and never returned any actual answers. Given that the problem itself is quite hard and almost paradoxical for LLMs to solve, we can see the clear confusion and self-contradiction in its thinking process.

<think>
Okay, I need to write a recursive Python function to count all the nodes in a binary tree without using a dictionary as an input parameter. The function must be recursive. Let me think about how to approach this.

First, I know that a binary tree node has left and right children. So each node can be represented as an object with data and pointers to left and right children. But since it's a Python function, perhaps I can represent the tree nodes using a class or just use tuples. But since the function needs to be recursive, perhaps using objects is easier.

Wait, but in the function, perhaps it's better to pass around each node as a parameter. However, since the function isn't allowed to use a dictionary as input, maybe I need to track the nodes as I traverse them without using a dictionary to collect them. Hmm, perhaps I should instead count the nodes during the traversal, but without storing all the nodes in a dictionary.

Wait, perhaps the function can perform an in-order traversal, count each node as it's visited, and sum them up. But the problem is, how to count without using a dictionary as an input parameter. Wait, perhaps the function can be structured to count nodes during the traversal.

Alternatively, perhaps the function can be written to traverse the tree recursively and keep a counter that increments each time a node is visited. But in that case, how do we avoid storing the nodes in a dictionary? Because the function needs to return the count, not the actual nodes.

Hmm, perhaps the approach is to write a helper function that takes the root node and a counter, and during each recursive call, if a node is found, increment the counter. Then, the main function can call this helper and return the counter.

But wait, the problem says the function must be recursive and not use a dictionary as an input parameter. So perhaps the function itself should not have any parameters except maybe for the root and a counter. But perhaps that

It just ended there, rephrasing the prompt and allowing it to use helper functions didn't help much either.

Cool, now what

Well, this is just the first step towards Reasoning models on ARM chips. Observing the quick progress that happened within the last month, we can expect major improvements in this field in the near future.

JARVIS, a capable AGI from the movie Iron Man is not fiction anymore ;)

Till the next drop, sayonara!

References

Agentica's Model: https://huggingface.co/agentica-org/DeepScaleR-1.5B-Preview
Bartowski's GGUF Version: https://huggingface.co/bartowski/agentica-org_DeepScaleR-1.5B-Preview-GGUF
PocketPal AI: Android , iOS and GitHub

CUPP: How Dictionary based Bruteforce Attacks can be more optimized

eniamza — Sat, 05 Oct 2024 16:18:03 +0000

What is a Dictionary Attack?

In most of the Sci-Fi movies, generally, we see a hacker wearing a black hoodie typing constantly on the keyboard. While these movies don't exactly portray a proper hacking culture, they also make it seem unbelievably easy to exploit an individual user.

But we have to understand that not all website is easily exploitable. Tech Giants such as Google and Facebook implant high-level security and constantly patch new vulnerabilities. So which part is the most vulnerable? You're right it's the user itself!

Once upon a time, users chose passwords such as "Honey123", "Love321", "I'mdumb111", etc. These passwords could be easily brute-forced and cracked using a Dictionary attack where the script tries the passwords from a provided Dictionary. Imagine Trying Several Keys at the same time from the collection of keys in the world

CUPP takes this attack one step ahead.

CUPP, not Mug or Jug?

I know it'd be fun to call it Jug. But CUPP stands for Common User Password Profiler

Also, sounds fun, right?
In this technique, We input a little information about our target. For example, a person named Danny Morgan wouldn't use the word "Scott" as his password. Unless he has a favorite actor named "Scott".

CUPP v3 goes through different combinations and algorithms based on the given data to create a wordlist for the target as effectively as possible.

Let's get the party started!

Before jumping into the steps, make sure you have these applications pre-installed:

Git
Python3 (v3 Recommended!)

Now that we have set up our environment to run CUPP, let's

Clone the Official CUPP Repository

git clone https://github.com/Mebus/cupp.git

Change your directory

cd ./cupp

Check if everything is working

python3 cupp.py -h

This should result in this output

usage: cupp.py [-h] [-i | -w FILENAME | -l | -a | -v] [-q]  

Common User Passwords Profiler         

optional arguments:                                                                                                       -h, --help show this help message and exit                                                                      -i, --interactive  Interactive questions for user password profiling                                                    -w FILENAME  Use this option to improve existing dictionary, or WyD.pl output to make some pwn sauce 
-l Download huge wordlists from repository                                                              -a Parse default usernames and passwords directly from Alecto DB. Project Alecto uses purified databases of Phenoelit and CIRT which were merged and enhanced 
-v, --version      Show the version of this program.                                                                    -q, --quiet        Quiet mode (don't print banner)

This means our script is ready to blast!

The Actual Business

Now we're going to generate the actual list! Yeah, yeah, I know there are a few more options available, but to keep it simple we'll stick to the classic Interactive Question-based Walkthrough. And don't worry, I'll add a short explanation for all of them later in this article.

To initiate the process first run:

python3 cupp.py -i

Here -i stands for interactive. You can also use -interactive (if you love typing)

This will bring our first question in front:

[+] Insert the information about the victim to make a dictionary                                                        [+] If you don't know all the info, just hit enter when asked! ;)                                                                                                                                                                               > First Name:

So as our target's name was "Danny Morgan", let's put "Danny" here and hit enter!

Then it asks for the Surname:

> Surname:

Which is "Morgan"
And for the Nickname, Let's Put Dan. Yeah, his Mom calls him Dan.

We attended know his birthdate because he's our friendly neighbor which is: 02011990.

Unfortunately, he's still single so he doesn't have a partner. So for the next 3 questions, we'll just keep those empty and press enter to move forward!

As he's single, obviously he doesn't have any children too! The next 3 questions also go empty!

But he has a loving dog named "Kevin". So for the next question, We put Kevin as our answer!
We know he works at Mcdonald's. I know, it is what it is.

Here comes an important part. Our target might have some more related keywords we may want to add. Such as the street he lives in, her grandma's name whom he all day yaps about or simply his favorite color black. Not to forget his favorite movie Terminator

Now CUPP will ask you if you want to add special characters and numbers [For Ex. @,!, # and 1,2,3,4] at the end of each word. Most modern sites encourage a user to use them, so it's better to have them! We will Enter "Y" for both and move forward.

The script also can combine its output with the Leet Mode. Where a number is used instead of a look-alike character. For example: E=3, S=5, l=1, T = 8, etc.

Danny isn't that much geeky so let's skip on this one! Enter N to continue.

At last, Hyperspeed print means CUPP will print the generated dictionary on the console, It's fun to look through. But for now, we'll just skip through.

Finally! Our intelligent little script will say something like this:

Now load your pistolero with ←[1;31mdanny.txt←[1;m and shoot! Good luck!

This means, our customized dictionary is finally done!

We should see a "danny.txt" in the same directory with 13612 words ready to be tested!

It tries to generate the common combinations a human might use. Just wonder what accuracy you can achieve with an existing pwned database, some OSINT research on the target and this!

Other Options

Now that we wrapped up our basic interactive option, let's briefly explore what other things we can do with CUPP.

help > -h

This option generates a help message with a list of arguments we can use with this script

interactive Steps > -i / -interactive

The one we just used. Scroll up to jog your memories!

Optimize existing Dictionary > -w FILENAME

If you have an existing dictionary in hand and want to add some custom spices. This is suitable and WyD.pl AKA Who's Your Daddy Password Profiler is a tool similar to CUPP but it scraps Strings from the files of a website and generates a custom password list!

Download Huge Dictionaries > -l

You can download existing dictionaries of common words [Contains 10 Millions or more words!]

Default Passwords > -a

Parse default usernames and passwords directly from Alecto DB. Project Alecto uses purified databases of Phenoelit and CIRT which were merged and enhanced

Version Number > -v / --version

Just prints the version number, nothing special

Quiet Mode > -q / --quiet

That Doesn't prints the intro Banner of CUPP.

Wrapping Up!

You surely don't want to fall victim to this kind of customized brute-force attack. So always be cautious to use unique and long passwords which are of course easy to remember. (Password resets on every login wouldn't make you happy, trust me!)

Also, enable 2 Factor Authentication where possible so hackers can't gain access to your online accounts without the secret code on your phone!

In further Episodes of Dictionary Attacks, we'll cover other Profiler scripts such as CRUNCH and WyD.pl (we just heard here).

Till then, Sayonara my peeps!

Scrambled EXIF: Remove Metadata From Your Media In A Blink!

eniamza — Thu, 03 Oct 2024 14:13:53 +0000

Metadata Doxxing and You

We all love to snap pics and upload them to social media in the blink of an eye. "Hey, see, I look cool in this dude!”. But you can not be certain of when those dudes will start looking beyond your picture!

This is an example of a logo I created and uploaded to my Quora Space:

But there's nothing interesting, right? It's impossible to tell who is the creator and where he lives. But is that really the case?

Metadata is associated with every file ever created. It contains valuable information like the Creation Date, Modification Date, Name of the Device that was used for creation, the Creator's Name, and even the Software name that was used to edit this logo!

EXIF (Exchangeable Image Format) is such a standard for images. Let's take a look at the EXIF Data extracted from my logo!

You can see the last modification date, the creator tool named Canva, and most importantly my name under the Author Section.

If you were a creep (I know you aren't, my readers are cool!), a simple Google search would present you with a whole page of information and social media links directly related to me. It'd take you less than 10 minutes to find out who I am!

Sounds like a nightmare, right?

Shuffle Up Your EXIF Metadata

Scrambled EXIF is here to rescue as! It acts as an intermediary for sharing files. This app acts as a middleman when you share your files by just adding another step. When sharing your files, you just need to tap the share button as usual and select Scrambled EXIF app. Shortly the share popup with apps will appear again after Scrambled EXIF's magic process! To summarize, it's just three steps:

Tap Share
Choose Scrambled EXIF
Choose the preferred app in the 2nd share popup.

Results?

Scrambled EXIF not only strips metadata from your files but also renames it with random strings. Why?

Because your phone sometimes names files containing dates and categories. For example, My phone saves Photos with this naming format: "YYYYMMDD-TIMESTAMP-PXL" That means, you can know the exact time of the capture and also the device model name.

But when I share the same logo above through Scrambled EXIF, the filename becomes: 394269db-d328-4ea9-8524-3880efb8df87.png and the metadata becomes:

Nothing Specific! It's that simple.

Resources

Scrambled EXIF App - Play Store F-Droid
What is EXIF - Wikipedia
Repository - GitLab

DumbProofing: When UX Becomes Superior to Functionality (And 5 Bonus Tips for Improving the UX)

eniamza — Thu, 03 Oct 2024 09:25:35 +0000

Once upon a time...

During the good ol' days of the internet, things were simple. You used to enter an email and password and maybe confirm your email with an OTP sent to your mail that's it.

Fast-forward two years. We now have OAUTH signups for Google, Facebook, and Github, which enable users to sign up with one click (or two if they need to confirm with the Authentication provider), and that's it.

You may have also noticed that when using the sign-in options like Google, it doesn't matter most of the time if you use the signup page or the Login Page because The Website determines if you're an existing user in the Backend and lets you proceed as suited.

Now, why didn't the developers simply rely on the user to make an educated decision and use the appropriate page for Logging In / Signing Up?

If you love her, you don't let her go

As the internet grew bigger and bigger, the struggle for online presence stonked! Soon enough it didn't matter if you were a viable SaaS Startup or a Tech Giant like Google who just doesn't care. It all came down to the "Retention and Conversion Rate".

In simple terms, You don't want to lose a customer or drive away a potential user from our beautifully designed landing page.

Now, imagine this, A user named Jim is pretty chill and randomly browses the internet (Like most of the audience). When he came to your website for a service, he wants to have a taste of that fruit as quickly as possible. If you block his first experience with layers after layers of authentication and finally a paywall (You surely don't want to live in your mother's basement forever), he will just get frustrated and move on to the next site in a blink. Unfortunately, that second website offers a free trial without a signup (Also known as Guest Browsing).

In the chart above you can see how less of the audience actually signs up for your product unless they are blown away by your landing page.

That's why it is extremely important to make the onboarding process as painless as possible for the user.

5 Curated Tips from My Experience in UX

After years of fiddling around with highly complex User experiences, Simple Grandma-friendly Apps get way more traction in the long run. Here are some tips to improve the user experience of your Side hustle which will fail anyway!

1. Offer Guest Mode and Free Trials whenever Possible.

Companies from Nvdia to niche online media converters, all offer some free credits requiring no sign-ups. You should try that out too! Let me link some of the Basic 3rd Party services such as Firebase too help you get started!

Firebase Auth: You can easily use Firebase's Anonymous Auth to track users without needing to sign up and afterward convert them to permanent users in the least intrusive way!
LocalStorage + Cookie: You can store a user's browsing and progress information in their Browser. Beware that cookies can be deleted and the Local Storage of the browser can be cleaned resulting in an infinite free trial glitch

2. Offer OAuth Powered signups and Logins

Passwords are a pain in the butt and are less secure in the era of sophisticated phishing attacks. Offering users to sign up through their Google and other social accounts such as Facebook or Github can greatly enhance their user experience!

You have multiple options to choose from when it comes to integrating OAuth. Some of them are [AUTH0, Free Tier, 25K Users], [Firebase Auth, Free Tier, 50K Users], [Supabase OAuth, Free Tier, 50K Users], [AuthJS, Free Library, Supports nearly all OAUTH Providers] , etc.

3. Don't drive away a user from the website unless absolutely necessary.

If a user or a potential customer wanders off from your website for Email Confirmation, Survey, Payments, etc, there's a higher chance that the user will not make it back to your app in the midst of the Attention-Hungry Dungeon of Internet Sales Funnels.

Here are a few libraries and services to help you with that:

SurveyJS: Add seamless forms to your website that return a well-structured JSON data.
Embedded Google Form: Want to chill? You can easily create and embed a google form in your website in Less than a minute!
Stripe's Embedded Checkout: White the most famous payment gateway, Stripe has their own Hosted Checkout feature, You can always embed that in your website for a seamless and non-intrusive checkout process

4. Less Click = More comfort for the user

I understand that you may have a groundbreaking app that has highly complex features. Yet your users are not dungeon masters. It's always a bad idea to Nest your most useful settings and options in the Dashboard or Navigation Menus.

5. Be a Guardian Angel, Guide them.

Not all your users are Tech-savvy. They won't know how to navigate through different parts of your app and if you don't get them hooked, they will just move to the next easier app. That is why while Adobe Photoshop is a beast, people still tend to prefer Canva for smaller tasks. Why? It's easier! That's why Guide them like a baby.

Here's a cool Javascript library that helps you to set up an initial tour for your audience. DriverJS (Give it a try, it's easy!)

Now you're ready to see your conversation rate go crazy! (Or slightly upwards) , It's in our best interest to make the user experience for our audience as smooth as possible. You give them easy, they give you their Credit Cards! (Just don't call them and ask their PIN)

If the article helped, Consider showing some love and a lot of constructive feedback! Cheers!