Obsidian turns your private notes into a thinking machine

Obsidian’s best trick is almost embarrassingly simple: it treats your private notes as a small web that belongs to you. Not a feed, not a dashboard, not a cloud workspace asking you to behave like a team of one. A folder of Markdown files on your device, opened by an app that lets those files point to each other, gather metadata, appear on visual boards, sync across devices, publish to the web, or stay entirely offline. That quiet premise is why Obsidian feels less like another productivity app and more like a piece of internet infrastructure smuggled into a notebook. Its own homepage calls it “the free and flexible app for your private thoughts,” and the product keeps returning to that same promise: your thoughts are stored privately on your device, and even Obsidian says it cannot read them.

The oddity is that Obsidian is most interesting before it does anything flashy. Open it, create a vault, write one note, and the whole thing might seem plain, almost underdesigned if your taste has been trained by polished SaaS screens. The surprise arrives later, when one note links to another, a daily note accumulates tiny observations, a travel plan grows tasks and recommendations, a quote from a book points toward an old journal entry, and a rough map of your thinking starts to emerge without asking permission. The app’s core metaphor is not a filing cabinet. It is a private hyperlink system, and that makes it feel closer to the early web than to a conventional note-taker.

The material you shared from Obsidian’s own front page is a good entrance into the product because it understands writing as transmission. The “Writing is telepathy” passage, drawn from Stephen King’s famous explanation in On Writing, is doing more than decorating a landing page. It is setting up a claim about notes: that thoughts do not only live in the moment when they are written. They wait. They cross years. They arrive later in the mind of the same person, or another person, with enough shape to be useful again. Obsidian is built for that kind of delayed contact. A note written at a desk in January might return on a train in October, linked to a project, a person, a book, a half-forgotten question, or a diagram you made when the idea still felt alive.

Plenty of apps promise to hold your thoughts, but Obsidian is unusual because it does not make itself the permanent owner of the container. The files are ordinary Markdown. The vault is a folder. The links are readable. The app can become complex, even eccentric, but the raw material remains legible outside the app. That is not just a technical footnote; it changes the emotional contract. You are not “putting things into Obsidian” in the way you put photos into a service and hope it stays friendly. You are keeping a folder of writing, and Obsidian is the powerful reader, editor, map, and workshop built around it. The company’s About page says its principles include simple, open file formats, local storage, privacy, customization, and being user-supported rather than investor-backed.

This is why Obsidian is worth opening even if you already have a notes app. It has a point of view about ownership, memory, and the shape of thought. Apple Notes is pleasant. Notion is collaborative and tidy. Google Docs is everywhere. Roam made backlinks famous for a certain kind of networked thinking. Obsidian sits in a stranger, more durable pocket: a personal knowledge base that can be as sparse as a notebook or as intricate as a private operating system. It does not demand that you build a “second brain.” It quietly gives you enough material to grow one by accident.

A notebook that behaves like a private web

The first thing to understand about Obsidian is that a vault is not a mystical productivity structure. It is a folder. Inside it are notes, attachments, images, PDFs, canvases, and other files, depending on how you use it. This sounds boring until you realize how much software has spent the past decade hiding files from users. Obsidian reverses that habit. It gives files back their dignity. You can open the folder, back it up, sync it with another tool, edit the Markdown elsewhere, or leave it alone for years. The app adds intelligence and interface, but the work remains yours.

That local-first foundation gives Obsidian a slightly different feeling from web-first tools. You are not entering somebody else’s workspace every time you open it. There is no loading spinner standing between you and a sentence you wrote last night. You can use it offline, which matters less as a technical feature than as a psychological one. A private note app should not feel like a subscription portal. It should feel like a room. Obsidian gets close to that. The Sync page says the app works offline and syncs later when you come back online, and it lists support across Mac, Windows, Linux, iOS, Android, and even headless use on a server.

The second thing is that links are not decoration in Obsidian. They are the spine. You can type a wiki-style link to another note, and the app treats that link as a real relationship. This lets you build something that feels less like folders and more like a personal Wikipedia. A note about Kyoto can point to a note about ryokans, which can point to a note about Japanese breakfast, which can point to a book you read, which can point to a packing list, which can point to a friend who gave a recommendation. None of that needs to be planned in advance. The web grows where your attention goes.

This is the hidden pleasure of the app: you can write first and organize second. Many productivity systems front-load structure. They ask for databases, templates, properties, tags, statuses, projects, priorities, colors, views, and naming conventions before you have written the thing that matters. Obsidian works nicely with structure, but it does not require it at the door. A messy note can exist as a messy note. A clean note can exist as a clean note. A note can link outward before you know what category it belongs to. That matters because thinking often arrives before taxonomy. If the app makes you name the drawer too early, the thought gets smaller.

Backlinks make this even more interesting. Obsidian can show which notes point to the note you are reading, so the page does not sit alone. A person note becomes a record of where that person appears in projects, meetings, quotes, trips, ideas, and decisions. A theme like “attention” becomes less of a folder and more of a gathering place. This is one reason Obsidian became beloved by writers, researchers, students, developers, designers, founders, and people who read too many PDFs at midnight. It rewards recurrence. It notices when a thought keeps coming back.

There is a small but real shift here: the note stops being a storage unit and becomes a node. The word “node” can sound like graph-brained theater, but in daily use it is practical. A quote is no longer trapped in the book note where you first pasted it. A meeting decision can connect to the product idea it affects. A recipe can connect to a shopping list, a family story, a health note, or a seasonal plan. The relationship becomes searchable, visible, and revisitable. A private archive becomes less stale when it has edges.

Obsidian’s Graph view is the most visible version of this idea, although it is also easy to overrate. The graph is beautiful, but the links matter more than the picture. A glowing constellation of notes looks impressive in screenshots, and it can reveal clusters you did not expect. Still, the graph is not the reason to use Obsidian. The reason is that clicking through the links changes how old writing returns to you. A graph is a weather map of your vault. The real weather is inside the notes.

The homepage leans into that idea with examples around projects, travel, philosophy notes, Canvas boards, plugins, Sync, and Publish. The product is presented as a thinking environment, not a prettier scratchpad. Its examples include a Japan trip plan, a “Writing is telepathy” note, a Descartes passage, links between ideas, visual relationships, and shared vaults. That selection is revealing. Obsidian is not saying, “Use us for grocery lists.” It is saying, “Use us for thoughts that might keep changing shape.”

This makes the app especially strong for subjects that refuse to stay in one folder. Research, writing, travel, product planning, reading, study, therapy notes, worldbuilding, code notes, personal history, and client knowledge all benefit from sideways movement. A folder tree says one thing belongs in one place. Obsidian says the same thought can touch many places without being duplicated. That is closer to how memory behaves. We do not remember in folders. We remember through cues.

The “private web” feeling also gives Obsidian a cultural charge. It belongs to the part of the internet that still believes tools should be hackable, personal, and somewhat weird. Its community makes plugins, themes, workflows, templates, dashboards, and vault tours. Some users keep it minimal. Others turn it into a life-management cockpit so elaborate it starts to resemble a personal ERP. The app tolerates both. That tolerance is rare. Many tools punish you for refusing their intended workflow. Obsidian gives you enough rope to build a bridge, a hammock, or a trap for yourself.

That last part matters because Obsidian is not magically disciplined software. It can become a procrastination machine if you use it to build systems instead of writing notes. It can feed the urge to perfect categories, tune themes, install plugins, and rename folders while the actual thinking waits in the hallway. The app does not save you from yourself. It gives you a workshop. Whether you make furniture or spend the whole day rearranging clamps is your problem.

Still, the workshop quality is the point. Obsidian respects the user enough to be slightly dangerous. It does not sand off every edge. It lets you see files, edit syntax, install community code, bend visuals, and publish a knowledge base. It assumes some people want that. Not everyone does. Good. The web needs tools that are not built for the lowest-friction onboarding funnel. Obsidian is for people who feel relief, not fear, when an app says, “Here are your files.”

What stands out at a glance

The table is small because Obsidian’s appeal is not one feature but the way the parts compound. Local files make ownership feel real. Links make memory less brittle. Canvas gives messy ideas a surface. Plugins let the app become many things without forcing every user into the same mold. Sync and Publish turn the vault outward only when you choose.

The tiny file choice that changes everything

The most radical thing in Obsidian is not the graph, the plugin ecosystem, or the dramatic promise of a “second brain.” It is the decision to build around plain text Markdown files. That choice sounds modest until you compare it with the usual app bargain. Many tools make your work beautiful inside the tool and awkward outside it. Export exists, but export is often a farewell ritual, not daily freedom. Obsidian’s notes are already outside in a sense. The app is reading and improving a folder you own.

Markdown is not perfect, but it is good enough in exactly the right way. It can hold headings, links, lists, code blocks, quotes, checkboxes, images, and frontmatter without becoming heavy. It is readable as raw text. It works in many editors. It ages well. A Markdown file does not care whether venture capital cools, a product manager changes strategy, or an API gets sunset. A folder of Markdown notes is boring in the way a printed book is boring: it survives fashion by not needing much.

This matters because notes are not like chat messages or receipts. A serious note archive may outlive several computers, jobs, relationships, cities, and versions of yourself. The app you like today may not exist in ten years. Your taste may change. Your operating system may change. Your work may move from a laptop to a tablet to a machine we have not normalized yet. Obsidian’s open-file logic makes those changes less terrifying. The company’s About page explicitly ties its durability principle to simple, open file formats that prevent lock-in and preserve data over time.

The local-file model also changes privacy from a slogan into a default posture. A note does not need to be uploaded just to exist. You can keep a private journal, a research folder, a sensitive career plan, or a medical question inside a vault on your own machine. That does not remove every security concern; your device security and backup habits still matter. Yet the baseline is different from a web app whose first move is to send every keystroke to a server. Obsidian’s pricing page says the apps can be used without sharing personal information, store data locally, do not collect telemetry, and do not sell user data.

This is one reason Obsidian has a special place among people who are tired of being turned into usage metrics. It offers a kind of software quietness that now feels almost defiant. You can write a note without being nudged toward collaboration, templates, AI summaries, or a team upgrade. You can make a vault that has no account, no feed, no public profile, no avatar, no workspace invite, and no measurable “engagement” beyond the fact that you wrote something worth keeping. That is not nostalgia. It is product taste.

The trade-off is that ownership asks for responsibility. Local files are comforting until you lose a laptop without a backup. Markdown is durable, but attachments need care. Plugins are powerful, but community code deserves judgment. Obsidian Sync is convenient, but some users may choose iCloud, Dropbox, Syncthing, Git, or their own backup pattern instead. The freedom is real, and so is the chore of deciding how your archive lives. This is the part many cloud tools hide. Obsidian makes it visible again.

There is a useful distinction here between private and lonely. Obsidian is private by default, but not isolated by design. You can use Sync for devices, Publish for public sites, shared vaults for team work, Web Clipper for capturing pages, and community plugins for many workflows. The point is that these are extensions from a private base, not the base itself. That is a healthier direction for a thinking tool. Start with the individual mind. Add connection only where it earns its place.

The Web Clipper shows this philosophy in miniature. It brings web material into your vault without turning clipping into a proprietary scrapbook. Obsidian describes the Web Clipper as free and open source, says clipped content is stored locally in your vault, and notes that clips are saved to durable Markdown files with highlights and settings exportable to JSON. That is exactly the kind of small product decision that separates a sticky tool from a needy one. A clipped article should become part of your archive, not another hostage in a browser extension’s private format.

The same idea appears in Canvas. Even Obsidian’s visual board has a file story underneath it. The help page describes Canvas as a core plugin for visual note-taking that lets you lay out notes, attachments, and web pages in an infinite space. It also says canvases are saved as .canvas files using the open JSON Canvas format. That detail is easy to miss, but it matters. A visual thinking surface is much less interesting if it becomes an opaque object trapped in one app. Obsidian’s better instinct is to make the surface playful while keeping the underlying object legible.

Bases, a newer piece of the system, carries the same tension between structure and file ownership. It gives you database-like views without turning your notes into database prisoners. The help page says Bases is a core plugin for creating views of notes, sorting and filtering files and properties, with table, list, card, and map views; it also says the data remains in local Markdown files and properties, while views are saved as .base files or embedded in code blocks. That is a very Obsidian compromise: structured enough to plan projects or reading lists, plain enough to keep your escape route.

This is where Obsidian differs sharply from tools that make databases the center of everything. A database-first app asks you to model your world before you have lived enough of it. Obsidian lets databases appear later, as views on top of notes. That is subtler and often better. A book note can begin as a paragraph. Later it can gain properties: author, status, rating, theme, source, year. Later still it can appear in a Base showing books by topic or reading state. The note remains a note. The structure is a lens, not a cage.

The file choice also shapes the kind of community that gathers around the app. People who care about text files tend to care about portability, automation, scripts, backups, editors, and long memory. They build workflows that connect Obsidian to Git, static sites, Readwise, Zotero, task systems, calendars, and command-line habits. Some of that is too nerdy for a casual user, but the culture is part of the product. Obsidian feels alive partly because it attracts people who want to tinker with their own thinking environment rather than rent a finished one.

There is a small design humility in all this. Obsidian does not pretend that the app itself is the final form of your knowledge. It treats the app as an interface over durable material. That is a rare posture. Many software companies want the product to be the world. Obsidian is more like a reading room, a map table, a graph viewer, a writing desk, a plugin host, and a publishing switch built around files that remain stubbornly yours.

That humility may be the most internet-native thing about it. The original web worked because documents could link without asking a central authority to bless every relationship. Obsidian brings that idea inward. It lets private documents link, accumulate context, and form paths through memory. The web became noisy because public linking got captured by ranking systems, feeds, ads, and platform incentives. A private web of notes dodges most of that. It gives hyperlinks back their first magic: one thought touching another because a person saw a connection.

Links, graphs, and the pleasure of finding old thoughts

A good note app has to solve a problem that sounds simple and becomes cruel with time: how do you find the thing you once knew you knew? Search helps when you remember the right word. Folders help when the thing belongs to one place. Tags help when you named the category clearly. But real memory is messier. You remember the friend who mentioned the book, not the title. You remember the trip where the idea came up, not the filename. You remember a feeling, a project, a half-phrase, a related problem. Obsidian’s linking model gives you more trails back.

The pleasure of the app is not only retrieval. It is recognition. You open a note and see backlinks from places you had forgotten. You discover that the idea you thought was new has appeared in three old notes, under different names. You realize that a work problem connects to a paragraph from a novel, a quote from a philosopher, a meeting with a client, and a personal anxiety you have been circling for months. That kind of discovery is hard to design directly. Obsidian creates conditions for it.

This is where the “writing is telepathy” framing earns its keep. A note is a message from one version of you to another. The old version cannot know when the new version will need it. The new version often cannot predict what will become relevant. Links are the nearest thing to a time machine inside a notebook. They preserve not only content but also relation. A note that says “Kyoto” is useful. A note that links Kyoto to “quiet mornings,” “ryokan research,” “Keiko recommendation,” “Japanese gardens,” and “packing mistakes” is a richer signal.

Obsidian’s double-bracket linking feels deliberately lightweight. The syntax is simple enough to use mid-thought. You do not need to open a database relation field or select a canonical object from a modal. You type a link. The note may already exist, or it may not. If it does not, the link becomes an invitation to create it later. This matters because the smallest bit of friction changes writing. A link should not feel like administrative work. In Obsidian, it usually feels like a gesture.

Backlinks make the gesture reciprocal. Once links exist, Obsidian can show you the incoming paths. This is where personal knowledge begins to feel less like a stack and more like a city. Each note has roads in and roads out. Some notes become crowded intersections. Others stay quiet. A note about a person may become unexpectedly central because that person touches projects, trips, books, and decisions. A note about an idea may grow from a sentence into a hub. You learn the shape of your attention by watching what becomes connected.

The Graph view is the app’s most photogenic expression of this. It visualizes relationships between notes as a constellation, which is both useful and slightly theatrical. It can reveal clusters, isolated notes, and overloaded hubs. It can also tempt users into graph vanity, where the vault looks impressive but contains little thinking. The graph is best treated as a mirror, not a scoreboard. If a cluster exists because you have been writing around a real subject, the view can be revealing. If the cluster exists because you spent a weekend manufacturing links, it may only reveal that you like clusters.

A better everyday use of links is quieter. You start a note for a project and link to people, reference material, decisions, meetings, open questions, and related projects. The project note becomes a launchpad. Months later, when somebody asks why a decision was made, you can walk through the trail. Not because you built a perfect knowledge system, but because you wrote enough small notes and made enough small links while the work was happening. Obsidian rewards lightweight habits. It punishes grand systems that never survive Tuesday.

Tags still have a place, but links often carry more meaning than tags. A tag says a note belongs to a category. A link says it touches a specific thing. The difference is subtle until your vault grows. A tag like #travel may gather everything from packing lists to visa notes to restaurants. A link to Kyoto creates a more precise neighborhood. A link to Keiko creates another. A link to ryokan creates another. The same note can belong to all three without being copied or trapped.

Folders still have a place too. Obsidian does not force a pure graph ideology. Some people use folders for broad areas, links for relationships, tags for states, and properties for structured views. Others dump everything into one folder and rely on search. Some use daily notes as the main entry point. Some use PARA, Zettelkasten, Johnny Decimal, Maps of Content, or their own messy pattern. The app’s strength is that it does not require a priesthood. It lets you borrow methods without marrying them.

Daily notes are especially compatible with Obsidian because they respect the way thoughts actually arrive. A day contains meetings, stray quotes, errands, moods, ideas, links, unfinished tasks, and tiny observations that do not yet deserve their own files. Later, some of those fragments can become notes. Others stay as context. A daily note is a landing pad. In a link-friendly app, it also becomes a timeline. You can trace when a thought first appeared, not just where you later filed it.

This is useful for creative work. Writers and editors often need to collect friction before they know the argument. A single article may begin as ten unrelated notes: a quote, a complaint, a screenshot, a product detail, a line from a book, a customer anecdote, a technical fact, a title idea, a metaphor, a counterargument. Obsidian lets those fragments remain separate while still touching. The eventual draft can pull from the web of notes without flattening it too early. The draft becomes one path through a network, not the only version of the material.

It is useful for learning as well. Students and self-learners can link concepts instead of memorizing them as isolated cards. A note on empiricism can point to Hume, sensory perception, scientific method, and a class lecture. A note on rationalism can point to Descartes, innate knowledge, deduction, and a different lecture. The Canvas example on the Obsidian homepage uses philosophers and relationships between rationalists and empiricists, which is a neat demonstration of the app’s sweet spot: not just storing definitions, but placing them in relation.

Researchers get another benefit: citations, excerpts, and interpretations can stay close without collapsing into one blob. A paper note can hold bibliographic details and quotes. A concept note can synthesize across papers. A project note can link to the concept note and the source notes. A question note can hold doubts. The vault becomes a thinking trail rather than a dump of PDFs. Obsidian is not a full reference manager by itself, but it pairs well with tools like Zotero through community workflows. The broader pattern is the same: each piece keeps its identity while links carry context.

For personal life, the value is stranger and more intimate. Obsidian can become a private record of attention. Not a diary in the sentimental sense, though it can be that. More like a memory machine with knobs. You can write about meals, trips, worries, conversations, recurring dreams, money decisions, family stories, health patterns, books, workouts, friendships, and plans. Later, links reveal repetitions you would not have noticed. The app is not therapy, but it is good at preserving evidence of your own mind.

That evidence can be uncomfortable. A connected archive shows what you avoid as well as what you pursue. Empty notes, abandoned projects, repeated anxieties, bloated dashboards, and overbuilt templates all say something. Obsidian’s flexibility makes it easy to perform competence instead of doing the work. A beautiful vault can hide an unwritten book. A perfect tag system can hide a hard decision. The app’s honesty is that it preserves the mess. The user’s honesty is deciding what to do with it.

The real magic appears when the archive starts surprising you. A note you wrote two years ago solves a problem today because a link carries it into view. A half-formed sentence becomes the missing line in a proposal. A trip note becomes a gift idea. A meeting note becomes proof of a decision. A quote becomes the anchor for an essay. These moments are not guaranteed. They emerge from repeated use. Obsidian does not create insight by itself, but it makes insight more likely to find a place to land.

Canvas, plugins, and the strange freedom of an app that bends

Obsidian’s text-note foundation would be enough for many users, but the app becomes more distinctive when it lets notes leave the vertical page. Canvas is the clearest example. It gives you an infinite visual space where notes, media, files, and web pages can sit near each other, connected by lines and groups. This is not a replacement for writing. It is a different posture toward the same material. Some thoughts want a sentence. Some want a table. Some want a map made of messy cards.

Canvas is useful because not every idea is ready to become linear. Research often begins as a scatter of pieces: a PDF, a quote, a screenshot, a question, a person, a timeline, an image, a website, a contradiction. A document forces those pieces into order before the order exists. A canvas lets the order emerge through placement. You can put things beside each other and see what happens. Proximity becomes a thinking tool. The official Canvas page describes it as an infinite space for research, brainstorming, diagramming, and laying out ideas, with support for embedding notes alongside images, PDFs, videos, audio, and interactive web pages.

There is something quietly refreshing about a visual board that is still tied to your notes. The cards are not dead sticky notes floating in a separate product. They can be existing notes from your vault. They can be edited. They can connect back to the rest of your system. This matters because visual thinking tools often become beautiful graveyards. You make a board, enjoy the arrangement, and then the board decays outside your real archive. Obsidian Canvas has a better chance of staying alive because it lives inside the same vault.

The open .canvas format adds another layer of trust. A visual layout becomes a file, not just an app state. That does not mean every user will hand-edit JSON Canvas files, and most should not need to. It means the structure is not hidden behind a service’s private object model. Developers and plugins can understand it. The app can build on it. The user can back it up. This is the same Obsidian instinct again: make the playful feature rest on something durable.

Canvas works especially well for planning, because plans are rarely linear at first. A Japan trip might include flights, ryokans in Kyoto, people to ask, neighborhoods, weather, restaurants, packing notes, train passes, budget, and open questions. A writing project might include thesis fragments, source notes, counterarguments, title options, quotes, and deleted paragraphs worth saving. A product idea might include user problems, sketches, competitor notes, support tickets, pricing doubts, and technical constraints. In a document, these pieces fight for sequence. On a canvas, they can coexist while the sequence forms.

The danger is that Canvas can become another place to decorate uncertainty. Moving cards around feels productive. So does color-coding groups, drawing lines, and arranging media. Sometimes that motion clarifies the problem. Sometimes it delays the sentence, decision, or call you are avoiding. Obsidian’s best features share this risk because they are expressive. The app gives you surfaces, not discipline. A smart user learns when to map and when to write.

Plugins expand the same freedom in a more technical direction. Obsidian’s plugin ecosystem is one of the reasons the app feels larger than its small-team origin. The official homepage points to thousands of plugins and themes, and the community plugin directory includes everything from calendar views and kanban boards to task tracking, recent files, translators, hidden-file controls, diagram tools, and far more than any single user should install. The plugin universe can make Obsidian feel like a notebook, an IDE, a reading system, a task manager, a dashboard, a fiction bible, a personal CRM, or a local knowledge base with knobs.

The best plugins do not merely add features. They let different kinds of thinkers keep their preferred shape. A researcher may want citation tools, PDF workflows, and literature notes. A manager may want tasks, project dashboards, and meeting templates. A writer may want longform drafting, word counts, backlinks, and distraction-free themes. A developer may want code snippets, diagrams, Git integration, and local automation. A student may want spaced repetition, lecture notes, and flashcards. The app does not need to predict every workflow because the plugin ecosystem lets workflows breed.

This is also where Obsidian becomes intimidating. A new user can mistake the plugin directory for a requirements list. It is not. Installing twenty plugins in the first week is a classic path to confusion. The better move is to write notes until a friction repeats. Then look for a plugin that removes that friction. Need recurring tasks? Add a task plugin. Need calendar navigation? Add a calendar. Need database-like views? Try Bases or another approach. Need a better capture flow from the browser? Use Web Clipper. The vault should pull plugins toward it, not the other way around.

Themes have a similar role. They make the app feel personally inhabitable. That may sound cosmetic, but writing tools are intimate. People spend hours inside them. Font size, line width, contrast, spacing, tabs, sidebars, and color all affect whether the room feels usable. Obsidian’s theme culture acknowledges that one person’s calm interface is another person’s headache. A tool for private thought should not force a single aesthetic mood on everyone.

The open API deepens this because Obsidian is not only customizable at the surface. Developers can build real extensions. The homepage points to developer docs and an open API for plugins and themes, while Canvas documentation notes that plugins can add capabilities to Canvas. This does not matter to every user directly, but it changes the product’s future. When a community can build around a tool, the tool grows sideways. Use cases appear that the original team would not have prioritized, and niche needs stop being dead ends.

Bases deserves special attention here because it may pull database-curious users closer without sacrificing the Markdown core. It turns a vault into something that can be sorted, filtered, and viewed through structured properties. A folder of project notes can become a table. A book list can become cards. Travel ideas can become a map. Files can be grouped and searched by fields. Since the underlying data remains in local Markdown properties, the structure feels additive rather than possessive. For users who wanted some of Notion’s view logic without moving their entire mind into a cloud database, this is a serious development.

The syntax behind Bases shows how nerdy Obsidian is willing to be. Base files use YAML, filters, formulas, properties, summaries, and view definitions. The app interface handles typical use, but the syntax can be edited manually and embedded in code blocks. That duality is part of the product’s charm. You can ignore the syntax and click around. Or you can open the hood. Obsidian rarely insists on one level of abstraction.

This bendability creates a product that is hard to review in the usual way. Obsidian is not one app experience. It is a spectrum. A minimalist vault with plain notes and a few links is a different creature from a plugin-heavy vault with dashboards, databases, Canvas maps, clipped web research, and published pages. Both are Obsidian. This makes the app difficult to explain in a neat sentence and easy to become attached to once it has grown around your habits.

The downside is that Obsidian can feel unfinished to people who expect the app to tell them how to work. It will not automatically produce a perfect productivity system. It will not stop you from making five competing templates. It will not keep your vault clean unless you develop a cleaning habit. It will not decide whether a note belongs in Projects, Areas, Resources, Archives, Daily, Fleeting, Literature, Permanent, or a folder named “stuff.” This is the price of an app that bends. You get agency, and agency includes the possibility of making a mess.

That mess is not always bad. A living vault should have compost. Old notes, fragments, dead projects, duplicates, and half-formed ideas are not signs of failure if they are searchable and occasionally useful. The mistake is trying to make every note canonical. The web is useful partly because it is uneven. A personal web can be uneven too. Obsidian’s great gift is not perfect order. It is recoverable disorder.

The best way to use the app may be to keep the core boring and let the edges get interesting. Write Markdown notes, link generously, use a few folders, add properties only when they earn their keep, install plugins slowly, and use Canvas when the page feels too narrow. That is not a universal method, just a sane pressure valve. Obsidian rewards patience. The app becomes stranger and more personal as your archive grows, but it grows best from actual notes, not from imaginary systems.

Sync, Publish, and the price of staying independent

Obsidian’s free core would be less convincing if the business model quietly contradicted the product philosophy. Its paid services are optional extensions rather than the entrance fee to your own thoughts. The pricing page says the app is free without limits, with no sign-up required, while optional add-ons handle syncing and publishing. Sync is listed at $4 per user per month billed annually or $5 monthly, and Publish at $8 per site per month billed annually or $10 monthly. Those prices may change in the future, but the shape of the model matters more than the numbers: the base app remains usable without an account.

That is a sharp contrast with the dominant SaaS instinct. Many apps make storage, identity, collaboration, and billing feel inseparable. Obsidian separates them. You can use the local app for free. You can pay for Sync if you want first-party device syncing. You can pay for Publish if you want a public site. You can buy Catalyst or Commercial licenses to support development. You can also choose other backup or sync systems if you know what you are doing. This choice fits the product’s values better than a forced subscription would.

Sync is the paid feature most private-note users will care about. It solves the practical problem of wanting the same vault on multiple devices without turning the vault into a readable cloud document. The Sync page describes end-to-end encryption with AES-256, version history, offline work with later syncing, selective sync for files and preferences, file recovery, and shared vaults for collaboration. For a tool that invites years of personal writing, Sync’s version history and recovery features are not nice extras. They are insurance against ordinary human mistakes.

The privacy claims around Sync matter because a local-first app loses credibility if its cloud service becomes a privacy trap. Obsidian’s own materials say Sync uses end-to-end encryption by default, and recent official posts discuss security audits and encryption upgrades. The company announced audits by Cure53 and Trail of Bits, noting that remediations were implemented and validated, and also explained that “managed encryption” was renamed to “standard encryption” after audit feedback because the risks of not choosing default end-to-end encryption needed clearer wording. The August 2025 changelog also says file names were already end-to-end encrypted and received a stronger method for new vaults, with existing vaults able to upgrade through a migration assistant.

This is a place where the user should stay clear-eyed. Security is not a mood, and no marketing phrase makes trust automatic. The audit information is reassuring because it names outside firms and discusses findings, remediations, and documentation changes. It is also a reminder that secure sync is hard. A serious private-notes tool should be willing to say what changed, what was found, and where the user has choices. Obsidian’s public handling here is more concrete than the vague “we take privacy seriously” language that clogs software pages.

Shared vaults complicate the private-note story in an interesting way. Obsidian started as a deeply personal tool, but teams clearly want the same file-and-link model. Sync supports collaboration on shared vaults, and the homepage shows shared vault invitations and roles. This is useful for small teams, research groups, editorial projects, documentation teams, families, and organizations that want shared knowledge without giving up the vault model. It also raises a cultural question: how much collaboration can Obsidian absorb before it starts feeling like every other workspace app?

For now, the app’s center of gravity still feels personal. Even team features appear as an extension of vaults rather than a replacement for private thinking. That matters. The market is full of tools that slowly drift from “your notes” to “your organization’s knowledge hub” to “AI-powered workspace command center.” Obsidian may still change, but its local-file base makes a total drift harder. The individual vault remains a real thing, not a nostalgic feature.

Publish is the outward-facing sibling. It lets an Obsidian vault become a website, wiki, knowledge base, documentation hub, or digital garden. The Publish page emphasizes connected notes, hover previews, graph view, stacked pages, backlinks, Markdown editing, custom domains, themes, password protection, SEO, mobile performance, and optional analytics. It is easy to see why this appeals to people who already think in links. If your notes are a web, publishing them as a web feels natural.

Publish also belongs to a larger internet pattern: the return of the personal knowledge site. Blogs never fully died, but many people lost the habit of making sites that feel like maps rather than timelines. A digital garden is looser than a blog and more alive than a PDF. It can hold evergreen notes, reading lists, essays, documentation, class resources, public research, or a product manual. Obsidian Publish makes that jump from private vault to public garden feel coherent because the internal links already exist.

The best Publish sites do not look like content marketing hubs. They feel like a person or team thinking in public. The graph, backlinks, hover previews, and stacked pages are not just gimmicks when the material has real connections. They let readers move through a body of work by association. That is closer to browsing an old web directory, a wiki, or a well-kept commonplace book than scrolling a publication feed. It is a slower internet gesture, and that is part of its charm.

The risk is that publishing from a private notes app can tempt people to publish before notes are worth reading. A digital garden should not become an excuse to dump rough fragments on the web and call them evergreen. Obsidian lowers the friction, but editorial judgment still matters. Some notes should stay private. Some should become essays. Some should become documentation. Some should die quietly. The tool makes publishing easier; it does not make every note public-worthy.

The business model around Publish and Sync also tells a story about independence. Obsidian says it is 100 percent user-supported and not investor-backed, which is not a guarantee of virtue but does shape incentives. Investor-backed tools often need large markets, fast growth, and expansion into adjacent categories. A user-supported tool can still make bad choices, but it has more room to serve a passionate niche without chasing every enterprise trend. Obsidian’s paid services make sense because they are adjacent to the core use: keep notes across devices, publish notes to the web, support the app.

The pricing page’s commercial license note is also revealing. Obsidian does not require payment for commercial use, but encourages organizations to buy a license to support independence. That is an unusual posture in a software market trained to gate features tightly. It asks for support rather than forcing compliance at the individual level. Some organizations will pay. Some will not. The point is that the free app remains genuinely useful.

This does not mean Obsidian is cheap for every use. A person who pays for Sync and Publish is paying an ongoing subscription, and teams can add costs across users or sites. Users with strong technical habits may prefer alternative sync setups or static-site publishing. Others will happily pay because the official services reduce friction and keep money flowing to the product. The right answer depends on tolerance for setup, risk, and maintenance. What matters for Web Radar is the architecture of choice. Obsidian gives users real exits.

The combination of free local app, paid Sync, paid Publish, optional licenses, plugins, and open files creates a rare product posture. The app can grow into your daily life without making you feel trapped by the growth. That is not a small thing. Many tools become more frightening as they become more useful because leaving them becomes harder. Obsidian becomes more useful as the vault grows, but the files remain files. The app gains power without fully owning the archive.

Where Obsidian shines and where it asks for patience

Obsidian shines when your work or life contains ideas that return. It is strongest for recurring subjects, long projects, and knowledge that changes shape over time. A shopping list does not need Obsidian. A decade of reading notes might. A single meeting note can live anywhere. A network of decisions across a product, team, client, or thesis benefits from links. The app is not “better notes” in a generic sense. It is a better habitat for notes that want to keep talking to each other.

Writers are an obvious audience because Obsidian turns scraps into a searchable, linkable source field. A writer can keep quotes, outlines, drafts, deleted fragments, research notes, title ideas, character sketches, arguments, and publication plans in one vault. The app does not replace a final editing tool for every writer, but it is excellent before the final draft. It holds the messy phase with dignity. It lets material collect without pretending every note is ready for a document.

Students and lifelong learners get a different kind of value. Obsidian encourages concept maps instead of isolated storage. A course vault can connect lectures, readings, definitions, questions, essays, and exam prep. Notes become more useful when they link across weeks and classes. A biology concept might connect to chemistry. A philosophy argument might connect to politics. A literature note might connect to history. The point is not to create a perfect academic system. It is to make knowledge less disposable after the test.

Researchers can use it as a thinking layer above sources. Obsidian is good at synthesis because links let source notes and idea notes remain distinct. A PDF annotation can point to a concept. A concept can point to several papers. A project note can point to open questions. A method note can point to experiments. This structure supports the slow work of turning reading into thought. It also makes it harder for sources to become a pile of orphaned highlights.

Developers and technical teams often like Obsidian because Markdown, local files, code blocks, and plugins fit existing habits. A developer can keep architecture decisions, snippets, commands, API notes, debugging logs, release notes, and incident writeups in a vault. A team can maintain internal documentation with links and shared vaults. Publish can turn selected notes into docs. The app’s file-based logic feels less alien to technical users than closed rich-text systems.

Product people, designers, and founders may find a different kind of usefulness. Obsidian can hold research, customer conversations, roadmap doubts, feature ideas, competitor notes, positioning sketches, and decision logs without forcing premature polish. The ability to link a customer quote to a product bet, a pricing question, and a meeting note is not glamorous, but it is exactly how real judgment forms. Canvas helps when a product problem needs spatial arrangement. Bases helps when projects need structured views.

Personal users may be the most interesting group because Obsidian lets ordinary life become searchable without becoming public. Travel plans, recipes, journaling, family notes, medical questions, gift ideas, house projects, legal documents, books, films, workouts, and finances can sit in one vault or several. Some people will hate that. Others will feel a deep relief at having a private place where life is allowed to be connected. The app does not need every user to become a knowledge-management hobbyist. It only needs enough people to notice that their thoughts deserve better than a pile of disconnected notes.

Obsidian also shines for people who distrust lock-in. If you have ever tried to leave an app and discovered your own writing had become a hostage, Obsidian’s file model feels almost physical. You can see the files. You can move them. You can back them up. You can open them elsewhere. This does not make migration effortless, especially if your vault uses plugins or complex internal conventions, but it keeps the basic archive readable. That is a much better starting point than a closed database with a decorative export button.

The app asks for patience in the beginning. Its first hour can feel underwhelming unless you already understand what you want from it. A blank vault does not show the power of links, because there is nothing to link. The graph is empty. Backlinks are absent. Plugins are unknown. Canvas has no material. Obsidian is a slow-blooming tool. It gets better when you feed it honest notes for a while. That is a hard sell in an app culture trained around instant delight.

It also asks for taste. The plugin ecosystem is powerful enough to ruin your setup. Install too many plugins and the vault can become noisy, fragile, or mentally expensive. Every plugin adds choices, settings, commands, and possible breakage. Some are wonderful. Some are niche. Some become abandoned. The mature Obsidian user learns restraint. The beginner often learns by making a mess, which is acceptable as long as the underlying notes survive.

The interface can also feel dense. Obsidian has panes, sidebars, command palettes, settings, core plugins, community plugins, themes, hotkeys, properties, links, embeds, canvases, bases, graph controls, and sync options. None of these are impossible, but the mental surface area is larger than a simple notes app. A user who wants a frictionless place to jot groceries may find it excessive. A user who wants to build a long-term thinking room may find the complexity worth it.

Mobile use is another area where expectations matter. Obsidian on mobile is powerful, but the app’s deepest strengths still feel more natural on a larger screen. Quick capture, reading, small edits, and reference work are fine on a phone. Canvas, plugin configuration, large refactors, and deep research are more comfortable on desktop or tablet. This is not unique to Obsidian. Knowledge work is cramped on small screens. The difference is that Obsidian invites complex work, so the limits show.

The local-first model can be confusing for people raised on web apps. A vault is a folder, which means file paths, sync conflicts, backups, and attachments matter. Obsidian Sync hides much of that if you use it, but the underlying reality remains. Some users will prefer a tool where the service handles everything invisibly. Obsidian is for people who are willing to know a little more about where their work lives. That knowledge is a gift and a burden.

There is also a philosophical risk: Obsidian can make you feel like collecting knowledge is the same as using it. Links, highlights, clipped pages, tags, graphs, and dashboards can become a beautiful postponement. A vault full of other people’s ideas is not wisdom. A vault full of your own notes is not automatically insight. The app can preserve thought, connect thought, and bring thought back. It cannot decide what the thought is worth. That remains human labor.

The best criticism of Obsidian is not that it is too hard. It is that it can flatter the part of the mind that enjoys systems more than outcomes. Some users spend months designing a vault architecture for work they never do. This is not the app’s fault alone; every flexible tool attracts ritual. Yet Obsidian’s community can sometimes make newcomers believe they need a grand method before writing a paragraph. They do not. They need one note, then another, then a link where the connection is real.

A good first use is modest. Create a vault for one live area of your life. Not everything. One thing. A research topic. A writing project. A trip. A reading habit. A course. A client. A personal journal. Add notes when they have a reason to exist. Link names, places, ideas, sources, and questions. Use daily notes only if they fit. Add one or two plugins after a real need appears. Try Canvas when you have enough pieces to arrange. Let the vault earn complexity.

Obsidian is not for everyone, and that is part of its appeal. It does not need to become the universal note app. It is too specific, too file-minded, too customizable, too patient, too odd. The web is better when some tools choose a strong audience instead of sanding themselves into generic mass-market smoothness. Obsidian’s audience is broad, but the attraction is precise: people who want private, durable, linkable thought, and who do not mind shaping the tool around themselves.

What Obsidian reveals about the web

The deeper reason Obsidian belongs in Web Radar is that it feels like a local remix of the web’s best old ideas. Hyperlinks. View source energy. Personal sites. Plain files. Extensibility. Communities making small tools for each other. A distrust of centralized ownership. A belief that documents can have lives beyond the app that displays them. These are not new ideas, but they feel newly fresh because so much current software has moved in the opposite direction.

The public web became an attention machine. Obsidian takes the hyperlink and removes the audience pressure. A link inside your vault does not chase clicks. It does not feed an algorithm. It does not need a title optimized for sharing. It exists because two thoughts belong near each other. That makes the link feel innocent again. A private link is a small act of interpretation. It says, “This reminds me of that,” without turning the reminder into content.

This is why the app has a strange moral texture. It gives users a way to build a private internet of memory while the public internet gets louder. That does not make Obsidian anti-web. Publish, Web Clipper, embedded pages, community plugins, and forums all connect it outward. But the center is quiet. You collect from the web, think privately, connect ideas, and publish selectively. That rhythm is healthier than the default cycle of consume, react, post, vanish.

The Web Clipper is a good example of this rhythm. A useful clipper should not just save pages; it should make web material available for thought. Saving an article to a read-later queue often means burying it. Clipping a passage into a vault, linking it to a project, and adding your own note gives it a better chance of returning. Obsidian’s clipper supports local storage, Markdown output, exportable settings, hotkeys, templates, and extraction from page data. That is more than capture. It is digestion.

Publish closes the loop by letting some private thought become public structure. A Publish site can behave like a small, intentional web rather than a feed. Readers can follow backlinks, hover previews, stacked pages, graph connections, and full-text search. That experience is not right for every piece of writing, but it is perfect for bodies of knowledge that grow over time. Documentation, course notes, public research, and digital gardens all benefit from non-linear reading.

This matters because the personal website has been quietly returning as a cultural desire. People want places online that do not feel rented from a social network. They want pages that can change, collect, and link without being buried by yesterday’s timeline. Obsidian Publish is not the only way to build such a place, and technically inclined people may prefer static site generators. But for Obsidian users, Publish is appealing because it turns the existing vault into a site without rebuilding the whole system elsewhere.

The app also shows how much people miss tools with communities rather than platforms with audiences. The Obsidian community is full of people sharing setups, plugins, themes, workflows, and experiments. Some of it is excessive. Some of it is brilliant. Much of it has the old web’s workshop feeling: a person solved a strange problem, posted the method, and now someone else can adapt it. This is different from influencer productivity culture, though the two sometimes overlap. The best Obsidian sharing feels like neighbors showing each other how they built shelves.

The plugin directory is a living index of that culture. It proves that niche needs are not edge cases when the tool is extensible. Someone wants markdown-backed kanban boards. Someone wants task queries. Someone wants a calendar. Someone wants draw.io diagrams. Someone wants hidden files visible. Someone wants translation. Someone wants startup pages. A centralized product team would ignore most of these or turn them into bloated official features. A plugin ecosystem lets the long tail exist.

This does create governance questions. A plugin ecosystem needs trust, review, maintenance, and user judgment. Community code is part of the charm and part of the risk. Users should be careful with plugins that touch sensitive data, sync externally, or run complex automation. Obsidian reviews plugins before they enter the community directory, but no ecosystem removes every risk. The broader lesson is that freedom and caution travel together. A locked-down app feels safer until you need it to do something it refuses to do.

Obsidian’s independence also says something about product economics. A tool can be ambitious without treating user data as fuel. The company’s stated model is user-supported, with optional paid services and licenses. That stance will always face pressure: growth, support costs, security work, platform changes, and user demands do not disappear. Still, the current model aligns better with private thought than advertising, engagement feeds, or forced cloud storage would. The business model and the product philosophy are at least pointed in the same direction.

The app’s design also resists the current urge to put AI at the center of every writing experience. Obsidian’s core value is not that a machine thinks for you, but that your own thinking has a durable place to accumulate. There are AI plugins for users who want them, and many people will combine local notes with language models in careful ways. But the app itself does not need to become an AI wrapper to feel current. Its relevance comes from an older question: where do your thoughts live when nobody else is watching?

That question may be more urgent now precisely because so much software tries to mediate cognition. Calendars tell you what matters, feeds tell you what to notice, AI tools offer to summarize what you have not read, and work apps turn every thought into a collaborative artifact. Obsidian does something less glamorous. It gives you a place to write, connect, and return. The lack of spectacle is a feature. Thinking often needs fewer witnesses.

The local-first movement around tools like Obsidian also hints at a possible correction in software taste. Users are rediscovering the value of files, offline access, fast interfaces, exportability, and tools that do not vanish when a server hiccups. This is not a rejection of the cloud. Sync, Publish, and web clipping are cloud-adjacent or web-connected features. It is a rejection of cloud dependency as the default condition for private work. A tool can connect to the internet without belonging to it entirely.

Obsidian is not alone in this. A broader set of apps now tries to combine local ownership with modern interface design, from writing tools to databases to creative coding environments. What makes Obsidian stand out is the completeness of the thought: Markdown files, links, graph, Canvas, plugins, Sync, Publish, Web Clipper, Bases, and a community that treats the vault as a personal object. It is not just “offline notes.” It is an ecosystem built around the premise that your knowledge should remain yours.

This is why Obsidian feels like a hidden internet gem even though it is no longer obscure. Its weirdness is still intact. The app has not been fully smoothed into a generic productivity brand. It still speaks to people who like personal wikis, local folders, open formats, plugins, and quiet tools. It still invites users to build something idiosyncratic. It still makes room for private depth. In an internet culture obsessed with visibility, a tool for invisible thought has a special charge.

Notes before installing

Author:
Jan Bielik
CEO & Founder of Webiano Digital & Marketing Agency

This article is an original analysis supported by the sources cited below

Obsidian
Official homepage for Obsidian, used for its positioning, feature overview, privacy language, examples around links, Canvas, plugins, Sync, Publish, and the “Sharpen your thinking” framing.

About Obsidian
Official manifesto and team page, used for Obsidian’s stated principles around user ownership, durable files, privacy, customization, independence, and user-supported development.

Obsidian pricing
Official pricing page, used for the free core app, Sync and Publish pricing, optional licenses, commercial-use note, local-data claims, telemetry statement, and refund details.

Obsidian Sync
Official Sync product page, used for cross-platform syncing, offline work, end-to-end encryption, version history, selective sync, file recovery, and shared vaults.

Obsidian Canvas
Official Canvas page, used for the visual thinking features, infinite space framing, embedded media support, and Canvas positioning inside Obsidian.

Canvas in Obsidian Help
Official help page, used for the description of Canvas as a core plugin and for the .canvas file and open JSON Canvas format details.

Obsidian Web Clipper
Official Web Clipper page, used for the local storage, Markdown saving, JSON export, templates, hotkeys, and page-data extraction details.

Introduction to Bases in Obsidian Help
Official help page, used for Bases as a core plugin, database-like views, table/list/card/map layouts, local Markdown data, and .base file behavior.