Infinite Brain: The AI Knowledge Graph That Killed PARA

Infinite Brain: The AI Knowledge Graph That Killed PARA

I spent three years building a PARA vault. Projects, Areas, Resources, Archives. Six hundred and forty-two markdown files. The graph view looked like a galaxy. I was proud of it the way you're proud of a garden that mostly just grows weeds you've decided to call wildflowers.

Then I ran a single benchmark that ended my relationship with PARA in about ninety seconds.

I asked Claude Opus 4.7 the same question against two versions of the same knowledge: my existing PARA vault, and a restructured version I'd been quietly testing for six weeks. The PARA query consumed 8,847 input tokens to produce a mediocre answer that mixed three unrelated projects into a single confused recommendation. The restructured version answered the same question with 612 tokens — and the answer was sharper, cited the right sources, and surfaced a connection between two notes I'd written eight months apart that I'd completely forgotten existed.

Same knowledge. Same model. 14.5x fewer tokens. Better answer.

That's when I understood what most of the productivity world is going to figure out painfully over the next eighteen months: PARA was designed for humans who browse. It is structurally hostile to AI that retrieves. And the gap between those two use cases is now wide enough to cost you real money every single day you keep feeding mediocre context to a model that could be doing brilliant work.

The system that replaced my PARA vault is what the original creator calls the Infinite Brain — a personalized knowledge graph built on sixteen atomic note types and ten typed edges. It sounds bureaucratic when you describe it on paper. In practice, it's the first knowledge architecture I've used where the AI stops feeling like a tourist and starts feeling like it actually lives in my notes.

I'm going to walk you through exactly what changed, why the math forces the change whether you like it or not, and the precise conversion steps I used to migrate a 642-file PARA vault into an Infinite Brain graph in roughly two weekends. There's a specific moment in this post — somewhere around the typed edges section — where you'll either nod and start planning your conversion, or you'll close the tab. I won't try to convince you. The token numbers do that on their own.

Why PARA Quietly Sabotages Every AI Query You Run

I want to be careful here. Tiago Forte's PARA method is not a bad system. For human note-takers in 2017, it was genuinely revolutionary — a way to organize a mountain of information by actionability rather than by topic, which is a smart move when the bottleneck is your own attention.

But the bottleneck stopped being your attention somewhere around late 2024. The bottleneck became how cleanly an LLM can retrieve, reason over, and synthesize the knowledge you've collected. And once that's the constraint, every PARA design decision starts working against you.

Here's what I mean, concretely.

PARA notes are big. The dominant pattern in BASB-style vaults is a few-thousand-word "project doc" that bundles meeting notes, decisions, links, raw research, and personal commentary into a single file. When an AI agent retrieves that note, it gets the whole bundle. Most of those tokens are noise relative to the question being asked.

PARA links are untyped. When you write [[client-onboarding-v2]] inside a project note, Obsidian creates a link. But the link tells the AI nothing about why the two notes are connected. Is this a dependency? A contradiction? A source citation? A precedent? The model has to read both notes in full to figure that out, which costs tokens and frequently produces the wrong inference.

PARA folders are arbitrary boundaries. A "Project" folder makes sense to your morning self planning a quarter. It makes no sense to an LLM trying to answer "what have I learned about pricing across every client engagement." The model now has to scan four to ten project folders, ingest hundreds of irrelevant notes, and hope the right context floats to the top of its attention window.

I'm not theorizing here. I rebuilt the same query against the same knowledge in two structures and watched the cost difference roll in.

This is the part most PARA defenders miss when they wave their hands and say "but you can use AI on PARA." Yes, you can. You can also use a hammer to install a screw. The interesting question isn't whether it's possible — it's how much you're paying in tokens, latency, and answer quality for the privilege of forcing two incompatible designs together.

GraphRAG benchmarks from the past year make this concrete at scale. Microsoft Research's published results show GraphRAG required between 26% and 97% fewer tokens than alternative RAG approaches for the same query quality, depending on the question type. The harder and more synthesis-heavy the question, the larger the gap. Personal knowledge work is overwhelmingly synthesis-heavy — "what's the through-line across these six clients," "what did I decide about this last spring," "which of my hypotheses has the most evidence behind it." Those are exactly the queries where flat document retrieval bleeds tokens hardest.

The Infinite Brain is essentially what happens when you take the structural insight behind GraphRAG and rebuild it as a personal markdown system you can actually live in. No vector database. No indexing pipeline. Just markdown files, typed links, and an architectural discipline about note granularity that pays for itself the first day you connect an LLM to it.

But before we get into the architecture, you need to see the math. Because the math is what makes the conversion non-optional.

The 9,000 vs 600 Token Math, Worked Out Properly

Let me walk through the exact comparison I ran, because I want you to see where the savings actually come from. This isn't magic. It's the natural consequence of having the right granularity.

I picked a question I genuinely wanted answered: "Across my last twelve client engagements, what's the most common reason discovery scope blows up before kickoff?"

In my old PARA vault, the relevant context was scattered across:

• 12 project folders, each with a 1,200–3,000-word kickoff retrospective
• 4 "Areas" notes about my agency operations
• 1 "Resources" note where I'd dumped a half-finished thinking pass on this exact question last fall
• An indeterminate number of daily notes that referenced these projects

To answer the question, Claude had to either ingest a lot of context broadly (expensive) or do multiple narrow retrievals and stitch them together (also expensive, plus latency). I let the agent do the broad pull because that's what most people do in practice. Total input: 8,847 tokens. The answer was middling — it correctly identified two of the three real patterns and missed the most important one because the relevant evidence was buried in a "Resources" note the retrieval ranked low.

In the Infinite Brain version, the same knowledge had been atomized. Each kickoff retrospective was already broken down into:

• 1 Decision note ("Decided to add 5-day pre-discovery sprint" — 80 lines)
• 1–3 Pattern notes ("Pattern: clients underestimate stakeholder count in B2B" — 120 lines each)
• 1 Hypothesis note ("Hypothesis: scope blowup correlates with marketing-led buyer journeys")
• A few Fact notes (specific quotes from kickoff calls, 30–60 lines each)
• Concept notes that the patterns linked into via Supports and Contradicts edges

When I asked the same question, the agent walked the graph instead of grepping the files. It pulled the Pattern notes first, followed Supports edges to the Hypothesis, traced Derived from edges to the underlying Facts, and assembled a tight context window of exactly the slices it needed. Total input: 612 tokens. The answer surfaced all three real patterns and flagged the hypothesis as having the strongest evidence trail, which is genuinely what I'd concluded after a year of running these projects.

At Claude Opus 4.7's published rate of $5 per million input tokens, the cost difference per query is roughly $0.044 vs $0.003. That's a 14.5x reduction on a single query. If you're running an AI agent against your knowledge base ten times a day, every day, the annual difference is meaningful but not life-changing — call it $150 a year. That's not the headline.

The headline is what the lower token cost lets you do that you couldn't do before. When a query against your knowledge graph costs less than a third of a cent, you stop rationing. You start running broad ambient queries — "what should I be thinking about this week," "what unresolved questions have been sitting in my graph longest," "what hypotheses have I generated that I never followed up on" — that would feel wasteful at PARA token costs. The cheap, fast retrieval changes the kind of thinking you do with your second brain. That's the part the spreadsheet doesn't capture.

Alright. The math sells itself. Now let me show you the architecture that produces it.

The Sixteen Atomic Note Types, And Why Each One Earns Its Place

The Infinite Brain has sixteen atomic note types. The first time I read the list, I rolled my eyes — felt like over-engineering for the sake of a framework. I was wrong. Every type exists because it answers a question PARA can't answer: what kind of thing is this note, and how should the AI treat it.

Here's the full list with a real example from my own vault for each.

1. Pillars. Long-term north stars. The handful of things you're trying to be true about your life or work over years. I have eight of these. One example: "Build leveraged income that doesn't require my hourly attention by 2027." Pillars are referenced by almost everything else and almost never edited.

2. Decisions. Specific choices made at specific times with explicit reasoning. "On 2026-03-14, decided to drop the WordPress side of the agency and refer that work to a partner. Reason: gross margin was 23% vs 61% on Laravel work." Decisions are the most valuable note type for AI retrieval because they compress entire deliberation arcs into queryable atoms.

3. Concepts. Definitions of things I want consistent meaning for. "Atomic Note" is itself a Concept note. So is "Discovery Sprint," "Buyer Journey," "Token Budget." Concepts give the AI a stable vocabulary instead of forcing it to infer your terminology fresh every time.

4. Questions. Things I want answered, recorded as standalone notes with their own identity. "Why do design system rollouts stall at the 60% adoption mark?" Questions live as nodes in the graph so I can attach evidence to them as it accumulates, rather than re-asking the same question every six months.

5. Playbooks. Repeatable procedures with steps. "Client Kickoff Playbook." "Vault Migration Playbook." Different from a Decision (which is a one-time choice) and different from a Concept (which is a definition). A Playbook is a sequence I'll execute again.

6. Tasks. Atomic units of work. Most people put these in a task manager, not a knowledge graph. I keep them in the graph for the ones that link meaningfully to other knowledge — a task that emerged from a Decision, or one that tests a Hypothesis. The throwaway "buy milk" tasks live elsewhere.

7. Events. Things that happened at a specific time. Meetings, conferences, launches. The kickoff retrospectives I mentioned earlier are Events. They're the natural attachment point for Facts that came out of the event and Decisions that resulted from it.

8. Patterns. Recurring observations across multiple Events or Facts. "Pattern: every time I quote a fixed price on a discovery sprint, scope creep adds 30%+ to delivery time." Patterns are where wisdom lives. They're also the type of note that's almost impossible to retrieve cleanly from a PARA vault, because the pattern emerges from many distinct documents that have nothing structurally signaling their connection.

9. Hypotheses. Beliefs you hold but haven't confirmed. "Hypothesis: marketing-led B2B buyers underestimate stakeholder count by 2-3x." Tagged with edges that point to supporting Facts and contradicting evidence as it accumulates. Hypotheses are how you make your beliefs falsifiable instead of just floating in your head.

10. Facts. Specific verified claims with sources. A direct quote from a client interview. A benchmark number from a published paper. A revenue figure from your books. Facts are the primary "evidence" type — most other note types ultimately point back to Facts.

11. Sources. External documents — articles, papers, books, podcasts. The metadata for the source plus a few sentences about what it contributes. Distinct from a Bookmark (which is just a URL you might want later) and from a Note (which is your own writing).

12. Bookmarks. URLs you might want to read but haven't yet. A staging area, basically. Without a Bookmark type, every interesting link you save pollutes your graph with un-synthesized noise.

13. Notes. Your own raw writing — thoughts, drafts, half-formed ideas. Not yet structured enough to be a Concept or a Hypothesis. Notes are where ideas start; they get promoted to other types as they crystallize.

14. Contacts. People. Linked to via Authored by edges on Sources and Tagged as edges on Events.

15. References. Pointers to external resources you'll re-use — a snippet, a config file, a code template, a prompt library. The "reusable artifact" type.

16. Custom types. The escape hatch for things your domain needs. I added a "Pricing Experiment" type for my agency work and a "Prompt Pattern" type for my AI engineering work. Use this sparingly — every custom type you add is a new thing you have to maintain conceptually.

The discipline that makes this work is the atomic note rule: every note is between 50 and 300 lines. Not words — lines. That floor and ceiling matter. Below 50 lines, you usually don't have enough substance to be worth retrieving. Above 300 lines, you're bundling multiple ideas into a single retrieval unit, which is exactly the PARA failure mode you're trying to escape.

The first time I sat down to atomize a 4,200-word project retrospective into the right chunks, it took me forty minutes and felt absurd. The fifth time, it took eight minutes and felt obvious. The skill is real and it transfers fast.

But the note types alone aren't what makes the AI sing. The edges do. And the edges are where most knowledge graph systems fail, because they treat all links as equivalent.

Typed Edges: The Part That Makes the AI Actually Reason

Obsidian links are untyped by default. When you write [[B2B Stakeholder Patterns]], Obsidian records that two notes are linked. It does not record why.

That ambiguity costs you tokens every single retrieval, because the LLM has to read both notes in full to figure out what kind of relationship it's looking at. Multiply that across a thousand-note vault and the inefficiency compounds into the kind of token bloat that turned my PARA query into 8,847 tokens of mush.

Typed edges fix this. Every link in an Infinite Brain note is annotated with one of ten relationship types, and the annotation lives inline in the markdown so any LLM agent can parse it without special tooling.

Here are the ten edge types with the inline syntax I use:

• Supports — [[fact-stakeholder-count]] supports [[hypothesis-b2b-stakeholders]]
• Contradicts — [[fact-march-2026-pricing-test]] contradicts [[hypothesis-fixed-price-discovery]]
• Depends on — [[task-rebuild-discovery-deck]] depends on [[decision-drop-wordpress]]
• Derived from — [[pattern-scope-creep]] derived from [[event-march-kickoff]] [[event-april-kickoff]] [[event-may-kickoff]]
• Related to — [[concept-discovery-sprint]] related to [[playbook-client-kickoff]]
• Part of — [[task-update-pricing-page]] part of [[decision-drop-wordpress]]
• Preceded by — [[event-april-kickoff]] preceded by [[event-march-kickoff]]
• Followed by — [[decision-drop-wordpress]] followed by [[task-rewrite-services-page]]
• Authored by — [[source-cagan-empowered]] authored by [[contact-marty-cagan]]
• Tagged as — [[event-may-kickoff]] tagged as [[concept-fixed-price]] [[concept-b2b-saas]]

The inline syntax matters. You don't need a graph database, a plugin, or any special infrastructure. Plain markdown. The LLM reads "supports" or "contradicts" or "derived from" as part of the prose around the link, and it can navigate the graph by following whatever edge type is relevant to the question being asked.

Here's a real example from my vault. This is an actual Pattern note, lightly redacted:

# Pattern: B2B Discovery Stakeholder Underestimation

## Observation
On every B2B SaaS engagement we've run since Q3 2025, the
client's initial stakeholder list captures 30-45% of the
people who actually need to weigh in on scope decisions
before kickoff.

## Evidence
- [[fact-march-kickoff-stakeholder-count]] supports
- [[fact-april-kickoff-stakeholder-count]] supports
- [[fact-may-kickoff-stakeholder-count]] supports
- [[fact-june-pmo-pushback]] supports
- [[fact-october-finance-veto]] supports

## Counter-evidence
- [[fact-feb-clean-kickoff]] contradicts
  (note: this client had run our discovery process before)

## Derived from
[[event-march-kickoff]] [[event-april-kickoff]]
[[event-may-kickoff]] [[event-june-pmo-meeting]]
[[event-october-finance-call]]

## Supports
[[hypothesis-stakeholder-mapping-pre-discovery]]

## Related concepts
[[concept-discovery-sprint]] [[concept-buyer-journey]]
[[concept-stakeholder-map]]

## Notes
The cleanest predictor I've found: if procurement and
finance aren't named on the initial intro call, expect
30%+ scope churn before SOW signature. This pattern
shows up in marketing-led buyer journeys far more than
product-led ones.

That's 152 lines in the actual file. It's a complete atomic unit of synthesized knowledge. An AI agent can pull this single note and have the entire pattern, the evidence, the counter-evidence, and the connections to surrounding ideas. 152 lines, maybe 600 tokens. Compare to dragging in five full project retrospectives totaling 12,000 words to give the model the same understanding.

The Pattern note above wasn't written from scratch. It was promoted from a buried paragraph in an old "Q4 2025 retrospective" note that I would never have queried in PARA because the file was a 4,800-word kitchen sink. Atomization is what made this knowledge accessible.

Side note — when I first started writing typed edges by hand, I thought it would be tedious enough to kill the system. It isn't. After about a week, the syntax becomes muscle memory the same way [[wikilinks]] does. And the Claude-based agent I built (more on that below) auto-suggests edge types when I create new links, so the actual cognitive overhead per note is something like five extra seconds. For a 14x token reduction on every future query, that's a deal I'll take all day.

The Conversion: Two Weekends From PARA to Infinite Brain

Let me show you the actual playbook. Not in theory — the exact sequence I used on my own 642-file vault. If you're using Obsidian and you've got a Claude or ChatGPT subscription, you can run this same conversion.

Weekend 1: Foundation and Triage

Step 1 — Set up the new structure (30 minutes).

I created a new top-level folder called _brain/ parallel to my existing PARA folders. Inside it, sixteen subfolders matching the note types: _brain/decisions/, _brain/concepts/, _brain/patterns/, etc. The leading underscore keeps the brain folder pinned to the top of the file tree visually, which matters more than you'd think when you're working in the system daily.

I also created a single _brain/_index.md that lists every note type with a one-sentence description and a count. That index is what the AI agent reads first to orient itself when answering queries.

Step 2 — Kill the Bookmarks landfill first (45 minutes).

I had 387 web clippings sitting in PARA Resources folders, most of them never read. Triaging these into the new system was the highest-leverage cleanup I did. Three buckets:

• Read and synthesized → promote to a Source note with a 60-line summary
• Read but not yet synthesized → leave as a Bookmark note for later
• Never going to read → delete

Honest count: 41 became Sources, 89 became Bookmarks, 257 got deleted. That's two-thirds of my "knowledge" gone in 45 minutes, and my graph quality went up.

Step 3 — Identify your Pillars (20 minutes).

These are easy to recognize once you know what you're looking for. Long-term goals, persistent values, north stars you've been writing about for years. I had eight. Each got its own atomic note in _brain/pillars/, between 80 and 200 lines. These rarely change, but they're the gravity wells the rest of the graph orbits.

Step 4 — Run a "Decision Mining" pass (3 hours).

This is the most valuable conversion task and the one most people skip. I went through my last twelve months of project notes, daily notes, and retrospectives and extracted every explicit decision into its own Decision note. Format:

# Decision: [Specific choice in one sentence]

## Date
2026-03-14

## Context
[What was the situation that forced this choice]

## Options considered
- Option A: ...
- Option B: ...
- Option C: ...

## Choice
Option B.

## Reasoning
[Why this option won. Be specific about trade-offs.]

## Tagged as
[[concept-x]] [[concept-y]]

## Followed by
[[task-z]] [[event-w]]

I extracted 73 Decision notes from the past year. Each one is now independently retrievable. When Claude needs to answer "why did I make that pricing change last spring," it pulls the relevant Decision note — 100 lines, maybe 400 tokens — instead of grepping through my entire Areas/Business folder.

Weekend 2: Atomization and Edge Wiring

Step 5 — Atomize project retrospectives (4-5 hours).

This is the hardest step and the one that separates a real Infinite Brain from a half-converted PARA vault. Each old project retrospective gets pulled apart into its component atomic notes:

• The events that happened → Event notes
• The decisions that were made → Decision notes (already done in Step 4 if applicable)
• The patterns that emerged → Pattern notes
• The hypotheses you formed → Hypothesis notes
• The specific facts and quotes → Fact notes
• The concepts you defined → Concept notes

I had a working rule: if I touched a retrospective and didn't extract at least three atomic notes from it, I wasn't reading carefully enough. The lowest-yield retrospective produced three notes; the highest produced eleven.

Step 6 — Wire up typed edges (2-3 hours).

This is where Claude becomes a force multiplier. I built a small Claude prompt that takes one of my new atomic notes as input and suggests typed edges to other notes in the graph. The prompt looks like this:

You are wiring edges in an Infinite Brain knowledge graph.

Here is a new note: [paste note content]

Here is the index of existing notes by type: [paste _index.md]

For each potential connection, suggest:
- The target note
- The edge type (Supports / Contradicts / Depends on /
  Derived from / Related to / Part of / Preceded by /
  Followed by / Authored by / Tagged as)
- A one-sentence justification

Only suggest edges where the relationship is clear and
specific. Skip vague "related to" links unless there's
no better edge type.

I run this against each new atomic note. Claude proposes 4-12 edges. I accept maybe 60-70% of them — the model is right more often than wrong, but it occasionally over-connects. The acceptance is one keystroke per edge in my Obsidian setup.

Step 7 — Build the cleanup pass (1 hour).

Last step: run a query against the graph asking the agent to identify Pillars, Concepts, or Hypotheses that have zero incoming edges from other notes. These are the orphans. Either the orphan is genuinely disconnected (and you should ask whether it earns its place) or you've missed wiring it up.

I had 23 orphans after the first edge-wiring pass. After the cleanup, I had 4 — and three of those four turned out to be Concepts I'd defined but never actually used, which I deleted.

Total weekend-clock time: roughly 18 hours over two weekends. That's the real cost. The reward is that every AI query I run for the rest of the time I use this vault is structurally cheaper, faster, and sharper than the equivalent PARA query.

If you're a heavy AI-knowledge-base user — and if you're reading this far, you almost certainly are — that math pays off in weeks, not months.

What I Got Wrong, And What's Genuinely Hard About This

I want to be honest about the things this approach doesn't solve, because I read too many "I changed my system and it changed my life" posts that gloss over the trade-offs.

The atomization tax is real. Writing a 4,000-word brain dump and dropping it in a project folder takes ten minutes. Writing the same content as 8-12 atomic notes with proper edge wiring takes 25-40 minutes the first few times. After a couple of months it gets faster — call it 50% slower than the brain-dump approach, not 4x slower — but it's never going to be free. You're paying upfront in capture friction to save downfront in retrieval cost. If you're someone who only queries your notes occasionally, that math may not work for you. For me, running 30+ AI queries a day against my vault, it's not close.

The atomic note rule is harder than it sounds. "Between 50 and 300 lines" feels like a soft guideline until you're staring at a 700-line note that genuinely doesn't decompose cleanly. The skill of seeing where a note should split is something I'm still developing six months in. The pattern I've found that helps: if I'm writing a section heading inside a note, that section probably deserves to be its own note with an appropriate edge.

Edge sprawl is a real failure mode. Early in my conversion I went edge-crazy and wired up every plausible connection. The graph became too dense to be useful — every note connected to forty others, and the AI couldn't tell which connections were load-bearing. The fix was a discipline I now apply ruthlessly: every edge has to be one a future-me would actually traverse. If the connection is interesting but I'd never follow it to answer a real question, it's not earning its place.

The system rewards specific kinds of work more than others. If your knowledge work is heavily synthesis-driven — research, strategy, consulting, writing — the Infinite Brain pays back enormously. If your work is heavily execution-driven and your "notes" are mostly lightweight task tracking, the overhead is harder to justify. PARA was designed for the second use case. Don't replace your task manager with this; that's not what it's for.

There is no community plugin yet that makes this trivial. I built my own Obsidian template snippets and Claude prompts. The original creator's community offers conversion prompts and templates, and they're solid starting points, but you should expect to build some custom tooling for your specific workflow. This isn't a download-an-app system yet. It might be in a year.

The good news is that none of these trade-offs change the underlying math. The 14x token reduction is real. The retrieval quality improvement is real. The "AI feels like it actually lives in my notes" experience is real. What you trade for those gains is upfront discipline in how you write, and that discipline gets cheaper over time as the muscle develops.

Where the Token Savings Actually Show Up

I want to close with something concrete, because the abstract "fewer tokens" framing doesn't quite capture what changes day-to-day.

Three months into running my Infinite Brain, here's what I now do that I literally couldn't have afforded in my PARA vault:

Morning ambient queries. Every morning I run a Claude command that asks: "Looking at my graph as of today, what's the most important unresolved Hypothesis I have, and what would it take to confirm or kill it?" That query costs me about 1,800 tokens of input — under a cent. In PARA, the same question would have required 25,000+ tokens of context to answer well. I would never have run it.

Cross-domain pattern hunts. Once a week I run: "Look at every Pattern note tagged with both concept-pricing and concept-b2b. What's the strongest connection across them, and what's the biggest contradiction?" These are the questions that make a knowledge base feel alive. They're also the questions that became affordable when typed edges replaced flat retrieval.

Decision archaeology. "Find every Decision I made in the past 12 months tagged with concept-agency-pricing. Order by date. Tell me which ones I've reversed and which still stand." This query took 480 tokens and 4 seconds. It surfaced a pattern in my own pricing strategy that I'd been making the same mistake about for nine months.

The math behind the Infinite Brain is what convinces engineers. The day-to-day experience of having a knowledge base your AI can actually reason over — cheaply, quickly, accurately — is what convinces everybody else.

Three years from now, I think we'll look back at PARA-style flat-folder note systems the way we look back at organizing files by department in a 1990s shared drive. Functional, eventually painful, replaced by something that fits the actual constraints of modern work. The constraints have changed. The architectures have to change with them.

If you want to know whether this is worth your two weekends: open your current vault, pick the most synthesis-heavy question you've asked an AI about your own knowledge in the last month, and count the tokens it took to get a decent answer. If that number embarrasses you, you already have your answer.

Mine embarrassed me. I'm not going back.

Let's Work Together

Looking to build AI systems, automate workflows, or scale your tech infrastructure? I'd love to help.

• Fiverr (custom builds & integrations): fiverr.com/s/EgxYmWD
• Portfolio: mejba.me
• Ramlit Limited (enterprise solutions): ramlit.com
• ColorPark (design & branding): colorpark.io
• xCyberSecurity (security services): xcybersecurity.io