That impression is false.

The model does not know what it will say. Not the paragraph. Not the sentence. Not even the next word. There is no internal narrative, no latent plan waiting to be revealed. At every step, the system is confronted with a single question: given everything so far, what “word” is most likely to come next?

What you are witnessing is not intelligence as we understand it. It is coherence without comprehension. Structure emerging from a process that never plans, never reflects, and never understands. The gap between those two realities is where the illusion lives.

To see why this illusion is so convincing, we have to look at what actually happens between the moment you hit Send and the moment the first word appears.

TL;DR

By the end of this article, you’ll be able to look at a prompt and predict how the model will respond to it and why. You’ll see what makes a prompt collapse into noise, what makes another lock the model into clarity, and how the same system can feel intelligent or incompetent depending on how you engage it.

But to get there, we first need to strip away the illusion and examine the machinery underneath.

From Prompt to Text: The Language Generation Pipeline

When you press Send, nothing starts “thinking.”
Instead, your prompt enters a sequence of transformations — each step moving it further away from human language and closer to raw computation.

First, the sentence is broken into pieces.
Those pieces are translated into numbers.
The numbers are compared to establish context.
Every possible continuation is evaluated and scored.
One option is chosen and locked in.

That single choice is then fed back into the system, and the entire sequence runs again.

This loop repeats once for every word that appears on your screen.

In technical terms, the process consists of five phases:

1. Tokenization: Language is fractured into discrete units that the model can operate on.

2. Embeddings: Those units are lifted out of text entirely and placed into a numerical space of meaning.

3. The Transformer: Context is processed through layers of attention, deciding what matters and what doesn’t.

4. Probabilities: Every possible continuation is evaluated and scored.

5. Sampling: A single option is selected, fixed in place, and fed back into the system.

Nothing here runs once. There is no final pass, no overview, no plan.
Only a loop executed at scale, where language emerges one irreversible choice at a time.

To make sense of how such a simple loop can produce such convincing language, we need to slow it down and examine each phase in isolation. Starting with the very first transformation your text undergoes.

1) Tokenization: Breaking Language Apart

The first myth to let go of is simple: tokens are not words.

Tokens are fragments. Sometimes a full word, sometimes a syllable, sometimes a piece of punctuation. Shaped by statistical efficiency, not by grammar. Tokenizers are trained in advance on vast collections of text to compress language as effectively as possible. Frequently occurring patterns are kept whole. Rarer or longer words are broken apart. “The” might be a single token; “indistinguishable” might become several.

All of this happens before the neural network is involved. No attention, no probabilities, no reasoning. Just a deterministic conversion from text to symbols. By the time the model begins operating, your prompt is no longer language at all. It’s a sequence of integers.

2) Embeddings: Turning Symbols into Geometry

Once language has been broken into tokens, an even less intuitive step follows: those numbers still carry no meaning.

A token ID is nothing more than an index in a lookup table. On its own, it encodes no semantics, no context, and no notion of relatedness. “Dog” and “database” might sit next to each other numerically or be separated by thousands of indices — the distance is arbitrary. If the model tried to operate on these token IDs directly, every token would be equally meaningless.

So the next step is not language processing. It’s a coordinate assignment.

Each token ID is mapped to a high-dimensional vector — a long list of numbers that places it at a specific position in space. This space is not linguistic. It is geometric. Distance, direction, and relative position are the only signals that exist.

Tokens that appear in similar contexts across massive amounts of text are placed near one another. Tokens that rarely co-occur drift farther apart. Over time, structure emerges — not because anyone defined it, but because statistical patterns enforce it.

This is how relationships take shape:

• Function, method, and procedure fall into the same neighborhood.

• Java, Python, and JavaScript occupy adjacent regions.

• Python the programming language and Python the snake are pushed far apart.

No rules were written for this. No ontology was designed. The geometry formed itself. Once tokens become vectors, meaning is no longer symbolic. It becomes spatial.

• Similarity is represented as distance.

• Analogy becomes direction.

• Context becomes movement through this space.

For the first time in the pipeline, the model has something it can actually operate on. These vectors — not words, not tokens — are what enter the transformer.

And this is where context begins to matter.

3) The Transformer: Context Is a Mixing Problem

By the time data reaches the transformer, language is already gone.

What the model receives is a sequence of vectors — points in a geometric space that encode meaning and similarity. But at this stage, each vector still stands mostly alone. It knows what it represents, but not how it relates to everything else around it.

The transformer’s job is to change that.

At its core, the transformer is not a reasoning engine. It doesn’t think or plan. Instead, it acts as a context mixer. Its role is to repeatedly take a set of vectors and rewrite each one in terms of all the others.

This happens through a mechanism called attention.

3.1) Attention: Deciding What Matters

For every token in a sequence, the transformer asks a simple question: “Which other tokens should influence me right now — and by how much?”

For example: “The cat sat on the mat because it was tired.”

What does “it” refer to? Not the mat. The cat.

Humans resolve this instantly. The transformer does it numerically. When processing the vector for “it”, the attention mechanism assigns more weight to “cat” than to “mat”, even though “mat” appears closer in the sentence.

This isn’t logic in the human sense. It’s pattern recognition at scale. Across millions of examples, the model has learned that “tired” usually applies to living things, not objects.

Attention works by comparing vectors and assigning weights — numbers that determine how much each token influences every other token.

3.2) Multi-Head Attention: Multiple Perspectives at Once

This process doesn’t happen just once.

It runs in parallel, using what are called “attention heads”. Each head can focus on different kinds of relationships, such as:

• Grammatical structure

• Semantic similarity

• Positional cues

One head might track subject–verb agreement. Another might follow references like “it” or “they”. Another might focus on the overall topic of the sentence.

None of these roles is predefined. They emerge naturally because different patterns help the model make better predictions.

3.3) Depth: Building Meaning Layer by Layer

After attention is applied, the vectors are updated. Each token now carries information not just about itself, but about its relationship to the entire sequence.

Then the process repeats.

Modern models stack dozens of these layers. Early layers tend to capture local structure. Later layers encode broader, more abstract context. With each pass, the representation becomes richer and more specific.

By the time the vectors leave the transformer, they no longer represent isolated meanings. They represent meaning in context. Not just “cat”. But “this” cat, in “this sentence”, for “this purpose”.

3.4) What the Transformer Is Not

There is no memory of past conversations here. No internal narrative. No global understanding of the prompt.

The transformer doesn’t know what it’s saying. It continuously rewrites vectors based on how they relate to one another. What feels like reasoning is the accumulated effect of repeated context mixing.

And once that mixing is done, the model moves on to its next step. It has to decide what comes next.

4) Probabilities: Scoring the Future

Once the transformer finishes mixing context, its work is complete.

What comes out is a final set of vectors — each one encoding everything the model knows at this moment about the sequence so far. But nothing has been turned into text yet. There are no words. No sentences. Just numbers.

Now the model must answer a single question: “Given everything so far, what should come next?”

To do that, it considers every possible next token in its vocabulary.

Not a handful.
Not the top few.
All of them.

For modern models, that can mean tens or even hundreds of thousands of possibilities.

4.1) From Context to Scores

The final transformer layer assigns a score to every possible next token. These scores are called logits.

On their own, logits don’t mean much. They’re just raw numbers:

• positive or negative

• large or small

To turn them into something usable, the model applies a mathematical function called softmax.

Softmax converts those raw scores into a probability distribution:

• Every token receives a probability

• All probabilities sum to 1

• Higher scores become higher probabilities

At this point, the model still hasn’t chosen anything. It has simply produced a ranked list of possibilities.

For a prompt like “What is Python?”, the distribution might look something like this:

• “is” → 23%

• “was” → 14%

• “means” → 6%

• thousands of other tokens → fractions of a percent each

This is the core reality of language generation. The model does not decide what to say. It produces a probability distribution over what could come next.

4.2) Plausibility, Not Truth

This is also where a crucial limitation appears. The probabilities don’t represent truth. They represent plausibility.

The model has no built-in concept of correctness. It doesn’t verify facts or check consistency against reality. It simply assigns higher probability to sequences that look like things it has seen before.

This is why models can sound confident while being wrong.

When a model hallucinates, it isn’t lying. It’s selecting a high-probability continuation that happens to be false. The system knows how convincing answers are shaped. Not whether they’re correct.

At this stage, everything is still potential. Nothing has been committed. That happens next. The model must make a choice.

5) Sampling: Committing to One Path

Up to this point, nothing has actually been generated.

The model has:

• Broken text into tokens

• Embedded them into geometry

• Mixed context through attention

• Scored every possible next token

But it hasn’t chosen anything yet.

What it holds now is a probability distribution — a map of futures, each weighted by likelihood. Sampling is the moment where possibility collapses into reality. This is where the model commits.

5.1) Choosing Is Not Picking the Best

A common misconception is that the model always selects the most likely next token. It doesn’t.

If it did, every response would be painfully predictable. The same phrasing. The same structures. The same answers every time.

Instead, the model samples from the probability distribution.

That means:

• Highly probable tokens are more likely to be chosen

• Less probable tokens are still possible

• Extremely unlikely tokens are effectively ignored

This controlled randomness is what allows language to feel flexible rather than mechanical.

5.2) Temperature: Controlling Risk

Sampling behavior is shaped by a parameter called temperature.

Temperature adjusts how sharp or flat the probability distribution is before a token is selected.

• Low temperature sharpens the distribution

  • The top tokens dominate

  • Outputs become focused, conservative, repetitive

• High temperature flattens the distribution

  • Lower-probability tokens get more weight

  • Outputs become more creative, but less reliable

At temperature zero (theoretical), the model would always pick the single most likely token. At very high temperatures, generation becomes chaotic. Most real-world systems operate somewhere in between.

5.3) Guardrails: Limiting the Space

Additional techniques are often applied to prevent sampling from drifting into nonsense.

Two common ones:

• **Top-k sampling
  **Only the top k most probable tokens are considered. Everything else is discarded.

• **Top-p (nucleus) sampling
  **Tokens are considered until their cumulative probability reaches p (for example, 90%). The tail is ignored.

These methods don’t change what the model knows. They change which futures are allowed to choose from.

5.4) One Token at a Time

After sampling, a single token is selected. That token is appended to the sequence, then the entire process starts again:

• The new token is embedded

• Context is remixed

• Probabilities are recomputed

• Another token is sampled

There is no master plan. No outline. No awareness of where the sentence is going. Each step is local. Each choice depends only on what exists so far. What feels like a coherent paragraph is actually the result of hundreds or thousands of tiny commitments, made one token at a time.

What Looks Like Intent Is Just Momentum

The model does not know where it is heading. It doesn’t aim for conclusions. It doesn’t plan punchlines. It doesn’t hold goals in mind.

What emerges instead is statistical momentum. Once a direction is chosen, future probabilities reinforce it. Style stabilizes. Topic narrows. Coherence appears. Not because the model understands the destination. But because every step reshapes the landscape of what comes next.

And with that final commitment, language reappears. One token at a time.

6) How to Leverage This When Using AI Agents

Once you understand how models actually operate, a lot of “prompt magic” stops being magic.

• AI agents don’t reason globally.

• They don’t plan end-to-end.

• They don’t hold intent across time.

They sample one token at a time, conditioned on the context you give them. That means your primary lever is context shaping.

6.1) Control Behavior by Controlling Context

Models don’t follow intent — they follow context. Clear structure, constraints, and framing sharpen the probability space and produce more reliable behavior than vague instructions ever will.

Good example

You are a senior backend engineer.

Task: Review the following function for concurrency issues.

Constraints:

• Focus only on thread safety

• Ignore performance concerns

• Respond in bullet points

Bad example

Can you look at this code and tell me if it's okay?

6.2) Think in Trajectories, Not Prompts

Early tokens set direction. The opening lines determine tone, depth, and structure. Treat prompts as the start of a trajectory, not a single instruction.

Good example

We are writing a technical design review.

Audience: senior engineers.

Tone: precise, critical, neutral.

Begin by summarizing the core architectural tradeoff.

Bad example

Explain this architecture.

6.3) Use Examples to Collapse Ambiguity

Examples reduce interpretation space. They show the model exactly which patterns to reinforce and which to ignore.

Good example

Convert requirements into acceptance criteria.

Example:
Requirement: User can reset password
Acceptance Criteria:

• User receives reset email

• Link expires after 15 minutes

• Password meets policy

Now convert:
Requirement: User can export data

Bad example

Write acceptance criteria for this feature.

6.4) Break Tasks into Stable States

Long, open-ended goals degrade output quality. Breaking work into phases keeps context sharp and reduces error accumulation.

Good example

Step 1: Summarize the problem in one paragraph.

Step 2: List possible approaches.

Step 3: Evaluate tradeoffs.

Step 4: Recommend one option.

Proceed step by step.

Bad example

Figure out the best solution and explain everything.

6.5) Design for Correction, Not Perfection

Models commit sequentially. Errors compound. Build feedback loops that reintroduce context and allow correction.

Good example

Answer the question.

Then:

• List your assumptions

• Identify potential errors

• Revise the answer if needed

Bad example

Give me the final answer.

6.6) Shape Context, Don’t Command Intelligence

Agents aren’t planners or thinkers. They’re probabilistic systems responding to context. Precision beats authority.

Good example

Here is the format you must follow:

• Assumption

• Reasoning

• Conclusion

If information is missing, say so explicitly.

Bad example

Be smart and figure it out.

Final Thoughts

What you’ve seen here isn’t a story about intelligence. It’s a story about mechanics.

From prompt to token, from token to vector, from vectors to probabilities, and from probabilities to a single irreversible choice. Language emerges without understanding, intention, or awareness. Coherence is not evidence of thought. It’s the result of structure, scale, and statistical momentum.

Once you understand this pipeline, AI stops feeling mysterious. You stop asking “What does it know?” and start asking “What context am I shaping?” The difference is subtle, but it’s where effective use begins.

There is no mind in the machine. But there is a system. And systems, once understood, can be guided.

Thanks for reading through 🙌🏼. If you found this post useful, please share it through your circles.

But the screen that shows the CCTV footages never shows who’s in front of the door, as the camera set to a wrong angle.

That’s what a Silent Scan is: real attacker activity captured in logs… but missing from the dashboards analysts rely on to judge the health of their environment.

This article breaks down how that happens, and shows exactly how to stop it.

The Hidden Failure No One Talks About

Every SIEM boasts dashboards: anomaly charts, trending tables, threat widgets, colorful pies that make us feel informed. But dashboards lie when their filters are narrow.

A SIEM can fully ingest the logs for a port-scan, tag the source as malicious, and even generate an alert… while the dashboard you check every day shows zero anomalies involving that host.

That’s not a detection failure. That’s a visibility failure, which is worse, because you don’t know what you’re missing.

A Simple Example That Exposes the Problem

Imagine a SIEM dashboard powered by a query like:

Show anomalies for destination A or B

Clean. Simple. Harmless, right?

Now imagine a real attacker probes IP C, another security device you forgot to include in that query. The SIEM knows. The logs show it. Threat intelligence screams about it.

But the dashboard? Zero. Like the attack never happened.

Junior analysts look at the dashboard and think:

“All quiet today.”

Hey! It wasn’t.

Let’s Visualize It Clearly

The Real Attack A suspicious IP sends repeated connection attempts to a web gateway or firewall. Classic reconnaissance.

Your Security Stack Logs:

• Source IP flagged by threat intel

• Repeated port hits

• Access denied

• Firewall blocks

• Potential recon behavior

What the SIEM Shows in Raw Logs “External host scanned a protected endpoint.”

What the Analyst’s Dashboard Shows Nothing… No entry… No spike... No anomaly…

Why? Because the dashboard filter only monitors a shortlist of tracked assets, and the scanned one is missing. This is how real attacks hide in plain sight.

Why This Matters

Attackers don’t start with bombs. They start with knocks.

Reconnaissance is Phase Zero of intrusion: mapping defenses, discovering exposed surfaces, testing response behavior. Missing recon is like watching a movie from the middle and wondering why the ending makes no sense.

A blind dashboard means:

• Early-stage threats go unnoticed

• Incident timelines become incomplete

• Investigations miss crucial clues

• Analysts trust visuals that don’t reflect reality

• Security relies on luck instead of design

Dashboards aren’t passive screens. They shape how analysts think. If the dashboards are blind, the team is blind.

Here’s Where It Gets Surprisingly Fun

Remember those variables from programming classes? Those boring “boxes” that hold values that can change? SIEMs use the same idea quietly, but far more powerfully.

People often ask: “Does a SIEM even have variables?” Absolutely. They just don’t call them that.

Every SIEM (Splunk, Sentinel, Elastic, QRadar, ArcSight, Chronicle, whatever your flavor…) gives you structured lists:

• Lookup tables

• Watchlists

• Reference sets

• Dynamic lists

• Enrichment tables

These are effectively security variables. Instead of hard-coding IPs into queries like a freshman Python homework, you store them in a central list and reference them dynamically.

Not technical? Doesn’t matter.

Picture this… You run a nightclub. You don’t memorize every VIP by heart each night. You keep a VIP list at the door.

• Name on the list → let them in.

• Not on the list → stop, check, verify.

  

A SIEM works exactly the same way. These lists are the difference between a dashboard that shows reality, and a dashboard that shows whatever tiny slice of reality you remembered to filter for.

And once you understand that, the examples you’re about to see suddenly become painfully clear.

The Fix: Stop Hard-Coding. Start Using Dynamic Asset Lists.

Those structured lists, the “security variables” your SIEM already provides should become your single source of truth.

Don’t build dashboards like:

destination_asset_ip = 'X' or 'Y' or 'Z'

Use:

destination_asset_ip in "SECURITY_ASSETS_LIST"

Then, keep SECURITY_ASSETS_LIST updated automatically with your security solutions:

• Firewalls & WAFs

• Reverse proxies & Load balancers

• API gateways

• Internet-exposed nodes

• Pre-prod mirrors

When assets evolve, your dashboards stay accurate… forever.

Realistic Sample: Before vs. After

Before (The Dangerous Way)

Dashboard Query: Show anomalies only for: 127.0.0.10, 127.0.0.20, 127.0.0.30

• Scenario: IT deploys a new WAF at 127.0.0.40.

• The Gap: The dashboard query wasn't updated manually.

• The Result: An attack hits 127.0.0.40. The dashboard goes silent.

After (The Correct Way)

Dashboard Query: Show anomalies where destination is in SECURITY_ASSETS_LIST

• The List: SECURITY_ASSETS_LIST automatically updates to include:

  • 127.0.0.10

  • 127.0.0.20

  • 127.0.0.30

  • 127.0.0.40

• The Result: Every device speaks. Every scan shows. Every blind spot dies.

The Shadow IT Trap: How Attackers Exploit Blind Spots

The Setup A malicious IP sends sequential connection attempts to a "Shadow IT" server, a dev machine spun up for testing that didn't make it onto the official Excel spreadsheet.

Raw Logs (SIEM sees):

• Multiple denied hits

• Port variations

• Threat intel score: High

• Behavior: Consistent with probing

Dashboard (SIEM doesn’t show):

• “0 anomalies detected today.”

Why the contradiction? The widget tracks only known, pre-selected devices. Attackers don’t attack only the devices you expect. They attack everything. Your dashboards must reflect that.

A Message to Every Analyst… Especially Beginners

If you only trust alerts, you’ll miss trends. If you only trust dashboards, you’ll miss the context.

If you want to be better than average, fix the blind spots.

Modern CSOC teams don’t fail because they lack data. They fail because they ignore the data they already have.

The scariest threats aren’t loud. They’re quiet, curious, probing, and waiting for the moment you’re not looking.

Closing Thought

A SIEM that collects data but doesn’t show it is like a lighthouse with the bulb turned off. It stands tall, looks impressive, and helps exactly no one.

Turn the light on. Start with visibility. Use dynamic asset lists. Make your dashboards honest.

Because the next silent scan won’t announce itself. But your SIEM should.

This article is written for beginners and focuses on clarity and practical understanding of basic and simple lambdas, rather than diving deep into internal implementation details and optimizations. If you are already familiar with the basics and looking for more advanced reading on lambda optimizations, click here.

For this guide, we’ll be discussing

1. What Is AWS Lambda?

2. What Does Serverless Mean?

3. Why Use AWS Lambda?

4. Core Lambda Concepts

5. Lambda Execution Lifecycle

6. Creating Your First Lambda Function

7. How Pricing Works

8. Common Errors

9. Lambda Drawbacks & Limitations

What Is AWS Lambda?

AWS Lambda is a compute service and a core building block of serverless architectures. Unlike traditional servers, it puts your code at the center of focus by allowing you to run it without provisioning or managing any servers.

You simply upload your code, define when it should run and AWS handles:

• Server provisioning

• Scaling

• Availability

• Infrastructure maintenance

In addition, you are charged only when your code runs.

What Does Serverless Mean?

Serverless doesn’t mean there are no servers.

It means:

• You don’t manage servers

• You don’t worry about capacity

• You don’t scale manually

AWS owns the infrastructure; you own the code.

Traditional vs Serverless

Traditional App

Serverless App

This shift allows teams to move faster and put more focus on business logic.

Why Use AWS Lambda?

Lambda is ideal when you want to:

• Build quickly

• Scale automatically

• Reduce operational overhead

• Pay only for usage

Common Use Cases

• APIs (With API Gateway)

• File processing (S3 events)

• Background jobs

• Scheduled tasks (cron jobs)

• Event-driven microservices

Core Lambda Concepts

Before writing your code and using Lambda, you need to understand a few terminologies and fundamentals.

Execution Role

An IAM role that defines what your Lambda is allowed to access.

Function

The unit of code you deploy and execute in AWS Lambda.

Handler

The entry point AWS calls when the function runs.

export const handler = async (): Promise<string> => {
  return "Hello from Lambda";
};

Event

The input passed to your function to trigger it (HTTP request, S3 event, message, etc.).

Trigger

The AWS service that invokes your function.

Lambda Execution Lifecycle

Understanding the lifecycle helps you avoid performance and cost issues.

1. Cold Start

• AWS creates a new execution environment

• Your code is loaded

• Initialization code runs

2. Invocation

• The handler function is executed

• Your logic processes the event

3. Warm Start

• The environment may be reused if the Lambda finishes execution and hasn’t expired yet (still within its TTL).

• Execution is much faster

Code outside the handler runs once per environment, not per request.

Creating Your First Lambda Function

At a high level:

1. Open the AWS Lambda console

2. Create a new function

3. Choose a runtime (Node.js, Python, Java, Go, etc.)

4. Write or upload your code

5. Configure permissions

6. Add a trigger

Simple Example (Node.js)

import { APIGatewayProxyEvent} from "aws-lambda";

export const handler = async (event: APIGatewayProxyEvent): Promise<APIGatewayProxyResult> => {
  return {
    statusCode: 200,
    body: JSON.stringify({
      message: "Hello from AWS Lambda 🚀",
    }),
  };
};

Once deployed, this function can be invoked via an API or event.

How Pricing Works

AWS Lambda pricing is based on actual usage, not idle time.

1. Invocations

You pay per function call.

2. Execution Duration

You pay for:

• Memory allocated

• Execution time (milliseconds)

Cost = Invocations + (Memory × Execution Time)

Important notes:

• More memory also means more CPU

• Faster execution can reduce total cost

• Free tier covers many small projects

Common Errors

Cannot find module

I like to think of this as AWS Lambda’s welcome message—one of the first and most common errors you’ll hit as a new Lambda user. This typically occurs when:

• Dependencies weren’t included in the deployment package (node_modules missing or incomplete)

• The build output is incorrect or bundled incorrectly for Lambda

• Runtime versions don’t match

• The module is not included in the deployment package

• The module name or import path is incorrect

Tip: Always inspect what gets deployed.

Permission Errors (Access Denied)

Permission errors mainly occur when lambdas try to perform certain actions that extend to other services and are caused by:

• Missing IAM permissions

• Incorrect execution role

Note: If Lambda can’t access a service, check IAM first.

Timeout Errors

Lambda has a configurable timeout. Long‑running tasks may require:

• Increasing timeout

• Breaking work into smaller async tasks

Lambda Drawbacks & Limitations

With all the amazing features that Lambda offers, unfortunately, like everything else, it is not all sunshine and rainbows. There are cons that you have to deal with when using lambda and understanding its limitations early will save you from painful refactors later.

Cold Starts

• Noticeable delay for user-facing APIs

• Worse with heavy dependencies or VPC-enabled Lambdas

Bad choice when building latency-sensitive APIs

Alternative services: AWS App Runner, ECS / EC2

Execution Time Limits

Lambda functions have a maximum execution time (15 minutes).

• Not suitable for long-running tasks

• Jobs can’t “just keep running.”

Bad for Background tasks that may run for hours (Video encoding or large file processing or Long ETL jobs)

Alternative services: AWS Batch, Fargate, ECS / EC2

Limited Local State & Ephemeral Environment

Lambda execution environments are stateless by design.

Why it matters:

• You can’t rely on in-memory state between invocations

• The filesystem is temporary

Alternative services: Use it with DynamoDB to persist state, ECS / EC2

Debugging & Observability Can Be Tricky

Debugging distributed, event-driven systems is harder than debugging a single server.

Common challenges:

• Logs scattered across CloudWatch

• Harder to reproduce issues locally

• Tracing async flows requires extra tooling

The points above make Lambda a poor choice if:

• Your app relies heavily on local caching

• You need session-based or sticky state

• You’re porting a legacy monolith that assumes persistent memory

• Your team is new to cloud-native debugging

Alternative services: OpenTelemetry, ECS / EC2 for familiar debugging patterns and tooling

Closing Thoughts

AWS Lambda is a cornerstone of the AWS ecosystem. Once you understand its execution model and lifecycle, it becomes a powerful tool for building scalable, event-driven architectures while significantly reducing operational complexity. That said, it’s important to remember that Lambda is not a silver bullet and isn’t the right fit for every use case.

Resources

• https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtime-environment.html

• https://docs.aws.amazon.com/lambda/latest/dg/typescript-handler.html

• https://aws.amazon.com/lambda/pricing/

-Add Money in Seconds

The journey in financial literacy starts with just a tap. Add money through InstaPay, Fawry, or any card and start teaching them how to make essential purchases. Seeing money in action is the only way they can truly grasp its value. 💰

-Give Them A Card

Don’t give us that worried look 👀 You can request up to 5 cards from a single primary account and watch the magic happen! Not only will this give them some financial autonomy, but you can also freeze their spending whenever it doesn’t stick to your budget! Two birds with one stone?

-Watch them in Action

Instead of rushing to the cashier to buy their favorite goodies from Klivvr’s list of partners, let them do the work! Explain how to place the purchases, check the receipt's accuracy, and use their Klivvr card. What’s better than boosting their confidence while teaching them necessary social skills?

-Analyze Spending Together

After all that spending, it’s only time to reflect back on it! Analyze their monthly purchases and put them into perspective compared to your intended budget. This way, they can know what you expect from them and how to be financially responsible moving forward!

-Let Them Withdraw Cash

Putting them in real-life situations, such as dealing with an ATM, builds key life skills that they will thank you for later! Guide them through the steps needed to withdraw cash so they can be comfortable with it as they grow.

This scratches the surface of all the ways Klivvr Go Plus can help empower your littles! Happy spending 💸

-Check Money Transfer Options

Klivvr lets you add money to your card using Instapay, Fawry, or any bank card! Check which ones work best for your family and enjoy instant money transfer relief.

-Check Existing Partners

On your Klivvr application, you can see a list of 20+ partners across different categories, such as Lifestyle, Food and beverages, and more! Check which spots are your family’s favorites, and make sure to visit them with your Klivvr card to get a discount!

-Request Multiple Cards

Are your kids always losing cash? Do you delay shopping until your partner comes home because you share a card? Well, it sounds like it is time to request an extra card! The Go Plus plan allows up to 5 cards from one single primary account.

-Track their Spending!

If your family is always steering away from the budget, well, then it’s time for some interventions! Use the tracker on your Klivvr application and see for yourself what is going wrong and how you can fix it next month.

-Stay in Control

We have all fallen prey to that mistake of forgetting our card with our kids, but Klivvr lets you freeze it instantly with a tap! Whenever their spending isn’t looking well or you lose that card for the hundredth time, just freeze it through your application and enjoy the peace of mind.

These are some of the ways that you can use Klivvr to be your newest financing best friend! Happy spending with your fam!

Maintaining Consistency with the Design System

K-Design Wizard simplifies the process of maintaining the design system, addressing small but crucial details like text sizes, letter spacing, and color opacity adjustments. Changes, such as letter spacing adjustments from 2.5% to 2% or color opacity tweaks by 0.2%, are seamlessly incorporated without designers or developers having to sift through the details. Designers simply run the plugin, applying the changes instantly. This direct approach helps our team avoid lengthy discussions on minor design tweaks and reduces the chance of manual errors.

The Challenge: Bridging Design and Development

Designers work tirelessly in Figma to create pixel-perfect interfaces, but translating these designs into code often involves tedious, manual adjustments. Maintaining design consistency across platforms and screen sizes further complicates the process, as minor discrepancies, like a color or font size mismatch, can alter the intended user experience.

This is where our plugin shines, particularly when faced with maintaining the design system at scale. As our Product Designer, Marium Nour noted, even small updates should feel lightweight and non-intrusive for designers, allowing a natural design flow without a heavy, disruptive impact.

Custom Figma Plugin: Exporting Design Tokens

To address these challenges, we developed a custom Figma plugin that exports design tokens. Design tokens are the atomic elements of a design system – colors, typography, spacing, and other visual properties that define the look and feel of an interface.

Our plugin extracts this crucial information directly from Figma, ensuring that every design decision is captured accurately. It generates JSON files containing:

• Color palettes for both light and dark modes

• Typography styles, including font sizes, line heights, and weights

• Measurements for spacing and component sizes

Here's a snippet of what the exported JSON might look like for color tokens:

{
  "color": {
    "primary": {
      "base": { "$value": "#0077C2" },
      "light": { "$value": "#4DA3E5" },
      "dark": { "$value": "#005691" }
    },
    "background": {
      "light": { "$value": "#FFFFFF" },
      "dark": { "$value": "#121212" }
    }
  }
}

By using design tokens, we create a single source of truth that both designers and developers can reference. This approach not only improves consistency but also facilitates easier updates and maintenance of the design system.

K-Design Wizard: Automating Token Translation

While exporting design tokens improves design consistency, K-Design Wizard, our Python script, takes it a step further by transforming these JSON files into ready-to-use Swift code. This step eliminates the need for manual code writing, reducing the chance of human error and enhancing the speed of design implementation.

Key features of K-Design Wizard include:

1. Generating Swift enums for colors, measurements, and typography styles

2. Creating GitHub pull requests to update the codebase automatically

3. Handling both light and dark mode color schemes

4. Supporting multiple languages for typography (e.g., English and Arabic)

Here's a simplified example of how K-Design Wizard might generate a Swift enum for colors:

enum LightColors {
    case primaryBase
    case primaryLight
    case primaryDark
    case backgroundLight
    case backgroundDark

    var value: String {
        switch self {
        case .primaryBase: return "#0077C2"
        case .primaryLight: return "#4DA3E5"
        case .primaryDark: return "#005691"
        case .backgroundLight: return "#FFFFFF"
        case .backgroundDark: return "#121212"
        }
    }
}

This script eliminates the need for manual code writing, reducing the chance of human error and significantly speeding up the process of implementing design changes.

The Automated Workflow

With our custom tools in place, the design-to-development workflow becomes a streamlined process:

1. Designers make changes in Figma

2. The custom Figma plugin exports updated design tokens as JSON files

3. K-Design Wizard processes these JSON files, generating Swift code

4. The script creates a GitHub pull request with the updated code

5. Developers review and merge the changes

This automated workflow ensures that design changes are reflected in the codebase quickly and accurately, without manual intervention.

Benefits of Automation

The advantages of this automated approach are numerous:

1. Time Savings: What once took hours of manual work now happens in minutes.

2. Reduced Human Error: Automated code generation eliminates typos and misinterpretations.

3. Improved Consistency: Design tokens ensure that the same values are used throughout the application.

4. Faster Iteration Cycles: Quick implementation of design changes allows for more rapid prototyping and refinement.

5. Better Collaboration: Designers can see their changes reflected in code almost immediately, fostering better understanding between design and development teams.

Implementation and Integration

To implement this workflow in your own projects:

1. Install the custom Figma plugin in your Figma workspace.

2. Set up K-Design Wizard on your local machine or CI/CD pipeline:

   • Ensure Python is installed

   • Install required dependencies (pip install PyGithub)

   • Configure GitHub access token for PR creation

3. Establish a process for running the script when design tokens are updated

4. Train your team on the new workflow and tools

Here's a simplified snippet of how you might use the generated Swift code in your iOS app:

import SwiftUI

struct ContentView: View {
    var body: some View {
        Text("Hello, World!")
            .foregroundColor(Color(colorString: LightColors.primaryBase.value))
            .padding(Space.medium.cgFloat)
            .background(Color(colorString: LightColors.backgroundLight.value))
    }
}

Remember, the key to successful adoption is clear communication and documentation. Make sure all team members understand the benefits and processes involved.

Future Improvements and Possibilities

While our current setup has greatly improved our workflow, there's always room for enhancement:

• Expand support for other programming languages (e.g., Kotlin for Android development)

• Integrate with design systems to generate component code automatically

• Develop a web interface for non-technical team members to trigger updates

• Implement version control for design tokens to track changes over time

The possibilities for further automating and optimizing the design-to-development process are endless. As we continue to refine our tools, we're excited to see how they will evolve to meet future challenges.

A New Era of Efficiency in Design and Development

By creating custom tools that bridge the gap between design and development, we've not only saved time and reduced errors but also fostered a more collaborative environment. Our Figma plugin and K-Design Wizard script demonstrate the power of automation in solving real-world development challenges.

We encourage all teams facing similar design-to-development hurdles to explore custom automation solutions. The initial investment in developing these tools pays off manifold in improved efficiency, consistency, and team satisfaction.

Remember, the goal is not just to make the process faster, but to create space for creativity and innovation. By automating the mundane, we free ourselves to focus on what truly matters – creating exceptional user experiences.

What is Glassmorphism, and Why Should You Care?

Before we dive into the code, let's talk about what glassmorphism is and why it's causing such a buzz in the design world. Glassmorphism is a design trend that creates a frosted glass effect in user interfaces. It typically involves:

1. A semi-transparent background

2. A subtle blur effect

3. Light borders or shadows to create depth

Glassmorphism can give your app a:

• Modern and sleek look

• More depth and layered

• Visually interesting without being overwhelming

Plus, it's a great way to make your app stand out in a sea of flat designs!

Setting the Stage: The GlassmorphicLayer Component

Now that we know what we're aiming for, let's introduce the star of our show: the GlassmorphicLayer component. This nifty piece of Jetpack Compose magic will allow us to create stunning glassmorphic effects with ease.

Here's a sneak peek at what we'll be working with:

@Composable
fun GlassmorphicLayer(
    modifier: Modifier = Modifier,
    backgroundDimColor: Color = Color.Transparent,
    transitionStiffness: Float = Spring.StiffnessMediumLow,
    blurSourceView: View = LocalView.current.rootView.findViewById(android.R.id.content),
    contentEnterAnimation: EnterTransition = getDefaultEnterAnimation(transitionStiffness),
    contentExitAnimation: ExitTransition = getDefaultExitAnimation(transitionStiffness),
    onDismissRequest: () -> Unit,
    content: @Composable BoxScope.() -> Unit,
) {
    // The magic happens here!
}

Don't worry if this looks intimidating – we'll break it down step by step!

The Journey Begins: Understanding the Components

Our journey to glassmorphic greatness involves three main parts:

1. The main GlassmorphicLayer component

2. A helper component called ScreenContentGlassmorphedLayer

3. A custom Modifier extension named glassmorph()

Let's explore each of these:

1. GlassmorphicLayer: The Conductor of Our Glassmorphic Orchestra

This is the main component you'll use in your app. Think of it as the conductor of an orchestra, harmonizing all elements to achieve a cohesive glassmorphic effect.

Key responsibilities:

• Managing the visibility of the glass effect and content

• Handling animations

• Coordinating the blur effect

2. ScreenContentGlassmorphedLayer: The Background Artist

This behind-the-scenes component creates the blurred background that gives our glassmorphic effect its signature look.

What it does:

• Captures a snapshot of your app's current view

• Applies a blur effect to this snapshot

• Displays the blurred image with smooth animations

3. glassmorph() Modifier: The Special Effects Wizard

This custom Modifier extension is where the real magic happens. It applies the blur effect and handles the animations that make our glassmorphic layer come to life.

Its superpowers:

• Animating the blur radius

• Controlling the visibility of the blur effect

The Implementation Adventure: A Step-by-Step Guide

Now that we know the key players, let's walk through how to implement the GlassmorphicLayer in your app. Don't worry; we'll take it one step at a time!

Step 1: Set Up Your Project

Ensure Jetpack Compose is set up in your Android project. If you haven't done this yet, check out the official Jetpack Compose documentation for guidance.

Step 2: Import the GlassmorphicLayer

Add this import statement at the top of your Kotlin file:

import com.design.components.GlassmorphicLayer

Step 3: Use GlassmorphicLayer in Your Composable

Here's a simple example of how to use the GlassmorphicLayer:

@Composable
fun MyGlassmorphicScreen() {
    GlassmorphicLayer(
        backgroundDimColor = Color.Black.copy(alpha = 0.5f),
        onDismissRequest = { showGlass = false }
    ) {
        // Content inside the glassmorphic layer
        Text(
            text = "Glassmorphic Content",
            modifier = Modifier.align(Alignment.Center)
        )
    }
}

This example shows a glassmorphic layer on top of the current screen content with some text inside. Cool, right?

Customization: Making It Your Own

Now that we have our glassmorphic layer up and running, let's explore some ways to customize it and make it truly yours!

1. Change the Background Dim

Want to set the mood? Adjust the backgroundDimColor:

backgroundDimColor = Color.Blue.copy(alpha = 0.3f)

2. Tweak the Animation Speed

Make it snappy or smooth by modifying transitionStiffness:

transitionStiffness = Spring.StiffnessHigh // for faster animations

3. Create Custom Animations

Want your glassmorphic layer to make a grand entrance? Provide your own enter and exit animations:

contentEnterAnimation = slideInVertically() + fadeIn()
contentExitAnimation = slideOutVertically() + fadeOut()

4. Blur a Specific View

Get focused by blurring a specific view instead of the whole screen:

blurSourceView = myCustomView

The Secret Sauce: Implementing the Blur Effect

Now, let's dive into the heart of our glassmorphic effect: the blur implementation. This is where things get really interesting!

Blurring Across Android Versions

One of the challenges in implementing a consistent glassmorphic effect is dealing with different Android versions. Our GlassmorphicLayer component handles this elegantly:

• On Android 12 and above: We use the blur modifier directly on the current view snapshot.

• On lower Android versions: We apply the blurring on the snapshot bitmap itself.

Let's break this down step by step:

Step 1: Capturing the View as a Bitmap

First, we need to capture our current view as a bitmap. Here's how we do it:

fun View.captureViewAsBitmap(callback: (Bitmap?) -> Unit) {
    val window = context.findActivity()?.window
    if (window == null) {
        callback(null)
    } else {
        captureViewAsBitmap(window, callback)
    }
}

fun View.captureViewAsBitmap(
    window: Window,
    callback: (Bitmap?) -> Unit,
) {
    val bitmap =
        Bitmap.createBitmap(
            // The width of the view to be captured
            width,
            // The height of the view to be captured
            height,
            // The bitmap configuration (32-bit color with alpha)
            Bitmap.Config.ARGB_8888,
        )
    val location = IntArray(2)
    // Gets the location of the view within the window
    getLocationInWindow(location)
    val bounds =
        Rect(
            location[0], // Left bound
            location[1], // Top bound
            location[0] + width, // Right bound
            location[1] + height, // Bottom bound
        )
    runCatching {
        PixelCopy.request(
            window,
            bounds,
            bitmap,
            {
                when (it) {
                    // Capture succeeded
                    PixelCopy.SUCCESS -> callback(bitmap)
                    // Capture failed
                    else -> callback(null)
                }
            },
            // Ensures the callback is handled on the main thread
            Handler(Looper.getMainLooper()),
        )
    }.onFailure {
        // Fallback to return null in case of failure
        callback(null)
    }
}

This function uses a neat trick to find the associated Activity and its window, then captures the view's content as a bitmap.

Step 2: Applying the Blur Effect

Now comes the magic part - applying the blur effect. For Android versions below 12, we use a custom blur function:

fun Bitmap.blur(context: Context, radius: Float = 25F): Bitmap {
    // Ensure the blur radius is within the valid range (1 to 25)
    val radiusResolved = radius.coerceIn(1f, 25f)

    // Scale down the bitmap for better performance
    val blurScale = 0.1F
    val blurWidth = (width * blurScale).roundToInt()
    val blurHeight = (height * blurScale).roundToInt()
    val inputBitmap = Bitmap.createScaledBitmap(this, blurWidth, blurHeight, false)

    // Apply the blur using RenderScript
    val renderScript = RenderScript.create(context)
    val intrinsic = ScriptIntrinsicBlur.create(renderScript, Element.U8_4(renderScript))
    val allocationInput = Allocation.createFromBitmap(renderScript, inputBitmap)
    val allocationOutput = Allocation.createFromBitmap(renderScript, inputBitmap)

    intrinsic.setRadius(radiusResolved)
    intrinsic.setInput(allocationInput)
    intrinsic.forEach(allocationOutput)

    allocationOutput.copyTo(inputBitmap)

    // Scale the bitmap back up to the original size
    return Bitmap.createScaledBitmap(inputBitmap, width, height, false)
}

This function does a few cool things:

1. It scales down the bitmap for better performance.

2. Applies the blur using RenderScript (a high-performance runtime that provides computationally intensive operations).

3. Scales the bitmap back up to its original size.

The Glassmorphic Magic Revealed

Now, let's see how we tie this all together in our glassmorph modifier:

@Composable
private fun Modifier.glassmorph(
    transitionStiffness: Float,
    visibilityState: State<Boolean>,
): Modifier {
    val blur by animateDpAsState(
        targetValue = if (visibilityState.value) 60.dp else 0.dp,
        animationSpec = spring(stiffness = transitionStiffness),
        label = "glassmorphic effect",
    )
    return this.blur(
        radius = blur,
    )
}

This modifier does something really clever:

• For Android 12 and above, it uses the built-in blur modifier.

• For older versions, it captures the view as a bitmap, applies our custom blur function, and then draws the blurred bitmap on top of the original content.

Why This Approach Rocks

1. Compatibility: It works across different Android versions, ensuring a consistent look for all users.

2. Performance: By scaling down the bitmap before blurring, we keep things smooth and snappy.

3. Customizability: The blur radius is animated, allowing for smooth transitions.

Putting It All Together

When you use the GlassmorphicLayer in your app, all this complexity is handled for you behind the scenes. You get a beautiful, performant glassmorphic effect without having to worry about the nitty-gritty details of bitmap manipulation or version-specific implementations.

Challenges Along the Way (and How to Overcome Them)

As with any journey, you might encounter some bumps in the road. Here are some common challenges and how to overcome them:

1. Performance Issues

Challenge: The blur effect might be slow on older devices.

Solution: Use a lower blur radius or disable the effect for low-end devices.

val blurRadius = if (isLowEndDevice()) 0.dp else 10.dp

2. Content Visibility

Challenge: Text might be hard to read on the blurred background.

Solution: Add a semi-opaque background to your content or increase text contrast.

Text(
    "Glassmorphic Content",
    modifier = Modifier
        .background(Color.White.copy(alpha = 0.7f))
        .padding(16.dp),
    color = Color.Black
)

3. Inconsistent Look

Challenge: The effect looks different on various devices.

Solution: Test across devices and adjust blur/transparency for consistency.

Best Practices for Your Glassmorphic Journey

As you continue to explore and implement glassmorphic effects in your app, keep these best practices in mind:

1. Start Simple: Begin with the basic implementation before adding complex customizations.

2. Test Frequently: Check your UI on different devices and screen sizes.

3. Performance Matters: Be mindful of performance, especially on lower-end devices.

4. Accessibility: Ensure your glassmorphic UI is accessible to all users.

5. Consistent Design: Use the effect consistently throughout your app for a cohesive look.

Wrapping Up: Your Glassmorphic Adventure Awaits!

Congratulations! You've now embarked on the exciting journey of implementing the GlassmorphicLayer in Jetpack Compose. With this powerful tool in your arsenal, you're ready to create stunning, modern UIs that will captivate your users.

Remember, the key to mastering any new technique is practice. So go forth and experiment! Try implementing the GlassmorphicLayer in different parts of your app, play with customizations, and most importantly, have fun with it!

Who knows? Your next app could be the standout with its sleek glassmorphic UI. Happy coding, and may your interfaces always be as smooth as frosted glass!

👉 See full implementation

In the upcoming sections, we will discuss the different types of Macros, provide an example of how to implement your first Macro, explore cases where Macros can enhance our code, and demonstrate how we used them at Klivvr to eliminate boilerplate code.

Types of Macros

• Freestanding Macros: Appear on their own without being attached to any declaration and start with #, such as #Error() and #warning().

• Attached Macros: Modify the declaration they are attached to, using the @ symbol before the name of the Macro.

Freestanding Macros

There are two types of freestanding Macros:

• Expression Freestanding Macro: Used to create a piece of code that returns a value.

• Declaration Freestanding Macro: Used to create a new declaration.

Attached Macros

There are five types of attached Macros:

• Attached Peer: Adds a new declaration alongside the declaration it’s applied to.

• Attached Accessor: Adds accessors (like willSet, didSet, get, set) to the property it’s applied to.

• Attached Member Attribute: Adds attributes to the declarations in the type or extension it’s applied to.

• Attached Member: Adds a new declaration in the type or extension it’s applied to.

• Attached Conformance: Adds conformances to the type or extension it’s applied to.

Now that we’ve explored the available types of Macros, let’s dive into creating a Macro and how it can enhance our codebase.

Macro Implementation Example

In this section we will explore how to create a Macro that generates a non-optional url from a string. The problem is that we need to check the url value using a guard statement every time we create a url from a string, like so:

So we need to avoid this boilerplate code, plus the URL(string: ) will always generate a value—the only case where it will generate nil is if the string is empty. We can go one step further by making the macro generates a compile time error if the given string doesn’t follow a certain formate, this will give us the ability to check all the URL in our code during compile time.

1. Create a SPM

The first step is to open Xcode 😂, then go to file > new > package. Then you will have a pop up like so:

You will choose Swift Macro and this will open a new Swift Package Manger (SPM) that contains a simple macro implementation called stringify.

Note: To create a macro, it must be contained in SPM. You can add as many macros as you need in the same SPM. Probably by now you have noticed that the SPM you have created depends on swift-syntax, this is the only requirement to create swift macro.

You will end up having something like this:

2. Declare a Macro

To declare a macro, we need to specify the type. The goal is to be able to call this macro in any point in our code base without having to add it to a declaration. With that in mind, we will choose the freestanding type for the macro. Going a step further, we’ll need to specify which type of freestanding macro we are going to use. We need the output of the macro to be a URL and this output is not a new declaration so we will use the freestanding expression macro. To write that in code it will be as follows:

@freestanding(expression)
public macro safeUrlFrom(_ urlString: String) -> URL = 
#externalMacro(module: "MyMacroMacros", type: "URLMacro")

The notation @freestanding(expression) specifies the type of macro, then we add the public keyword to expose the macro for use outside the SPM. Then you use the macro keyword to declare a new macro then you write the name of the macro and the parameters for it and the return type of the macro. After the = sign you basically tell the compiler where is the implementation of the macro in the SPM using the #externalMacro(module: "MyMacroMacros", type: "URLMacro") , you give it the name of the module that contains the implementation of the macro and the name of type that contains the implementation. This is because the implementation of the macros are contained in struct . Now you have declared the macro in the next step we will see how it will be implemented.

Note: The declaration of macro is in this file MyMacro:

3. Implementation of the Macro

So as we declared in the #externalMacro(module: "MyMacroMacros", type: "URLMacro") the implementation will be in the MyMacroMacros module, you will find a file that already exits in the module, navigate to this file and let’s implement our first macro.

First we will declare a struct called URLMacro as we wrote in the #externalMacro and we will make it conform to the ExpressionMacro protocol since we declared our macro as freestanding expression, it will look like that :

As you see this protocol have only one requirement which is the expansion method which will contains the implementation of the macro, this method is called when the macro is called.

Since our macro takes parameter as an input so we must first check if the arguments where passed and if they are the right type or not other wise we will throw a compile time error. it looks like this:

All arguments passed to the macro are accessed through the node.argumentList this will gives us an array of the arguments passed to the macro since we only have one parameter we took only the first element, we made a guard statement to throw a compile time error if we found the first element to be nil (which means the arguments weren’t passed). The argument is of type LabeledExprSyntax which contains the passed value to the macro, if you tried to pass "www.klivvr.com" as argument and tried to print the value it will look something like this in the console:

Note: We’ll get to the details of how we created the URLMacroErrors enum to throw compile time errors at the end of the article.

The second thing we need to do is to check if the type of the argument is of type String. In the swift-syntax package, string is represented by the StringLiteralExprSyntax so basically what we need to do is to type case the argument from LabeledExprSyntax to StringLiteralExprSyntax, if it succeed this means a String was passed, if not this means the argument is not a String. To do this we assed the expression property and casted it using the as(StringLiteralExprSyntax.self)? then we assed the segments which contains the string we want.

To be able to understand what I did next let me explain first what is the StringLiteralExprSyntax. This is basically the tree syntax representation of string type in the https://github.com/swiftlang/swift-syntax package, every root of the tree contains a property that represent something in the string type, to understand what I mean let’s print it and see what it looks like:

As you see this why we assed the segments property to get the string we want, but why it called segments? Because every space in the string is basically a separator between two segments, for example: “Omar is the best 😅😎” here we have 5 segments on the other hand something like "www.klivvr.com" has only one segment. This is why the second condition in the guard is case .stringSegment(let segment)? = segments.first. This line takes the first element in the segments and makes sure it is equal to the .stringSegment case then we created the urlString from the segment.content.text like:

let urlString = segment.content.text

The third step we need to do is to check if the string is a valid url or not. If not, we will throw a compile time error, it will look something like:

We checked first if we can make a url from the urlString using the URL(string: urlString) then we checked if the url have a host and a scheme or url is a file url at this point we can say it is a valid url. After that we can return the url:

return "URL(string: \\(argument))!"

This ExprSyntax is then converted by the compiler to URL(string: \\(argument))!. Before celebrating our first macro, let’s first see how I created the URLMacroErrors enum to throw compile time errors.

4. URLMacroErrors

As you can see, the URLMacroErrors is an enum that conforms to two protocols Errors and the CustomStringConvertible. It has one requirement: the description property, which represents the message that will be represented with the compile time error.

Alert: Don’t forget to add the type in MyMacroPlugin like so:

Final outcome is as follows:

The macro succeeded in the first one because we passed a valid url that contains a scheme and a host but for the second one we didn’t specify the scheme hence why it failed.

Testing your Macro

The last step is to test our Macro. To test your macro, add a new key-value pair in the testMacros. The key represent the name of the macro, and the value represent the macro type. In this case, the value is URLMacro.self. Then you will call the assertMacroExpansion method in a test method. It takes two parameters, the originalSource which represent the calling of the macro, and the expandedSource which represents the expected output from the macro. If the actual output is equal, the expected output you wrote in the assertMacroExpansion test will pass, otherwise it will fail.

Enhancing Code Efficiency with Swift Macros

Swift Macros are a powerful feature that enables you to write cleaner, more maintainable code by reducing boilerplate and enforcing compile-time checks. At Klivvr, we’ve started using Macros to streamline our code, and we encourage developers to explore this feature in their projects to enhance efficiency. Good luck as you dive into the world of Swift Macros! 🍀

Resources

Macro created: https://github.com/EngOmarElsayed/URLMacro.git

Macro examples:

https://github.com/swiftlang/swift-syntax/tree/main/Examples/Tests/MacroExamples/Implementation

WWDC sessions:

https://developer.apple.com/wwdc23/10166

https://developer.apple.com/wwdc23/10167

Too Many Supplies:

Schools have this habit of sending unnecessarily long lists of required supplies, even though we all know our kids won’t be needing 50 bottles of acrylic paint of different shades or 3 sets of watercolor brushes. Go through all the from last year and cross them off your list! Be realistic with what your kid actually needs and avoid just-in-case purchases.

Uniform Dilemma:

They grow up so fast, don’t they? No, literally! Size up for all their school uniforms so you don’t need to buy the exact same thing each year for double the price!

Last Minute:

Well, waiting till the day before they go back is the perfect move if you want to break the bank. Shop a little bit earlier before prices go crazy! It will also help you avoid the crowd and find everything you need smoothly.

Impulsive Buying:

Back to school shopping is the closest thing to the Hunger Games. We need to find the best quality at the best prices. And what does this need? Hunting! Look for different offers and don’t just buy from the first shop you pop into!

Well, this just scratches the surface of what goes down before school starts! Happy shopping with your littles!

Without a design system, you’re navigating a risky terrain—where each inconsistency could lead to confusion, weaken our brand identity, or leave users frustrated. In this article, we’ll unpack the essentials of design systems, delve into why they’re crucial to Klivvr’s success, and show you how to build one that not only elevates our digital presence but also shields it from design disarray.

We’ll also explore how design systems can revolutionize your approach to Android app design and guide you through implementing them in Jetpack Compose, making Klivvr’s user experience even more seamless and engaging.

What is a Design System?

At its core, a design system is a collection of standardized building blocks and guidelines that ensure consistency across products and experiences. For us, it’s like having a blueprint that offers a unified language and structured framework, guiding our teams through the complex process of crafting digital financial solutions. This approach streamlines the design and development process, minimizing the need to reinvent elements and patterns, which saves valuable time and effort as we build and scale our products and interfaces.

Components of a Design System

You can visualize the hierarchy in design systems like this:

1) Foundation

These are the building blocks that establish your product’s visual language, defining its look and feel through elements like color and typography. They also include icons, logos, illustrations, and crucial guidelines for accessibility and brand consistency, ensuring that everything from voice to tone aligns with your product’s identity.

2) Components

Here, you’ll discover reusable visual elements and interaction patterns that shape your product’s common interface and behavior. This includes templates, layouts, interaction patterns, code snippets, and components—each backed by detailed documentation to ensure consistency and efficiency throughout the design and development process.

3) Design System

At the top of the hierarchy is the design system itself—a comprehensive, ever-evolving resource that unites all foundational elements, components, and guidelines. It encompasses technical specifications, design tokens, documentation, and best practices, along with core principles and processes to steer UX design and product development across your entire ecosystem.

Why Use a Design System?

The true power of a design system lies in its ability to streamline workflows, ensure consistency across products, and foster collaboration among cross-functional teams. Whether you’re starting small or scaling across multiple platforms, a design system empowers the team to achieve more with less—not only in designing features but in bringing them to life.

At Klivvr, our design system serves as a single source of truth, eliminating design redundancy and speeding up the development process. Rather than spending time recreating components, our designers can draw from a library of brand-approved, development-ready options to quickly build out designs. With components crafted using code, tokens, and animation presets our developers can translate these designs into functional, accessible code in a fraction of the time. This approach has revolutionized Klivvr’s product development lifecycle, enabling us to bring products to market faster and deliver a seamless user experience.

Design System in Jetpack Compose

Jetpack Compose streamlines the implementation of a design system, making it easy to create a consistent look and feel for your app through theming, components, and more.

Getting Started

implementation "androidx.compose.material3:material3:$material3_version"

Once the dependency is added, you can start integrating Material Design elements such as color, typography, and shape into your apps, ensuring a cohesive and polished user experience.

Foundation

The foundation consists of essential subsystems like color schemes, typography, shapes, spacing, and themes. Customizing these elements automatically updates the components in your app, ensuring a consistent and personalized design throughout.

Color Schemes

The foundation of a color scheme is based on a set of key colors—primary, success, alert, danger, and neutral. Each of these colors corresponds to a tonal palette comprising several tones, which are utilized by Material components. For example:

internal object Color {
    object Base {
        val black = Color(0xFF000000)
        val white = Color(0xFFffffff)
    }

    object Light {
        val primary50 = Color(0xFFF3EEFE)
        val primary100 = Color(0xFFDECFFC)

        val success50 = Color(0xFFD8FDDE)
        val success100 = Color(0xFFB2E6CC)

        val alert50 = Color(0xFFFDF3D8)
        val alert100 = Color(0xFFFCE6A4)

        val danger50 = Color(0xFFF7E3E7)
        val danger100 = Color(0xFFF1A7B5)

        val neutral50 = Color(0xFFF4F4F6)
        val neutral100 = Color(0xFFECECEF)
    }

    object Dark {
        val primary50 = Color(0xFFDFD3F8)
        val primary100 = Color(0xFFB397ED)

        val success50 = Color(0xFFDCF9E1)
        val success100 = Color(0xFFB8E0CC)

        val alert50 = Color(0xFFFBF2DA)
        val alert100 = Color(0xFFF6E3AA)

        val danger50 = Color(0xFFF6E4E8)
        val danger100 = Color(0xFFEBADB9)

        val neutral50 = Color(0xFFF5F5F5)
        val neutral100 = Color(0xFFECECEF)
    }
}

Next, we need to establish the color tokens.

Color Tokens Contract

internal interface ColorTokens {
    // Base
    val baseWhite: Color
    val baseBlack: Color

    // Background
    val background: Color
    val onBackground: Color
    val onBackgroundVariant: Color

    // Primary
    val primary: Color
    val onPrimary: Color
    val primaryContainer: Color
    val onPrimaryContainer: Color

    // Success
    val success: Color
    val onSuccess: Color
    val successContainer: Color
    val onSuccessContainer: Color

    // Alert
    val alert: Color
    val onAlert: Color
    val alertContainer: Color
    val onAlertContainer: Color

    // Error
    val error: Color
    val onError: Color
    val errorContainer: Color
    val onErrorContainer: Color

    // Surface
    val surface: Color
    val surfaceContainer: Color
    val surfaceDim: Color
    val onSurface: Color
    val onSurfaceVariant: Color

    // outline
    val outline: Color
    val outlineVariant: Color
}

Light Color Tokens

internal object LightColorTokens : ColorTokens {
    override val baseWhite = Color.Base.white
    override val baseBlack = Color.Base.black
    override val background = Color.Light.neutral50
    override val onBackground = Color.Light.neutral900
    override val onBackgroundVariant = Color.Light.neutral500
    override val primary = Color.Light.primary400
    override val onPrimary = Color.Base.white
    override val primaryContainer = Color.Light.primary50
    override val onPrimaryContainer = Color.Light.primary400
    override val success = Color.Light.success600
    override val onSuccess = Color.Base.white
    override val successContainer = Color.Light.success50
    override val onSuccessContainer = Color.Light.success600
    override val alert = Color.Light.alert400
    override val onAlert = Color.Light.alert900
    override val alertContainer = Color.Light.alert50
    override val onAlertContainer = Color.Light.alert900
    override val error = Color.Light.danger400
    override val onError = Color.Base.white
    override val errorContainer = Color.Light.danger50
    override val onErrorContainer = Color.Light.danger400
    override val surface = Color.Base.white
    override val surfaceContainer = Color.Light.neutral50
    override val surfaceDim = Color.Light.neutral200
    override val onSurface = Color.Light.neutral900
    override val onSurfaceVariant = Color.Light.neutral500
    override val outline = Color.Base.black.copy(alpha = .1F)
    override val outlineVariant = Color.Base.black.copy(alpha = .06F)
}

As you can see, color tokens enhance the design process by replacing static values with intuitive names like “primary” or “on primary.” This method also allows us to define different values for light mode and dark mode while maintaining meaningful naming conventions, ensuring a seamless and adaptable user experience.

Next, we need to integrate the color schemes into a format that Material Design can recognize. We achieve this by creating a color scheme and passing in the color token values. While it’s possible to manually create a custom color scheme, it’s typically more efficient to generate one using your brand’s source colors. Here’s how to do it:

val colorScheme
    @Composable
    get() =
        if (isSystemInDarkTheme()) {
            darkColorScheme
        } else {
            lightColorScheme
        }

private val lightColorScheme =
    lightColorScheme(
        primary = LightColorTokens.primary,
        onPrimary = LightColorTokens.onPrimary,
        primaryContainer = LightColorTokens.primaryContainer,
        onPrimaryContainer = LightColorTokens.onPrimaryContainer,
        secondary = Color.Light.primary200,
        onSecondary = Color.Light.neutral900,
        background = LightColorTokens.background,
        onBackground = LightColorTokens.onBackground,
        surface = LightColorTokens.surface,
        onSurface = LightColorTokens.onSurface,
        surfaceVariant = LightColorTokens.surfaceDim,
        onSurfaceVariant = LightColorTokens.onSurfaceVariant,
        surfaceContainer = LightColorTokens.surfaceContainer,
        error = LightColorTokens.error,
        onError = LightColorTokens.onError,
        errorContainer = LightColorTokens.errorContainer,
        onErrorContainer = LightColorTokens.onErrorContainer,
        outline = LightColorTokens.outline,
        outlineVariant = LightColorTokens.outlineVariant,
        scrim = LightColorTokens.baseBlack,
    )

private val darkColorScheme =
    darkColorScheme(
        primary = DarkColorTokens.primary,
        onPrimary = DarkColorTokens.onPrimary,
        primaryContainer = DarkColorTokens.primaryContainer,
        onPrimaryContainer = DarkColorTokens.onPrimaryContainer,
        secondary = Color.Dark.primary200,
        onSecondary = Color.Dark.neutral900,
        background = DarkColorTokens.background,
        onBackground = DarkColorTokens.onBackground,
        surface = DarkColorTokens.surface,
        onSurface = DarkColorTokens.onSurface,
        surfaceVariant = DarkColorTokens.surfaceDim,
        onSurfaceVariant = DarkColorTokens.onSurfaceVariant,
        surfaceContainer = DarkColorTokens.surfaceContainer,
        error = DarkColorTokens.error,
        onError = DarkColorTokens.onError,
        errorContainer = DarkColorTokens.errorContainer,
        onErrorContainer = DarkColorTokens.onErrorContainer,
        outline = DarkColorTokens.outline,
        outlineVariant = DarkColorTokens.outlineVariant,
        scrim = DarkColorTokens.baseBlack,
    )

Next, let’s incorporate the color schemes into our custom theme.

@Composable
fun KlivvrTheme(
    content: @Composable () -> Unit,
) {
    MaterialTheme(
        colorScheme = colorScheme,
        content = content,
    )
}

Usage

KlivvrTheme {
    Text(
        color = MaterialTheme.colorScheme.primary,
        text = "Awesome text",
    )
}

That’s it! Your text color will now dynamically adjust in response to dark mode changes. Furthermore, with color tokens in place, altering the color values is as easy as directing a token to a different color value, and these changes will reflect instantly across the project without requiring any adjustments to the UI components.

val ColorScheme.success: Color
    @Composable
    get() =
        if (isSystemInDarkTheme()) {
            DarkColorTokens.success
        } else {
            LightColorTokens.success
        }

Typography

Typography is just as fundamental to a design system as colors and components. Establishing patterns for consistent and legible typography early in the design process is essential. This approach not only facilitates scaling typography across various applications and devices but also simplifies the handoff between designers and developers.

Material Design outlines a type scale with a streamlined naming and grouping system that includes display, headline, title, body, and label. Each category is further divided into large, medium, and small sizes, ensuring clarity and coherence throughout your design.

Similar to the color scheme, we will start by defining the text style contract.

internal interface TextStyles {
    val displayLarge: TextStyle
    val displayMedium: TextStyle
    val displaySmall: TextStyle

    val headingLarge: TextStyle
    val headingMedium: TextStyle
    val headingSmall: TextStyle

    val titleLarge: TextStyle
    val titleMedium: TextStyle
    val titleSmall: TextStyle

    val bodyLarge: TextStyle
    val bodyMedium: TextStyle
    val bodySmall: TextStyle

    val labelLarge: TextStyle
    val labelMedium: TextStyle
    val labelSmall: TextStyle
}

Next, we can define different styles of implementation for dark and light modes tailored to each locale. For example:

English text styles (Light/Dark)

private object TypeEN {
    private val fontFamilyResId = R.font.hauora

    object Light : TextStyles {
        override val displayLarge =
            getTextStyle(
                fontFamilyResId = fontFamilyResId,
                fontSize = 56.sp,
                lineHeight = 60.sp,
                weight = 700,
                letterSpacing = -1.20f,
            )
       // Same goes for the rest
    }
}

private fun getTextStyle(
    fontFamilyResId: Int,
    fontSize: TextUnit,
    lineHeight: TextUnit,
    weight: Int,
    letterSpacing: Float,
) = TextStyle(
    fontFamily =
        FontFamily(
            Font(
                resId = fontFamilyResId,
                variationSettings = FontVariation.Settings(FontVariation.weight(weight)),
            ),
        ),
    fontSize = fontSize,
    lineHeight = lineHeight,
    letterSpacing = (letterSpacing / 100) * fontSize,
)

Next, we can generate our Material Design typography in the same way we created the color scheme.

val typography
    @Composable
    get() =
        if (isSystemInDarkTheme()) {
            TypeEnDark
        } else {
            TypeEnLight
        }

val TypeEnLight = Typography(
    displayMedium = TypeEN.Light.displayMedium,
    headlineLarge = TypeEN.Light.headingLarge,
    headlineMedium = TypeEN.Light.headingMedium,
    headlineSmall = TypeEN.Light.headingSmall,
    titleLarge = TypeEN.Light.titleLarge,
    titleMedium = TypeEN.Light.titleMedium,
    titleSmall = TypeEN.Light.titleSmall,
    bodyLarge = TypeEN.Light.bodyLarge,
    bodyMedium = TypeEN.Light.bodyMedium,
    bodySmall = TypeEN.Light.bodySmall,
    labelLarge = TypeEN.Light.labelLarge,
    labelMedium = TypeEN.Light.labelMedium,
    labelSmall = TypeEN.Light.labelSmall,
)

val TypeEnDark = Typography(
    displayMedium = TypeEN.Dark.displayMedium,
    headlineLarge = TypeEN.Dark.headingLarge,
    headlineMedium = TypeEN.Dark.headingMedium,
    headlineSmall = TypeEN.Dark.headingSmall,
    titleLarge = TypeEN.Dark.titleLarge,
    titleMedium = TypeEN.Dark.titleMedium,
    titleSmall = TypeEN.Dark.titleSmall,
    bodyLarge = TypeEN.Dark.bodyLarge,
    bodyMedium = TypeEN.Dark.bodyMedium,
    bodySmall = TypeEN.Dark.bodySmall,
    labelLarge = TypeEN.Dark.labelLarge,
    labelMedium = TypeEN.Dark.labelMedium,
    labelSmall = TypeEN.Dark.labelSmall,
)

Next, let’s incorporate the typography into our custom theme.​

@Composable
fun KlivvrTheme(
    content: @Composable () -> Unit,
) {
    MaterialTheme(
        colorScheme = colorScheme,
        typography = typography,
        content = content,
    )
}

Usage

KlivvrTheme {
    Text(
        color = MaterialTheme.colorScheme.primary,
        style = MaterialTheme.typography.bodyMedium,
        text = "Awesome text",
    )
}

That’s it! Your typography will now dynamically adjust in response to dark mode or locale changes. Plus, with typography tokens in place, updating the text styles is as simple as modifying the text style attributes, and these changes will instantly reflect across the project without requiring any adjustments to the UI components.

Spacing

A spacing system streamlines the creation of page layouts and UI. The consistent and intentional use of a spacing system fosters a more harmonious experience for the end user. A well-defined spacing system also lays the groundwork for responsive design and customizable UI density, enhancing the overall quality and accessibility of our products in the future.

Unlike color schemes and typography, spacing isn’t a predefined attribute in the Material theme. However, we can achieve similar declarative behavior by utilizing extension functions.

object Space {
    val space100 = 4.dp
    val space200 = 8.dp
    val space300 = 12.dp
    val space400 = 16.dp
    val space500 = 20.dp
    val space600 = 24.dp
    val space800 = 32.dp
}

val MaterialTheme.spaces get() = Space

Usage

KlivvrTheme {
    Text(
        modifier = Modifier.padding(MaterialTheme.spaces.space400),
        color = MaterialTheme.colorScheme.primary,
        style = MaterialTheme.typography.bodyMedium,
        text = "Awesome text",
    )
}

TL;DR

Design systems are crucial for crafting consistent and cohesive digital experiences, incorporating elements such as colors, typography, and components. They streamline workflows, uphold brand consistency, and enhance collaboration among cross-functional teams. This article delves into the fundamentals of design systems, highlighting their significance and offering insights on how to build and implement them effectively—particularly in Android app development using Jetpack Compose. It provides detailed guidance on creating color schemes, typography, and spacing systems to ensure a seamless and adaptable user experience.

Accessing String Resources

Imagine you've added a string in your resources file like this:

Now, you want to access this string in your code. Here's what that might look like:

To get this string, you first need to use Context. But why?

Why Context is Necessary

Android stores resources like strings, drawables, and colors using its framework. When you create a resource file, the Android framework handles its storage. But when you want to retrieve this file, you need to ask the system for it. Here’s where Context comes in.

Context is your gateway to the Android system—it allows you to communicate with the operating system to access resources, services, and more.

Think of it like communicating with a friend. To reach them, you use your mobile phone, which acts as a bridge. Similarly, Context is the bridge between your app and the Android system.

In summary: Context is the bridge between you and the operating system.

Why Views Need Context

Every view in Android requires Context. Why? Because views often need to access system resources—like colors, strings, or the current app mode (light or dark). To retrieve these resources, the view needs to communicate with the system, which is done through Context.

Different Types of Context in Android

Android provides five main types of Context:

• Application Context

• Activity Context

• Service Context

• BroadcastReceiver Context

• Content Provider Context

You're probably most familiar with Application and Activity contexts, as they're the ones you use most frequently. However, each type serves a different purpose and provides access to different system resources.

Misconceptions About Memory Leaks

A common concern when using Context is avoiding memory leaks. Let’s go through two scenarios:

Scenario 1: Accessing SharedPreferences in an Activity

If you use getApplicationContext() to access SharedPreferences, will it cause a memory leak? No, it won’t.

Scenario 2: Holding a Reference to an Activity in the Application Class

If you hold a reference to an Activity in your Application class, will it cause a memory leak? Yes, it will. The garbage collector can’t reclaim the memory used by the Activity if the Application class holds a reference to it, leading to a memory leak.

This highlights the importance of using the right Context in the right situation.

Responsibilities of Different Contexts

Each type of Context has specific responsibilities. For example:

• The Application Context cannot start a dialogue. Let’s see what happens when you try:

When you run this code, you’ll get the following error:

android.view.WindowManager$BadTokenException: Unable to add window -- token null is not valid; is your activity running?

This shows that each Context type has specific limitations and responsibilities. Here’s a table that outlines what each type of Context can and cannot do:

The financial services industry is a prime target for cybercriminals due to the sensitive nature of the information it holds. At Klivvr, we recognize the gravity of this responsibility and are committed to safeguarding the PII of our clients while innovating within the regulatory framework.

Why PII Confidentiality Matters in Financial Services

The financial sector handles an enormous amount of sensitive data daily. From loan applications to transaction records, PII is constantly in transit and at risk of exposure. A breach of this information can lead to severe consequences, including identity theft, financial loss, and a loss of trust in the institution.

Regulatory bodies like the Central Bank of Egypt (CBE) and the Financial Regulatory Authority (FRA) impose strict guidelines on how financial institutions manage PII. Compliance with these regulations is not just about avoiding penalties; it is about maintaining the integrity of the financial system and protecting the rights of individuals.

At Klivvr, we understand that safeguarding PII is not just a regulatory requirement but a core aspect of our responsibility to our clients. We continuously innovate to enhance our security measures, ensuring that our practices are always in line with the latest regulatory standards.

Securing PII: Best Practices

1. Data Encryption: One of the most effective ways to protect PII is through encryption. By converting data into a secure format, even if intercepted, it cannot be read without the appropriate decryption key. We employ advanced encryption techniques to protect PII at all stages—whether at rest, in transit, or in use.

2. Access Controls: Limiting access to PII is crucial. Only authorized personnel should have access to sensitive information, and this access should be regularly reviewed and adjusted based on roles and responsibilities. We implement strict access controls, ensuring that PII is accessible only to those who need it to perform their duties.

3. Regular Audits and Monitoring: Continuous monitoring and regular audits are essential to detect and respond to potential security breaches promptly. We utilize state-of-the-art monitoring tools that provide real-time alerts and detailed audit trails, ensuring that any suspicious activity is identified and addressed immediately.

4. Data Masking: Data masking techniques are used to protect PII in non-production environments, such as development and testing. This ensures that sensitive information is not exposed unnecessarily during these processes. We apply data masking across all relevant systems to minimize the risk of PII exposure.

5. Employee Training: Human error remains one of the most significant risks to PII confidentiality. Regular training ensures that all employees are aware of the importance of PII security and understand how to handle it appropriately. We conduct ongoing training sessions to keep our team updated on the latest security protocols and best practices.

Challenges and Considerations

Securing PII is not without its challenges. The ever-evolving nature of cyber threats means that financial institutions must stay ahead of the curve. We are committed to continuous improvement, investing in the latest technologies and methodologies to enhance our security posture.

Alternative Viewpoints

• Innovation vs. Regulation: Some argue that over-regulation can stifle innovation in financial services. While it is true that compliance can introduce additional steps and complexities, we see regulation as an opportunity to innovate securely. By integrating compliance into our innovation process, we ensure that our solutions are both cutting-edge and safe.

• Balancing Security with User Experience: Others emphasize the importance of balancing security with user experience. We believe that robust security should not come at the cost of usability. We strive to create solutions that are secure yet intuitive, providing our clients with peace of mind and a seamless experience.

Path Forward

As the financial landscape continues to evolve, the importance of PII confidentiality cannot be overstated. At Klivvr, we are committed to leading by example, ensuring that our practices not only comply with regulations but also set new standards for innovation and security in the financial services sector. By staying vigilant and proactive, we aim to protect our clients' information while fostering a culture of trust and integrity.

Let’s start by creating a project with an activity and override the default constructor. The simplest way to check the path to a constructor is by placing a breakpoint on it. It will enable us to walk through all the calls and explore the implemented code to find exactly what we want. Executing the project will result in the following:

In any Unix-based operating system, the first thing the kernel does is to execute init process. Init is the root/parent of all processes executing on Linux.

As we can see at the very bottom of the debugger frames, Android internally calls something called ZygoteInit

What is ZygoteInit

As the name suggests, ZygoteInit is the genesis of the Android application. It gets its name from a dictionary definition: “The initial cell formed when a new organism is produced."

Android at its core has a process called Zygote, which starts at init. It’s a special Android OS process that enables shared code across Dalvik/Art VM. This process is a “warmed-up” process, meaning it preloads all the classes and resources that an app may potentially need at runtime into the system’s memory. It then forks itself to start a well-managed process called SystemServer which initializes all core platform services it houses. One of the core services that gets started by SystemServer, which is particularly relevant here, is ActivityManagerService.

ActivityManagerService: Where the Magic Happens

ActivityManagerService is responsible for creating new Activity thread processes, maintaining the Activity lifecycle, and managing the activity stack. During its startup, it performs three main steps:

1. Collect Target Activity Information

Full implementation: ActivityManagerService.resolveActivityInfo()

The first step is to collect information about the target activity. This is done by calling resolveIntent() method on some hidden implementation for IPackageManager interface. The target information is then saved back into the intent object to avoid redoing this step.

2. Check User Privileges

Full implementation: ActivityManagerService.grantUriPermissionLocked()

The next step is to check if the user has sufficient privileges to invoke the target activity. This is typically done by calling grantUriPermissionLocked() which ensures:

1. The target package has a valid UID associated with it.

2. The UID is used to check if the target package can grant permission to access the URI by calling checkGrantUriPermissionLocked()

3. After ensuring that the caller has all the necessary permissions, grantUriPermissionUncheckedLocked() grants them to the target package.

3. Activity Object Instantiation

Now to the juicy stuff, it’s time to check if the ProcessRecord already exists for the process. If the ProcessRecord is null, the ActivityManagerService must create a new process to instantiate the activity—duh. The instantiation is done with the help of ActivityThread class.

At this point, all required permissions have been granted, all the information about the target activity has been stored in the intent object, and the system has made sure that the user has all the privileges to invoke the target activity. Now it’s time to instantiate and launch the target Activity. This phase can be divided into three sub-phases:

3.1. Get the Environment Ready

Full implementation: ActivityThread.handleLaunchActivity()

First things first, let’s get the environment ready. It does so by calling handleLaunchActivity(). This ensures that configurations are up to date, the graphics environment is initialized, and the WindowManager is set up.

3.2. Retrieve the Previously Collected Information

Full implementation: ActivityThread: performLaunchActivity()

Next, previously collected information, such as ComponentName is retrieved, and the baseContext is created to prepare for instantiation.

3.3. The Instantiation

Full implementation: AppComponentFactory.instantiateActivity()

This is where it gets interesting. Android uses the help of Java's reflection library to execute the new Activity() statement. It does so by calling newActivity() method on the Instrumentation object which then delegates the action to theAppComponentFactory object by calling instantiateActivity() method.

After instantiation,ActivityThread proceeds by calling callActivityOnCreate(). And this is the start of what we all know as Activity Life Cycle 😄

TL;DR

This article delves into the behind-the-scenes process of launching Android activities, exploring why intents are used and what makes an Activity object unique. It covers the role of the Zygote process, the initialization of core services by SystemServer, and the crucial functions of ActivityManagerService. The article explains how the system collects target activity information, checks user privileges, and instantiates the Activity object using Java reflection. By the end, you'll understand the detailed steps involved in the activity lifecycle from creation to launch.

-Staycation

First off, do you want to keep the trip lowkey and go for a staycation? Visit Kempinski Somabay with your Klivvr card and get 10% off!

-Fit checks!

Prepping for the trip is sometimes more exciting than the trip itself. Bring your Pinterest board to life with our range of partners! Whether you want new sneakers, a fancy dress, or just some basics for your summer getaway, check out our list of lifestyle partners and get up to 25% off!

-Summer Glam

Get the summer look of your dreams at Al Sagheer Salon and get 15% off when you pay with your Klivvr card.

-Lock it!

There’s nothing scarier than losing your card, but it gets scarier when it happens while you’re out of town! But with Klivvr, you can easily lock your card with a tap through the Klivvr app!

-Extra cards

Want to have a romantic dinner with your partner but your kids are all about the nearby amusement park? No more fighting over the card. Request an extra card for your account and let everyone have the trip the way they want!

-Spend & Earn

With our cashback offers and K-points program, rest assured that you will keep earning all trip long every time you spend with your Klivvr card!

-Track your spending

Summer trips can make us get a bit carried away. But with Klivvr, you can set spending goals and have daily insights on your spending to make sure you are on the right track all trip long!

To sum it up, we got you covered. See you by the sea! 🌊

One of the key benefits to being part of a tech community is the access to a diverse range of experiences and perspectives. Members come from various backgrounds and levels of expertise, creating a rich environment for knowledge exchange. Whether you're a beginner looking to learn the basics or an experienced engineer seeking to refine your skills, tech communities offer valuable insights and resources.

Moreover, communities often host events such as meetups, workshops, and hackathons, to provide hands-on experience and opportunities to apply new concepts in real-world scenarios. These activities not only enhance technical skills but also foster collaboration and teamwork, which are essential in the software development industry.

Networking is another significant advantage. Being part of a tech community allows engineers to build connections with like-minded professionals, mentors, and potential collaborators. These relationships can lead to job opportunities, partnerships, or simply a strong support system within the industry.

In essence, tech communities serve as a catalyst for growth. They encourage continuous learning, provide a platform for sharing knowledge, and help engineers stay motivated and engaged in their field. For iOS engineers in particular, communities like Swift Cairo offer a specialized environment where members can deepen their expertise in Swift and related technologies, ultimately becoming better and more well-rounded software engineers.

The Story of Swift Cairo

Swift Cairo was established in 2018 by Abdoelrahman Eaita and Attia Elsayed, sparked by a simple tweet that asked, "Yala community?" This straightforward question became the catalyst for what would grow into a thriving local hub for iOS engineers. Seizing the momentum, they began reaching out to companies, creating social media channels, and organizing what would become the community’s first offline meetup. This initial event marked the beginning of a journey that has since connected and supported countless engineers in Egypt, helping them to refine their skills and advance in their careers. Later on, Mohamed El-Naggar joined as a Co-Founder, playing a crucial role in managing the community's activities and contributing to its ongoing success.

Community Activities

The heart of Swift Cairo's activities lies in our beloved monthly offline meetup. This event brings together iOS engineers from across Egypt, hosted within the offices of various tech companies. During these meetups, two or more engineers take the stage to deliver talks on a range of topics that are valuable to all attendees, whether they're seasoned professionals or just starting out.

The real magic happens during the breaks, where community members have the chance to network, share experiences, and forge lasting connections. These moments of interaction are where bonds are formed, ideas are exchanged, and memories are made—making each meetup an unforgettable experience that goes beyond just technical learning.

In addition to our offline meetups, the community engages in several other activities. We host reading sessions where members join online meetings to explore and discuss the source code from various open-source projects. This collaborative effort deepens our understanding and sparks insightful conversations.

We also send out a weekly 2newsletter, sharing useful articles, tools, industry news, and job opportunities with our community members. Additionally, we organize workshops focused on specific topics, offering both online and offline sessions to teach and engage our members with learning new skills and concepts.

Our community also hosts a podcast, where Eaita invites different guests for each episode to discuss topics that are relevant and valuable to our members.

We also maintain a Slack channel that serves as our community’s digital hub. Here, members can ask questions, share job opportunities, or engage in random discussions, fostering a sense of camaraderie and continuous support among peers.

Beyond these activities, we also provide services to companies within the tech industry. We assist with hiring processes, conduct interviews, and even recommend talented engineers from our community. In some cases, our members have also taken on projects or worked directly with these companies, further strengthening the connection between Swift Cairo and the broader tech ecosystem.

The Impact of COVID-19

The COVID-19 pandemic was undeniably a challenging time for everyone, and our community was no exception. As mentioned earlier, the heart of our activities has always been our in-person meetups. However, with the onset of the pandemic, we had to pause all offline events to prioritize the safety of our members.

While this period felt like a dark era for our community, it also presented an opportunity to adapt and innovate. We began hosting online webinars and virtual meetups, providing a platform for our members to continue learning and staying connected. We also found creative ways to maintain our sense of community, whether it was through online gaming sessions, casual virtual hangouts, or simply supporting one another during these tough times.

Despite the challenges, this period of adjustment allowed us to explore new ways of engaging with our community and keeping the spirit of Swift Cairo alive, even when we couldn't meet in person.

The Comeback

After the pandemic subsided, our community faced new challenges. Many of our senior members, including our two beloved founders, had moved abroad, leaving us in a period of transition. For a while, we struggled to regain the momentum that had once driven Swift Cairo.

Recognizing the need for fresh leadership, Attia decided to pass the torch. He posed a simple question to the community: "Who wants to give back to the community?" The response was overwhelming, with many members eager to step up and contribute. After a series of friendly calls and discussions, Attia made his decision.

Meet the new team behind Swift Cairo: Ahmed Ramzy, Asmaa Tarek, Ahmed Ramy, Ibrahim Hamed, and Nourhan Boghdadi.

We have taken on the responsibility to continue the journey and further develop the community. With a renewed sense of purpose, we made a triumphant return to our offline meetups, and there's much more on the horizon. The story of Swift Cairo is far from over, and we're excited to see where the next chapter takes us.

My Story

As a junior iOS engineer, I joined Swift Cairo in 2018, and eagerly attended most of the meetups. I vividly remember the excitement I felt before each event and the joy that came with receiving the meetup invitation. Every time, I returned home with a notebook full of key points, new concepts to explore, and ideas to deepen my understanding.

The community wasn't just about the meetups; I frequently posted questions on our Slack channel, where other members generously offered their help and guidance. These interactions played a significant role in shaping my career, providing me with the knowledge and support I needed to grow as an engineer.

Now, as a senior iOS engineer, I feel a deep sense of responsibility to give back. The community has been instrumental in my journey, and I’m committed to helping new engineers improve their skills and advance in their careers, just as the community did for me

What’s Next

Our mission is clear: "Take Egypt's engineers to the next level." To achieve this, we’re focusing on elevating the quality and scope of our meetups. We plan to explore a variety of perspectives, recognizing that it’s not always about the source code. We aim to provide a more holistic approach to engineering by diving into topics that broaden our understanding of the field.

In addition to our enhanced meetups, we have some exciting workshops in the pipeline, designed to challenge and inspire our members. These workshops will be announced very soon, and we can’t wait to see how they will further contribute to the growth of our community.

The journey of Swift Cairo is far from over, and we’re more committed than ever to help our engineers reach new heights.

Tech Communities: The Key to Opportunities

At Swift Cairo, we believe that every member has the power to make an impact. If you have an idea that could benefit the community, we’re always open to hearing it. Even small actions can have significant effects. For example, as you’re reading this, we’re excited to announce that we're partnering up with Klivvr for our next meetup on the 28th of August. This kind of support is invaluable, and it all starts with conversations. You can help by talking to your company’s management about our community and the positive impact it’s having on Egypt’s tech scene.

There are many ways to contribute. You can share useful tips, write articles, or even volunteer as a speaker for one of our upcoming meetups. Every contribution, big or small, helps us continue to grow and support our members.

Stay informed on our latests events and meetups by following us on X and LinkedIn.

Special Thanks

I want to extend my heartfelt greetings to everyone whose part of the Swift Cairo community. Whether you’ve been with us since the beginning or just joined, your participation and enthusiasm are what make this community so special. Together, we’ve built a space where iOS engineers can learn, grow, and support each other, and that’s something truly worth celebrating.

Thank you for being a part of this journey. Let’s continue to push the boundaries, share our knowledge, and take Swift Cairo to even greater heights. Here’s to the future of our community and the incredible things we’ll achieve together!

People started thinking, "Hey, why not store our precious coins somewhere safe?" Banks then created paper bills, like little certificates for the gold people left behind. The concept of notes became popular; people liked the idea of storing all their heavy gold with the bank, and receiving a bank note as proof of ownership.

Fast forward to today...

Money has gone through a major glow-up. The internet revolution spread and took over the world. People built online stores, and others bought from them. Physical wallets became digital wallets. Traditional banking gave way to digital banking. Physical money notes turned into digital money notes.

Money got a major glow-up in the internet era. We're talking digital wallets, online shopping, cryptocurrencies, and even apps like Klivvr to help us manage it all. Money has become a cultural icon, a topic for books, a muse for rappers, and a driving force behind dreams.

Money Is Mindset

Money isn’t just a tool we use to renew our mobile internet bundle. Money is more than just numbers; it's personal. In The Psychology of Money Morgan Housel explains that our financial decisions aren't always logical. They're shaped by our unique experiences, upbringing, and emotions. What seems like a smart move for one person might be totally different for another. Housel further elaborates on how money has become a mindset, a reflection of a person’s dreams and values, a maker of visions and a creator of visionaries.

Money Talks, Are You Listening?

Speaking of mindsets, Napoleon Hill says in his book Think and Grow Rich that your thoughts are like money magnets. Desire, faith, imagination, decisiveness, and persistence are all tools we humans can use to attract and generate massive wealth. Manifestation, eh? So, visualize that dream vacation with your new shiny car, and who knows? It might just come true. ✨

Financial Freedom: More Than Just Money in the Bank

Let's get real: Financial freedom isn't just about having a juicy bank account. It's about having the freedom to live life on your own terms. It's about chasing your passions, exploring the world, and making memories that last a lifetime. You do NOT need a man in finance, trust funds, 6'5, blue eyes (or be one yourself) to be good with money. It's more about controlling your impulses, developing good habits, and making consistent choices over time.

Klivvr: Your Money Companion

We understand money. Klivvr knows that money isn't just about numbers. We're here to make your financial life easier, more fun, and less stressful. Whether you're sending money to your bestie, splitting bills with your roommates, or saving for that dream vacation, we've got your back.

This not only frustrates the user but also you, the UX writer, especially when the fix has to wait for the next app update.

Over-the-Air and Quick Fixes

In our previous blog, we discussed how using Phrase Strings—our localization tool—enabled us to efficiently introduce Klivvr's Arabic version. Phrase helps us manage content in both English and Arabic seamlessly.

While this made managing content easier, it still didn’t solve the need to create a new release for every content modification. Here comes in the real star: over-the-air (OTA). OTA was a win-win: it allowed me to make quick fixes, and introduce new translations with little to no reliance on developers, which freed them from content-related tasks.

How it Works

To implement OTA, we linked our app project file on Phrase to a distribution where our developers included the SDK into their projects. After this was setup, we simply look up existing keys and change their content or add translations. With every change, a new OTA release is made, that reflects instantly, as opposed to an app release. This saved us time, and allowed us to skip the store’s approval.

Here’s what Mohamed Hisham, our iOS lead had to say:

Before Phrase over-the-air, fixing even a single string error meant a full build release—often over the weekend. My keyboard saw more spilled spaghetti than I'd care to admit. But implementing Phrase was a breeze; all I had to do was include the SDK in my project, and we were good to go. Now, we fix those pesky typos without a new release, and my keyboard stays clean. It's a win-win! Plus, our localization process is faster and more efficient than ever, making our whole team happy.

Creating a release allows us to filter our changes by tags, and specify the app versions using these changes apply to.

Real-World Example: Improving Error Messages

Following up on the pickle we found ourselves into at the start of the article, in one of our older screens our users received a generic error message when they were not connected to the internet. The message read:

Heading: "Something went wrong"
Description: "We could not process your request. Try again later."

This message was confusing and did not help users understand the actual issue. Using OTA updates, we quickly improved this by changing the values of the existing keys to:

Heading: "No Internet Connection"
Description: "Make sure you're connected to the internet and try again."

This change was implemented instantly without needing a full app update, enhancing user experience and reducing frustration.

Stay Informed & Inspired

The ability to make quick, efficient updates using OTA has transformed our approach to UX writing. By utilizing this technology, we can always ensure that app updates are reserved for design, and technical changes, while also allowing our users to have a smoother, more intuitive experience.

For you, a future intern, an internship means building skills, making connections, and getting a taste of what your future career looks like. And for forward-thinking companies like Klivvr, it’s a chance to meet fresh talents and see new ideas in action. Our interns bring energy and innovation, helping us stay ahead of the curve.

Defining the Process

At Klivvr, we’ve meticulously crafted an internship program focused on growth and learning. It’s not just about doing the work; it’s about becoming an integral part of the team and making a real impact. Hatem Maamoun, our VP of Engineering, posed a pivotal question to our team: "Who wants to contribute to the internship program?" Immediately, Muhammed Youssef, Mohammed El-Sheikh, Moataz Mohammed, Haidy Emad, Kerolles Magdy, Mohammed Sherief, Mohammed El Hinamy, and myself—Ahmed Ramzy—stepped up to the challenge.

He then entrusted us with the task of designing the entire program—from the projects interns would work on, to the screening process, and the management of their daily tasks. Meanwhile, Yacoub Yassin, former Product Manager, took charge of mentoring the product manager intern, and Mai Soliman, our UX Researcher, dedicated herself to guiding the product design interns.

Together, we brainstormed various ideas and agreed on the following approach: We sought talent with a solid grasp of programming basics and strong problem-solving skills, along with foundational knowledge of relevant technologies (iOS, Android, and Backend). The interns would be tasked with working on a project that provides hands-on learning experience within Klivvr.

Each of us would manage the interns for a week, ensuring they receive diverse perspectives and guidance. We also coordinated with other departments to provide valuable learning sessions on topics crucial to our operations. This immersive approach allowed our interns to engage fully, gaining a realistic experience of workplace dynamics.

Meet our 2023 Interns

After filtering numerous CVs, our HR team conducted interviews with 40 candidates across different teams to ensure they met our criteria. We selected eight interns for the engineering team, three for product design, and one for product management. Our internship program underscores Klivvr's commitment to diversity and inclusion.

Meet our talented interns: Eman Mohammed, Dalia Hamada, Nadeen Serag, Mariam Ame, Muhamed Magdy, and John Nabil joined our engineering team. Shaza Omar, Marium Nour, and Muhamed Ashraf enriched our product design team, while Mohammed Adel took on the role of a product manager. Each intern brought a unique perspective, and the excitement to learn and grow professionally.

For the engineering team, Eman, Dalia, Nadeen, Mariam, Muhamed, and Keroless were eager to delve into programming, software development, and system architecture. They aimed to strengthen their technical skills while contributing to innovative projects that push the boundaries of technology.

In the realm of product design, Shaza, Marium, and Muhamed were driven by creativity and user-centric design principles. They aspired to craft intuitive user interfaces and engaging experiences that resonate with Klivvr’s users.

As for Mohammed Adel, our product manager intern, he focused on mastering the art of product lifecycle management, from ideation to delivery. He collaborated across teams, ensuring that our products exceed customer expectations.

Our Interns with our tech team on their last day

The Program

At Klivvr, we are committed to offering interns a transformative experience through our structured internship program. It begins with a thorough orientation and onboarding process designed to familiarize interns with our company culture, values, and operational dynamics. During this period, interns also receive comprehensive training on our systems, tools, and best practices, ensuring they are well-prepared to contribute effectively from day one.

On their first day, we onboarded the interns to the project they would be working on—the Klivvr social app, a platform designed for Klivvr employees to communicate, celebrate, and have fun together. We introduced them to their mentors, who would guide them each week, and provided an overview of the internship program. This included the goals, expectations, and resources available to support their learning and development.

On the second day, the interns began by reviewing their backlogs and familiarizing themselves with Kanban boards. This was crucial for them to understand how tasks are managed and prioritized. They learned how to extract technical details from tasks and effectively plan their work.

A typical day for our interns started with a daily stand-up meeting, where they discussed their progress, planned for the day, and addressed any blockers they encountered. This practice not only kept everyone on the same page but also fostered a collaborative environment.

Following the stand-up, interns would dive into their project work, applying their skills and learning through hands-on experience. Regular mentorship sessions were a key feature of the program. These sessions alternated between technical topics—such as coding practices, system architecture, and debugging techniques—and soft skills, including effective communication, teamwork, and problem-solving.

Mentorship and supervision formed the backbone of our program. Each intern was paired with a mentor who provided guidance and support throughout the internship. Mentors shared valuable industry insights, offered career advice, and helped interns navigate challenges. Regular check-ins and mentoring sessions ensured that interns received continuous feedback, enabling them to learn and grow professionally.

Feedback and evaluation were integral components of our program. Interns received constructive feedback on their work and performance from mentors and project leads. This feedback was instrumental in identifying strengths and areas for improvement, fostering a culture of continuous learning and development. Formal evaluations provided interns with a holistic view of their progress and achievements, recognizing their contributions and preparing them for future career opportunities.

In addition to project work, we arranged off-topic sessions where interns could learn from other departments. The data team, information security team, product team, and HR team each conducted sessions to explain and demonstrate their roles and impact on the company. These sessions were designed to give interns a broader understanding of how different functions contribute to the success of the company.

Our interns attending a session held by the Data Team

To ensure individual attention and address any concerns, we scheduled regular one-on-one meetings. These sessions allowed mentors to provide personalized feedback, discuss any challenges interns were facing, and offer additional support as needed. This personalized approach helped interns feel valued and supported throughout their journey.

The Impact

The internship program at Klivvr has yielded remarkable outcomes for our interns. By the end of the program, our interns gained hands-on experience, enhanced their technical skills, and developed essential soft skills like teamwork, communication, and problem-solving. Additionally, many of our interns secured excellent opportunities at other leading companies in the tech industry, a testament to the solid foundation they built during their time with us.

The impact of our internship program on Klivvr has been significant and multifaceted. Interns brought fresh perspectives and innovative ideas, infusing our projects with new energy and creativity. Moreover, integrating interns into our teams fostered a culture of mentorship and continuous learning among our staff. By engaging with the interns, our employees honed their leadership and teaching skills, creating a more collaborative and dynamic work environment. We are continuously working on enhancing our internship program to provide an even more enriching experience.

Testimony & Advice for Future Interns

Marium's journey at Klivvr was significantly influenced by the mentorship she received. "I was able to understand how important research is, and we don’t just decide this is how we want the product to look like and that’s it. t is a continuous loop where you try, test, get feedback, and improve," she shared. While shadowing one of our designers, Ahmed Badry, she learned the intricacies of the design process and the value of persistent learning.

Adel's path to becoming a full-time product manager at Klivvr began with a specific goal in mind. "There was a big learning curve, and I had the opportunity to build so much during the two-month internship. When I got the opportunity to continue, it was the cherry on top. I believed that my learning journey was not over at Klivvr," Adel recounted. He emphasized the importance of understanding the relationship between the product team and other departments. "Dealing with different stakeholders with their varying positions, and the relation between product and tech, was the most valuable thing I learned at Klivvr," he explained.

Marium and Adel, now full-time employees at Klivvr, have some advice for future interns. "Push yourself and give it your maximum effort. Don’t take it lightly; take it as a real job and push yourself," Marium advises. Adel adds, "Work on real products, don’t overthink the policies, and push yourself to your maximum effort

Well, economists noticed a new spending pattern post-COVID, which is that we are all about having fun now. Statistics show that despite rising prices, people started going crazy for things that were “forbidden” during the months of lockdown, such as concert tickets and flights. This was the case for the majority of people, whether they could actually afford these purchases or not.

Some people call it “revenge spending”, others could argue that it’s a form of FOMO in fear of another lockdown, but what we’re sure of is that a lot of people have ditched saving for the moment.

According to a research done by American software company Intuit in January 2023, 2 in 3 Gen-Zers perceive money as a tool “to support their other interests in life”. So, whether it be the latest Eras Tour or the UEFA, people are prioritizing experiencing new things rather than being financially secure.

It’s like we cling onto the tiniest possible trends just to go all out and be as extra as possible. I mean, Barbenheimer? Spending up to 500 LE for a cinema ticket, a strikingly pink outfit and an overpriced box of popcorn? In this economy?

This could be due to the fact that people no longer see financial security as evitable, and thus have resorted to living life to the fullest instead. This is especially the case due to how COVID-19 have impacted everyone’s social life, which explains why the live entertainment industry is everyone’s number one priority right now when it comes to spending. They’re making up for all the days we spent bored to death stuck at home with nowhere to go!

But whether funflation is just a spending trend or will lead to a tragic financial downfall, it’s interesting to observe how sociology and finances interact in motion!

We know that horrified face all too well, but it doesn’t have to be like that! Here’s how you can financially prepare for the summer season like a pro!

-Plan ahead

Start listing all your expenses for the holiday early in advance, so that nothing comes as a surprise! Writing down all the expected costs will help you stay in control so that you can know exactly what you need for the coming period. This includes checking the possible travel destinations, hotel prices, renting options, and other incurred costs that come with the warmer months.

-Determine your income

It’s an equation that doesn’t stop at analyzing expenses. You need to analyze all sources of revenue so you can measure what will be left off at the end after paying your expenses (your income!). By being realistic with the money that will be available for you, you can more accurately anticipate how your spending can go!

-Track your spending

As your summer getaway comes closer, start being aware of how your bank account is looking. Track how your spending is going so you can check if there is any unnecessary costs you can ditch in order to be good to go. Setting realistic expectations is key to smooth spending!

-Start budgeting

Now that you’ve calculated the available money, start allocating it to each category of the trip's expenses depending on their priority. This ensures that you won’t be surprised by how much you need as it approaches. Oh and please, let's beware of needs vs wants!

-Spend smart

Summer doesn’t have to be a burden on your paycheck! Look for discounts, cashback, and rewards programs to get all you dream of at a discounted price. (Take a look at Klivvr's partners while you're at it!)

-Have fun!

Money comes and goes but these sweet summer memories last forever! As long as you plan and spend cautiously, you can rest assured that summer 2024 will go as smoothly as ever.