<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Juhie Chandra on Medium]]></title>
        <description><![CDATA[Stories by Juhie Chandra on Medium]]></description>
        <link>https://medium.com/@juhiechandra?source=rss-3cf168f0a9c1------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*zRRJ3bvkIdRV-RLHUSAgQQ.png</url>
            <title>Stories by Juhie Chandra on Medium</title>
            <link>https://medium.com/@juhiechandra?source=rss-3cf168f0a9c1------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 08:25:52 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@juhiechandra/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[How a SIEM Actually Works: Splunk, Opened Up]]></title>
            <link>https://medium.com/@juhiechandra/how-a-siem-actually-works-splunk-opened-up-127dd58c4e27?source=rss-3cf168f0a9c1------2</link>
            <guid isPermaLink="false">https://medium.com/p/127dd58c4e27</guid>
            <category><![CDATA[ai-security]]></category>
            <category><![CDATA[siem]]></category>
            <category><![CDATA[blue-team]]></category>
            <category><![CDATA[splunk]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Juhie Chandra]]></dc:creator>
            <pubDate>Tue, 21 Jul 2026 21:16:28 GMT</pubDate>
            <atom:updated>2026-07-21T22:00:49.209Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>One suspicious login, followed through every gear of a SIEM: how Splunk stores, searches, schedules, and scores its way to the moment someone gets paged.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xus5Yuj3XjScJTiIEzc_kA.png" /><figcaption>TBs of data to a single event</figcaption></figure><blockquote>Author’s note: the research and analysis here are my own. I used Claude to help structure and sequence the draft. I write about Splunk specifically, because you cannot explain a machine honestly in the abstract, but the mechanics are roughly 90% the same in every SIEM, and there is a translation table for Elastic, Sentinel, and QRadar at the end.</blockquote><p>09:03 on a Tuesday. A Linux server writes six lines to /var/log/auth.log.</p><p>Five say a password failed for the user anna. The sixth says one succeeded. All six came from 203.0.113.9, an address in a country anna has never logged in from.</p><p>Nothing catches fire. No siren goes off. Six lines of text sit on a disk in a data center, indistinguishable from the eleven million other lines written that hour.</p><p>Somewhere, a machine either notices this or it doesn’t.</p><p>This article is about that machine.</p><p><strong>Who this is for:</strong> engineers, and the technically curious, who have heard of logs and alerts but have never sat inside a SIEM.</p><h3>What a SIEM is, and why it quietly carries corporate security</h3><p>A SIEM (Security Information and Event Management) is the single place every log from every system in a company lands, is stored, and is watched. Your servers, laptops, firewalls, cloud accounts, badge readers, and login systems all ship their logs to this one system, and it keeps them and stares at them.</p><p>It’s really three jobs wearing one invoice.</p><p>It’s the security team’s <strong>eyes</strong>. When someone is attacking you right now, the SIEM is what notices, or doesn’t. This is <em>detection</em>.</p><p>It’s the security team’s <strong>memory</strong>. When you need to know everything a compromised account touched over the last 90 days, the SIEM is the only system that can answer, because it kept everything. This is <em>forensics</em>.</p><p>And it’s the security team’s <strong>paperwork</strong>. The reason an auditor signs off and a regulator believes you can see inside your own walls is that the SIEM exists and retains what it’s supposed to. This is <em>compliance</em>, and it’s often the real reason the thing was bought.</p><p>Hold onto all three. Most of this article is about detection, but I’ll close the loop on the other two before the end. They’re not side quests, they’re the same machinery pointed at a different question.</p><p>The room you picture when you think “cybersecurity” (the SOC, the wall of monitors) is architecturally a room full of people arranged around this one system’s output. The whole job is reading what it surfaces.</p><h4>The money, and the dependency</h4><p>None of this is cheap, and the pricing is where it gets interesting.</p><p>Many SIEMs are priced per gigabyte of data you send them (Splunk itself now pushes workload- and compute-based pricing too, but per-GB is still the mental model most of the industry budgets against). Think about what that does. Every decision to watch a new system is also a decision to pay more, forever. <strong>The pricing model doesn’t just cost money. It quietly edits what a company is willing to see.</strong> Whole categories of logs get dropped not because they’re useless but because they’re expensive.</p><p>And it’s one of the stickiest systems in the enterprise. Years of tuned detection rules. Years of historical data you’re legally required to keep. Analysts whose instincts are shaped around this specific tool. Migrating means rebuilding all three at once, which is why companies rarely do it cleanly. More often the old system never fully dies. It gets demoted to a compliance archive while everyone works around it.</p><blockquote><strong><em>Aside: what “normal” looks like, in numbers.</em></strong><em> Rough orders of magnitude, not benchmarks, and they vary wildly by industry: a mid-size enterprise pushes </em><strong><em>hundreds of GB to a few TB per day</em></strong><em> into its SIEM. One TB/day is very roughly </em><strong><em>20,000 events per second</em></strong><em>, sustained. A mature Splunk Enterprise Security deployment runs </em><strong><em>hundreds of enabled detections</em></strong><em>; Splunk’s own public content library ships well over a thousand to choose from. A healthy scheduler </em><strong><em>skip ratio is low single-digit percent</em></strong><em>; sustained double digits is treated as an incident by teams who know to look. And an analyst can meaningfully triage on the order of </em><strong><em>ten to twenty alerts per shift</em></strong><em>, which is the constraint the entire second half of this article exists to respect.</em></blockquote><h4>SIEM vs EDR vs SOAR vs XDR, in four lines</h4><p>The most common newcomer confusion, cleared up before we start:</p><ul><li><strong>SIEM</strong>: collects logs from everything, stores them, and decides what’s worth a human’s attention. This article.</li><li><strong>EDR</strong> (Endpoint Detection &amp; Response): detects <em>on the laptop or server itself</em>. It’s a major <em>source</em> of logs for the SIEM, not a competitor to it.</li><li><strong>SOAR</strong> (Security Orchestration, Automation &amp; Response): <em>acts</em> on what the SIEM decides. Disable the account, isolate the host, open the ticket.</li><li><strong>XDR</strong>: largely the marketing word for the integrated bundle of the above, sold as one product.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*fe2JPO6bMfMxPCSP.png" /><figcaption>Diagram showing five log sources (servers, laptops, firewalls, cloud accounts and login systems) all streaming into a single central box labelled “The SIEM”, which surfaces a few alerts to a security operations centre on the right. anna’s suspicious login enters at the top left through the servers, like any other log line. Two dotted arrows leave the SIEM: one to an invoice, billed per gigabyte ingested, and one representing accumulated lock-in.</figcaption></figure><p><strong>Diagram 1: Everything a company runs streams into one system; a room of humans reads the few things it surfaces.</strong></p><p><em>Every system a company runs streams its logs into one place; a room of humans reads the few things it surfaces. anna’s login (red) enters like any other line. The two dotted arrows are what make a SIEM unlike other software: it bills by the gigabyte, and once installed it is almost impossible to leave.</em></p><p>Here’s the uncomfortable part. The dependency is total, and the understanding is optional. Almost nobody who depends on this machine (not the executives who sign for it, often not even the analysts who live in it) can tell you how it actually works inside.</p><p>The knowledge spans two tribes that don’t talk. A SIEM’s storage half is a database problem, and database people mostly don’t care about security operations. Its detection half is a security problem, and detection engineers rarely look below the query language. The full picture requires standing in both rooms, and almost nobody does.</p><p>So let’s open it up.</p><h3>In this article</h3><p><strong>Part 1: The storage machine</strong></p><ol><li>The frame: storage plus detection</li><li>Getting a log into a searchable pile</li><li>Reading a billion lines before your coffee cools</li><li>Immutable data, editable meaning</li></ol><p><strong>Part 2: The detection machine</strong></p><ol><li>The heartbeat: a rule that doesn’t run is a rule that doesn’t exist</li><li>Anatomy of a detection: the query is the smallest part</li><li>The six shapes of detection logic</li><li>The scorekeeper: how a thousand mediocre rules make one good alert</li><li>Context: the same event is boring or terrifying depending on who</li><li>When to attach a fact: the three checkpoints</li><li>Threat intel: the list of known bad</li><li>Keeping the machine honest: detections as code</li></ol><p><strong>The close</strong></p><ol><li>The full run: one log line to one alert, and one human</li><li>The same machine, four name tags</li><li>Takeaways</li></ol><p>A note on method: some of what follows is officially documented, and some is community knowledge, reverse-engineered by people who live in these systems.</p><h3>Part 1: The storage machine</h3><h4>1. The frame: storage plus detection</h4><p>Here is the frame, and I’ll state it once because it structures everything that follows:</p><blockquote><strong><em>A SIEM is storage plus detection.</em></strong></blockquote><p><strong>Storage</strong> is the problem of getting every log in the company into one pile you can search in seconds. It is a genuinely solved problem, and it’s elegant.</p><p><strong>Detection</strong> is the problem of continuously asking that pile questions and deciding when a human should be woken up. It is not solved, it’s where all the interesting failures live, and it gets most of this article.</p><p>Everything below is those two halves in detail.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*sJsd_LxXC9UBYB-n.png" /><figcaption>Architecture diagram of a SIEM in two bands. The top band, the storage machine, flows left to right: anna’s login enters via an agent tailing log files or an HTTP Event Collector for cloud sources, through a parsing pipeline that finds the timestamp, into immutable time-sliced buckets with word-index and bloom-filter accelerators, then a read-time meaning overlay and a pre-computed accelerated summary. The bottom band, the detection machine, shows a scheduler that either runs a detection or silently skips it, the detection writing points rather than alerts into a central risk ledger, alongside a context engine that rescales those points, a threat-intelligence feed, and hundreds of other rules. A single watcher reads the ledger and asks whether one entity has enough points, from enough rules, across enough attacker tactics, and emits one alert to one analyst.</figcaption></figure><p><strong>Diagram 2: The whole machine. Each numbered box is one section of this article.</strong><em>anna’s login enters at the left and exits at the right as one alert on one analyst’s screen. Each numbered section below zooms into one box of this diagram. Nothing else in the machine exists that isn’t on this picture.Where anna’s login is now: six lines of text on a server’s local disk, unread by anyone.</em></p><h4>2. Getting a log into a searchable pile</h4><p><strong>The question this section answers:</strong> how does a line of text on some server become something you can find, instantly, among a trillion others?</p><p>Three stages: an agent ships it, a pipeline parses it, and storage files it into time-sliced chunks.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ABW4fgDhu84AE3fS.png" /><figcaption>Diagram of a Splunk ingestion pipeline in three stages. On the left, an agent tails a log file on a machine, keeps a checkpoint called a fishbucket made of a file fingerprint plus a byte offset, and buffers to an on-disk queue that survives network stalls. A second inlet below shows cloud, SaaS and Kubernetes sources pushing events directly over a token-authenticated HTTP Event Collector with no agent. Both routes feed a parsing pipeline that breaks the stream into events, merges multi-line events, and finds the timestamp, which becomes the master index; unwanted data is routed away to the nullQueue to save cost. What survives is written into immutable, time-sliced storage buckets, with two accelerators attached: a tsidx word index that jumps to events that do match, and a bloom filter that skips buckets that cannot match.</figcaption></figure><p><strong>Diagram 3: Three stages. An agent (or HEC) ships it, a pipeline parses it, storage files it by time.</strong><em>Follow the file at the left. It’s tailed by an agent that remembers exactly where it stopped; cloud sources skip that step entirely and push straight in over HEC. Both routes land in the same parsing pipeline, whose most consequential job is the one in the middle: finding the timestamp. What survives is written into sealed, time-sliced buckets with two accelerators bolted on, and those two exist for a single purpose: to let a later search avoid reading data.</em></p><h4>The agent</h4><p>On every machine there’s an agent whose whole job is to tail log files and ship new lines.</p><p>The clever bit is small and worth naming. For each file, the agent keeps a <strong>checkpoint</strong>: a CRC fingerprint of the file’s first few hundred bytes, plus a byte offset of how far it has read. Splunk calls this the <strong>fishbucket</strong>. The fingerprint is how it recognizes a file it has seen before; the offset is how it knows where it stopped. Pair that with a local on-disk queue and you get durability nearly for free: when the network sulks or the receiver is busy, the agent parks data on disk and catches up later.</p><blockquote><strong><em>Aside: the classic fishbucket bug.</em></strong><em> Two files whose opening bytes are identical hash to the same fingerprint, and one of them silently never gets read until you widen </em><em>initCrcLength. This is the first of many silent failures in this article, and they all rhyme: no error, no red light, just a thing that quietly isn&#39;t happening.</em></blockquote><p>One distinction matters downstream:</p><p><strong>Table 1: The two agent types, and the one difference that matters downstream.</strong> <em>(→ Table 1 card, asset 04)</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/908/1*hDl-o9PHg5bdRwQEJVn2ww.png" /></figure><blockquote><em>Either way, an agent is a checkpointed file-reader with a buffer and a load-balancing client. That’s the whole trick.</em></blockquote><p><strong>Not everything is a file.</strong> Cloud services, SaaS audit logs, serverless functions, and Kubernetes have no local agent tailing anything. They push events over the <strong>HTTP Event Collector (HEC)</strong>, a token-authenticated HTTP endpoint that drops straight into the same parsing pipeline. If your mental model of ingestion is only “agent tails a file,” you’re picturing 2015. In a cloud-first environment, a large share of the most security-relevant data arrives over HEC and never touches a forwarder.</p><h4>The parsing pipeline</h4><p>Raw bytes arrive as an undifferentiated stream and move through the indexer in fixed-size blocks, tagged with host, source, sourcetype, and index before anyone looks at the content.</p><p>Then the pipeline does three jobs in order: break the stream into events ( LINE_BREAKER), decide whether adjacent lines belong to the same event ( SHOULD_LINEMERGE), and find the timestamp, which earns its own paragraph.</p><p>Get the timestamp wrong and everything downstream silently breaks, because in a SIEM <strong>time is the master index</strong>. Splunk carries two clocks per event:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/731/1*oGc_lVPK84ffKM7ytLiP8Q.png" /></figure><p>Every time-window detection keys on _time. Misparse it (wrong field, wrong timezone) and the event is filed under the wrong hour, where every detection scanning that window looks straight past it. <strong>More detections die of bad timestamps than of bad logic.</strong></p><p>This same pipeline is also where events get dropped on purpose: a routing rule sends unwanted data to the nullQueue, the cost shock-absorber that keeps you from paying to store noise.</p><h4>Storage as time-sliced, immutable chunks</h4><p>An index is a directory of <strong>buckets</strong>, and a bucket is a slice of time. Its filename literally encodes the epoch range of the events inside it, so “search the last hour” starts as filename arithmetic rather than a scan. Buckets age through a lifecycle (hot, warm, cold, frozen) rolling on triggers like maxDataSize, and once sealed, a bucket is never modified.</p><p>Inside each one: journal.gz, the raw events compressed in seekable slices, plus two accelerators glued on top. A <strong>word index</strong> ( tsidx) maps each distinct token to the events containing it. And a <strong>bloom filter</strong>, a &quot;definitely-not-here&quot; test that can rule an entire bucket out without opening its index. Both exist for one reason: to let a search avoid reading data, the entire performance religion of the next section.</p><blockquote><strong><em>Aside: sourcing.</em></strong><em> The bucket lifecycle and config keys are official Splunk documentation. The exact on-disk </em><em>tsidx and bloom layout is documented mostly through community conference talks and can change. I&#39;m telling you the shape, not the byte offsets.</em></blockquote><p>Two things change at scale. <strong>SmartStore</strong> puts warm buckets in object storage and keeps a local cache of what’s actually being searched, so storage and compute scale independently, and it’s the default in Splunk Cloud. <strong>Indexer clustering</strong> replicates each bucket across peers, which is how a system that never modifies a sealed bucket survives hardware failure.</p><p>And the frozen tier is quietly the compliance job wearing storage clothes: when a bucket ages past your retention policy it’s deleted or archived, and <em>that policy is the compliance promise</em>, expressed in config rather than PowerPoint. Job three of the three jobs, in about four settings.</p><p><em>Where anna’s login is now: six events, timestamped and sealed inside an immutable bucket, with a word index and a bloom filter sitting on top of them.</em></p><h4>3. Reading a billion lines before your coffee cools</h4><p><strong>The question:</strong> a SIEM holds an absurd amount of data, and a search over it comes back in seconds. How?</p><p>The secret is that the searcher never reads everything. It <em>eliminates</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_-eOprjCjV90Z1mI.png" /><figcaption>Funnel diagram showing how a SIEM search eliminates data rather than reading it. It starts with a billion stored events. The first stage checks whether each chunk is inside the requested time range, which is filename arithmetic and eliminates whole chunks without opening them, leaving about fifty million. The second stage uses a bloom filter to rule out chunks that definitely cannot contain the search term, leaving about four million. The third stage uses a word index to name exactly which events could match, leaving about two thousand. All three of those stages happen without reading any raw data. Only the final stage decompresses raw bytes, and it returns anna’s six events.</figcaption></figure><p><strong>Diagram 4: A search reads a billion lines by refusing to read almost all of them.</strong></p><p>Watch a question run. The time range you asked for immediately kills every chunk outside it, unopened. That’s filename arithmetic, not I/O. The bloom filter on each surviving chunk rules out most of the rest: <em>that username is definitely not in here.</em> The word index on what remains says exactly which events could match. And only then, for that final handful, does anyone decompress raw bytes.</p><p>A billion events down to six, and every elimination except the last happened without reading a byte of raw data. (The counts on the diagram are illustrative, not measured; the shape is the point.)</p><p><strong>This is why the entire folk wisdom of SIEM performance is “narrow the time range and add a distinctive word.”</strong> You’re not tuning. You’re feeding the funnel.</p><h4>Now scale it out</h4><p>One machine can’t hold all the data, so the data is spread across many and the question is spread with it.</p><p>The heavy lifting (the filtering and counting) runs on every storage node in parallel, over its own local slice. Each node sends back not raw events but a small summary, and a coordinating node assembles the summaries into the final answer. That’s map-reduce, if you want the term. <em>Many workers each count their own pile, one boss adds up the notes</em>, if you don’t.</p><p>This has a consequence that explains a dozen strange behaviors later. There is a <strong>split point</strong> in every search: the first command that needs all the data gathered in one place. Everything before it runs wide and parallel on the storage nodes. Everything after it is stuck on the coordinator, <em>including commands that could have run in parallel</em>, because the cut is one-way.</p><p>So eval and where and filters are nearly free when they come early, and expensive when they come late. Sequence logic, which needs events in strict order, can only run on the coordinator, which is why the detections in section 7 that look for <em>X then Y</em> are inherently pricier than the ones that just count.</p><p>Crucially, the coordinating node ships its dictionaries and rules (the field definitions, the lookup tables) <em>down to every worker along with the question</em>. Splunk calls this the <strong>knowledge bundle</strong>. Remember it: <strong>the knowledge goes to the data, not the other way around.</strong> It explains a performance mystery in section 10.</p><h4>The language</h4><p>The query language is SPL, and you can understand it as a pipeline of verbs joined by pipes: filter, then compute a field, then group and count, then keep the weird groups. search narrows, eval shapes each row, stats collapses rows into per-entity counts.</p><p>Read enough detections and they all have the same skeleton: <em>shape the events, summarize them per entity, keep the anomalies.</em></p><p>Which sets up the single most important sentence in this article:</p><blockquote><strong><em>A detection is just one of these questions, put on a timer.</em></strong></blockquote><h4>4. Immutable data, editable meaning</h4><p><strong>The question:</strong> if the stored events are never modified, how does the meaning of your data ever improve?</p><p>Here’s the philosophical center of the storage story, and it’s genuinely counterintuitive.</p><p>The raw events are never modified. Not once, ever. But the <em>meaning</em> of those events (the fields, the labels, the categories) is an overlay applied fresh every time you read them. Splunk calls these overlays <strong>knowledge objects</strong>.</p><p>The picture to hold is a stack of clear plastic sheets laid over a printed map. The map underneath never changes, but you can add, remove, and reorder the transparent sheets on top, and the next time you look you see a different combined picture.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*BM1xbxoLk7lmKuxu.png" /><figcaption>Diagram of read-time meaning as transparent sheets over a printed map. On the left, raw events on disk are the printed map, never modified. Three sheets sit on top of it: sheet one extracts fields, pulling user and source address out of the raw text; sheet two maps vendor field names onto a shared vocabulary, turning ClientIP into src and result into action; sheet three applies tags marking the record as an authentication event. Combined at read time, they produce what a detection actually reads: user equals anna, src equals 203.0.113.9, action equals failure. That combined view is then folded into a pre-computed accelerated summary rebuilt roughly every five minutes. A note off the second sheet reads: redraw a sheet and all of history re-reads itself. Re-interpreting beats re-ingesting.</figcaption></figure><p><strong>Diagram 5: The map underneath never changes. The sheets on top can be redrawn at any time.</strong><em>The heavy black box on the left is the only thing in this picture that is permanent. Everything to the right of it is a decision you can revise this afternoon, and the dotted line is the payoff: change one sheet, and every event ever stored is re-read through the new understanding, without re-ingesting a byte.</em></p><p>Why is this the right call for security data specifically? <strong>Because security data is hostile, messy, and your understanding of it changes weekly</strong>. A new attack teaches you that a field you ignored actually mattered. If meaning were baked in at write time, you’d have to re-ingest years of logs to reinterpret them. Because meaning is an overlay, you fix the overlay once and instantly re-read all of history through the new understanding.</p><p><strong>Re-interpreting beats re-ingesting. That is the entire reason a SIEM stores raw and interprets late.</strong></p><h4>The vocabulary problem</h4><p>Forty different products log in forty different ways. One says src_ip, one says ClientIP, one says source_address.</p><p>A shared dictionary (Splunk calls it the <strong>Common Information Model</strong>, the CIM) maps them all onto the same handful of words: user, src, action. Normalize each source into that dictionary once, and every detection you ever write against the standard words automatically covers all forty sources without naming any of them.</p><p>This is the quiet superpower. A detection for “suspicious login” is written once and works across Linux, Windows, VPN, and cloud, because they were all taught to speak the same three words. It’s an interface, in the programming sense: detections code against the interface, and each log source provides an implementation.</p><p>The corollary is brutal and worth writing on a wall: <strong>CIM coverage is detection coverage.</strong> A log source nobody normalized is invisible to every detection you have, and (as we’ll see in section 11) invisible to threat intel too. It is a blind spot that produces no error message.</p><h4>The catch is speed</h4><p>Interpreting a billion raw events at read time is slow, and you can’t do it thousands of times a minute.</p><p>So a background process keeps pre-computed summaries fresh (Splunk calls this <strong>data model acceleration</strong>) and detections read the compact summary instead of the raw pile. Mechanically: a summarization search runs about every five minutes to fold in new data, a cleanup pass runs about every thirty minutes, and the summaries live on the indexers right next to the buckets, so the parallel phase can read them locally. You choose a summary range (say seven days); questions inside the range hit the fast path, questions beyond it fall back to raw.</p><p>The whole detection machine runs at the speed of “read the summary,” not “re-parse everything.”</p><blockquote><strong><em>Aside: the fast path is not the complete path.</em></strong><em> Searching the summary only, when the summarization has fallen behind, returns </em>nothing<em> for the gap rather than an error. A detection can be blazing fast and quietly blind at the same time. Acceleration lag is a thing mature teams monitor.</em></blockquote><p>Which leaves you with a triangle you’ll spend a career tuning: <strong>flexibility, speed, and storage.</strong> Interpret-on-read gives you flexibility. Summaries give you speed. Both cost storage and background compute. Pick two, pay for the third. There is no configuration that gives you all three, and anyone selling you one is selling you a budget decision wearing an architecture costume.</p><blockquote><strong><em>Aside: “why not just use a database?”</em></strong><em> Fair question, and the honest answer is that you can. The workload has a specific shape: append-only immutable events, almost always pruned by time first, with hostile schemas that change under you (hence schema-on-read), aggregation distributed across many nodes, and tiered retention measured in years. Those constraints are what produced the design above, but they’re not unique to Splunk, and Elastic-based and ClickHouse-based SIEMs are real, credible competition on exactly this half of the problem. What you’re actually buying from a SIEM vendor isn’t the storage engine. It’s everything in Part 2: the detection layer, the content library, the risk framework, and the ecosystem of people who already know it.</em></blockquote><p><em>Where anna’s login is now: readable as clean fields (</em><em>user=anna, </em><em>src=203.0.113.9, </em><em>action=failure) and folded into a pre-computed summary that a detection can scan in seconds.</em></p><p>That’s the solved half. It’s genuinely elegant, and you could assemble a workable version from open-source parts in about a week. Now the interesting half.</p><h3>Part 2: The detection machine</h3><h4>5. The heartbeat: a rule that doesn’t run is a rule that doesn’t exist</h4><p><strong>The question:</strong> who actually runs a detection, when, over which slice of time, and what happens when the system is too busy?</p><p>We’ve reached the most under-appreciated component in all of security. It gets zero conference talks and causes most of the misses: the <strong>scheduler</strong>.</p><p>Picture a commercial kitchen with a fixed number of burners and far more recipes than burners. Walk-in customers (analysts running ad-hoc searches) get priority over the timed recipes. When more detections come due than there are slots, the overflow doesn’t wait its turn.</p><p><strong>It is skipped.</strong> Not delayed, not queued, not retried. Skipped. The time window that would have been examined is simply never examined by anyone.</p><p>The arithmetic is public. Total search slots are max_searches_per_cpu × CPUs + base_max_searches, and the scheduler only gets a share of that: max_searches_perc, which <strong>defaults to 50%</strong>. The other half is reserved so analysts aren&#39;t starved. A busy SOC can therefore starve its own detections, which means capacity planning <em>is</em> detection engineering.</p><p>Sit with how dangerous that is. A skipped rule and a rule that ran and found nothing look <em>identical</em> from the outside. Both produce no alert. There is no error, no apology, no red light. Your coverage can quietly drop by a third on a busy Monday morning and nothing tells you.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*SOGe6lIunjNtCBkw.png" /><figcaption>Timeline diagram showing two silent failure modes of a SIEM scheduler, across the times 09:00, 09:05, 09:08 and 09:10. The top lane shows scheduled detection runs: the 09:00 run ran and found nothing yet; the 09:05 run was skipped entirely because no search slot was free, meaning that window was never examined and nobody was told, marked as silent death number one; the 09:10 run ran and re-read recent history by arrival time. The middle lane shows anna’s login events occurring between 09:00 and 09:05 but not reaching the SIEM until 09:08 because of a forwarder hiccup. The bottom lane compares what each run could see: a narrow window covering 09:00 to 09:05 by event time misses the events entirely because they had not arrived yet, marked as silent death number two; a wide window covering the last seventy minutes of event time but filtered by arrival time covers 09:08 and catches the pattern anyway.</figcaption></figure><p><strong>Diagram 6: Two ways a detection goes blind without producing a single error message.</strong><em>Read the middle lane first: anna’s logins happen at 09:00 but don’t reach the SIEM until 09:08. Now look at the runs above. The 09:05 run was skipped outright: no slot, no error, that window gone forever. The 09:10 run survives only because its window is wide and filtered by arrival time rather than event time. Both failures are silent; only the second one has a fix inside the rule.</em></p><p>There’s a second quiet killer at this stage: <strong>late-arriving data.</strong></p><p>Every event has two times: when it happened (_time) and when the SIEM received it (_indextime). Usually they&#39;re close. But a forwarder hiccup can make an event that happened at 09:00 arrive at 09:40. Now the trap: the run at 09:05 looked at the 09:00-09:05 window, found nothing because the event hadn&#39;t arrived, and by the time it lands at 09:40, no run is looking at that window anymore. The event is never evaluated.</p><p>The fix is a deliberate overlap. Instead of tiling exact five-minute windows, each run re-reads a much wider window of history but keeps only the events that <em>arrived</em> since the last run:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/721/1*xM8_EiGB0do8Mp4uzSOWAw.png" /></figure><p>The earliest clause scans seventy minutes of <em>event</em> time, so late arrivals are inside the window. The where _indextime clause keeps only what was <em>indexed</em> in the last five minutes, so each event is evaluated exactly once no matter how late it was. <strong>That one line is the difference between catching and missing delayed attacks.</strong> Naive exact windows feel correct and are a classic silent miss.</p><p>Two more knobs worth naming, because they prevent skips rather than mourn them. allow_skew randomly nudges each search&#39;s start time so five hundred detections don&#39;t all demand a burner at :00, and it shifts the data window with it, so coverage stays gap-free. schedule_window marks a search as not-time-critical, letting urgent ones jump the queue.</p><p>And realtime_schedule, which defaults to on, is a <em>freshness bet</em>: if a search falls behind, skip the missed slots and jump to the most recent window. That&#39;s right for alerting. It is wrong for anything that rolls data up over time, like the risk aggregation in section 8, where a skipped window means permanently missing data, and you want the opposite setting.</p><p><strong>The single most important number to watch in an entire SIEM is the skip ratio</strong>, precisely because it’s the only thing that reveals a failure everything else hides. Here is the query. Run it Monday morning:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/719/1*9VC2npG4Xmlqz6tpUzGHtw.png" /></figure><p>The thesis of this section, and one detection engineers learn late: <strong>coverage is a property of the scheduler, not of the rule.</strong> Your logic can be perfect. If it doesn’t run, or runs over the wrong slice, it catches nothing. Most missed attacks at well-run companies are missed right here, not in the cleverness of the detection, but in the plumbing that decides whether and when it runs.</p><p><em>Where anna’s login is now: nearly missed. The 09:05 run was skipped entirely, and the 09:10 run caught the events only because of the index-time overlap.</em></p><h4>6. Anatomy of a detection: the query is the smallest part</h4><p><strong>The question:</strong> when an engineer “writes a detection,” what are all the pieces they fill in?</p><p>Let’s open the hood on the rule hunting anna and count the parts. The surprise is that the query (the SPL that finds the pattern) is maybe twenty percent of it. The rest is the wrapper, and the wrapper is where a detection becomes good or noisy.</p><p>Think of a smart smoke detector. The <em>sensor</em> reacts to smoke. But the useful part is everything around it: is this the kitchen (expect smoke, just log it) or the server room (page someone now)? Whose zone is it? Is this the third beep in five minutes? Should it also trip the sprinklers?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*l9da7wNLhGjtTWjC.png" /><figcaption>Diagram of a Splunk detection exploded into its parts. At the centre, drawn deliberately plainly, is the query itself, the sensor that finds five failed logins followed by a success, annotated as roughly twenty percent of the detection. Feeding into it are six wrapper elements: who this is about, the entity, a user account; how bad it is, a risk score of sixty points; what a human should read, a message written in advance; which attacker move it maps to, MITRE ATT&amp;CK technique T1110; what bad thing was seen, a threat object, the attacking IP address 203.0.113.9; and whether it should ring again, a throttle that stays quiet on this user and source for an hour. The query is governed by the output type, drawn as the heaviest box on the canvas: add points quietly, do not page anyone. Two exits leave it: the path taken, an intermediate finding written to the risk ledger, and the greyed-out path not taken, a finding sent to the analyst queue.</figcaption></figure><p><strong>Diagram 7: The query sits in the middle and is the small part. The wrapper decides everything else.</strong><em>The box in the middle is the part everyone thinks a detection is. Everything around it is what turns a matching row into a decision, and the gold box at the edge is the one that matters most: this rule will not page anyone. It will add points. The greyed path shows what it chose not to do.</em></p><p>First, the sensor. This is the real thing, and it’s the “X then Y” shape from the next section:</p><pre>index=linux sourcetype=linux_secure (action=failure OR action=success)<br>    earliest=-70m@m latest=now<br>| where _indextime &gt;= relative_time(now(),&quot;-5m&quot;)<br>| sort 0 _time<br>| streamstats time_window=10m count(eval(action==&quot;failure&quot;)) as recent_fails by user<br>| where action==&quot;success&quot; AND recent_fails &gt;= 5<br>| stats max(recent_fails) as fails values(src) as src by user<br>| eval risk_message=&quot;brute-force then success for &quot;.user.&quot; (&quot;.fails.&quot; fails) from &quot;.src</pre><p>Line by line: line 3 is the late-data overlap from section 5. Line 4 forces a global time ordering, which is what makes the next line meaningful. Line 5 is the whole trick: streamstats walks each user&#39;s events in time order keeping a <strong>running memory</strong>, here a rolling ten-minute count of failures. Line 6 fires the moment a success lands while that count is high: a success after five or more recent failures. Lines 7 and 8 collapse the result to one row per user and write the sentence a human will eventually read.</p><p>That’s it. That’s the famous brute-force detection.</p><p>Now the wrapper, which answers a fixed set of questions:</p><ul><li><strong>Who is this about?</strong> The <em>entity</em>, in our case the user account. Get this wrong or leave it blank and the whole downstream machine has nothing to attach risk to.</li><li><strong>How bad is it?</strong> A risk score. Sixty points.</li><li><strong>What should a human read?</strong> A message written in advance, in plain language, so the analyst isn’t staring at raw logs.</li><li><strong>What attacker move is this?</strong> A tag from the MITRE ATT&amp;CK catalogue: T1110, Brute Force, a shared taxonomy of attacker techniques that matters enormously in two sections&#39; time.</li><li><strong>What bad thing was seen?</strong> A <em>threat object</em>, separate from the victim: here, the attacking IP 203.0.113.9.</li><li><strong>Don’t re-ring:</strong> throttling. After firing for this user and source, stay quiet on that pair for an hour.</li></ul><p>And then the single most load-bearing setting in the entire machine: <strong>the output type.</strong></p><p>This detection can either page a human directly, or quietly add points to a ledger. For our brute-force rule the answer is the second one. <em>It will not alert anyone. It will add points.</em></p><p>Plant that flag firmly, because the next two sections are the whole reason it matters. “Some failed logins then a success” is medium-precision at best; plenty of those are someone fat-fingering a password. A rule that noisy should never wake a human on its own. So it doesn’t.</p><blockquote><strong><em>Every time you make a detection page a human directly, you are personally promising it’s precise enough to be worth that human’s time.</em></strong></blockquote><p><strong>Table 2: The decoder ring. Splunk renamed most of this in ES 8; most blog posts still haven’t.</strong> <em>(→ Table 2 card, asset 08)</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/919/1*zGG8NPES3MjGS8R46yqvAw.png" /></figure><p>I’ll use the plain-English versions in prose (“the risk ledger,” “points”) and the real terms live in this table.</p><p><em>Where anna’s login is now: matched by a rule that deliberately told nobody, and wrote sixty points to a ledger instead.</em></p><h4>7. The six shapes of detection logic</h4><p><strong>The question:</strong> how many kinds of “weird” are there, really?</p><p>Detection logic isn’t infinite. In practice there are about six shapes, and once you can name them you can read almost any rule.</p><p><strong>Table 3: Six shapes cover almost all detection logic. Note that every one of them has an exit.</strong> <em>(→ Table 3 card, asset 09)</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/912/1*gX8dRmPVPC9LK3uS6r3hlA.png" /></figure><p>Shapes 1 and 2 look within one data source. Shapes 3 through 5 compare now against a baseline. Shape 6 combines sources.</p><p>Notice the pattern in that last column. <strong>Every single-source shape has a way past it.</strong> That’s not a flaw to be fixed inside the shape. It’s the reason the next section exists.</p><p>Two craft notes that separate a toy query from a production detection. First: <strong>the numbers are the detection.</strong> The SPL shape is generic; the chosen thresholds are what make it precise or noisy. Derive them from base rates: run the count over a normal week and set the line above the 99th percentile of legitimate behavior. Don’t pick them by vibes. Second: baselines can be poisoned. A patient attacker who ages in slowly, or who acts while you’re building your baseline, defeats every shape in rows 3 to 5. Lagged baselines and hold-down periods are the countermeasure.</p><blockquote><strong><em>Aside: so where’s the AI?</em></strong><em> Every SIEM vendor markets machine learning, and it’s a fair thing to go looking for in a 2026 article. The honest structural answer: statistical methods mostly live </em>inside<em> the baseline shapes above. A spike detector using a rolling z-score, or a fancier model deciding what “rare” means, is still the spike shape and the rare shape. Heavier behavioral analytics (UEBA) is typically a separate, separately-priced product tier. Entity scoring, which we’re about to meet, uses a weighted statistical blend rather than anything deep. And the newest LLM assistants sit </em>on top of<em> the risk ledger, summarizing and triaging its output, rather than replacing the rules that fill it. Deterministic detections still carry the overwhelming majority of production coverage, and anyone telling you otherwise is describing a roadmap, not a deployment.</em></blockquote><p><em>Where anna’s login is now: caught by exactly one of six shapes (the sequence) and easily evaded by an attacker patient enough to slow down.</em></p><h4>8. The scorekeeper: how a thousand mediocre rules make one good alert</h4><p>This is the summit. If you take one idea from this article, take this one.</p><p>Start at an airport. The old way to run security is to wire every scanner to its own loud alarm. Metal detector beeps: alarm. Passenger looks nervous: alarm. Someone’s sweating: alarm. Guards sprint to every beep, almost all of which are a belt buckle or a nervous flyer, and within a week the guards have learned to ignore alarms entirely. <strong>That is a traditional SIEM: one rule, one alert, and an exhausted analyst who has stopped reading.</strong></p><p>The smart way: no scanner has its own alarm. Instead, each one quietly adds points to a passenger’s file. Belt buckle, plus five. Sweating, plus ten. One-way ticket paid in cash, plus forty. Nobody is dispatched for any single signal. Only when <em>one passenger’s total</em> crosses a line does <em>one</em> guard walk over, holding the whole file, the entire story, already assembled.</p><p>This is <strong>Risk-Based Alerting</strong>, and here is the sentence to hold:</p><blockquote><strong><em>Detections stop paging people. They add risk points to whoever is involved, and only when one person or machine collects enough points does a human get alerted.</em></strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*KgkfGDOJpz34Hr3d.png" /><figcaption>Two-stage diagram of risk-based alerting. Stage one, on the left, shows rules quietly adding points with nobody being paged: a brute-force rule contributes sixty points, a rare-country rule contributes forty, and a threat-intelligence match contributes thirty, each multiplied by 1.5 for a privileged user and 1.2 for a watchlisted critical asset, giving 108, 72 and 54 respectively; hundreds of other rules write points about other entities. All feed a central risk ledger, an index literally named risk. Risk factors are applied centrally rather than inside any rule, with all additions happening before any multiplications. Stage two, on the right, shows a single watcher asking of one entity: enough points, enough rules, enough tactics? For anna the answer is yes: 234 points from three rules across two attacker tactics, producing one alert carrying the whole story. For every other entity the answer is no, and their points quietly age out.</figcaption></figure><p><strong>Diagram 8: Two stages that must never be confused. Rules add points; one watcher decides when enough is enough.</strong><em>Everything on the left happens all day and pages nobody. Follow anna’s three red arrows into the ledger, watch the risk factors rescale them centrally rather than inside any rule, and then cross to the right, where a single watcher, not any individual detection, decides that this particular entity’s story has gone far enough.</em></p><p>The machinery is two stages, and keeping them apart in your head is the whole game.</p><p><strong>Stage one: detections write points.</strong> Each detection drops a note into a shared ledger, an index literally named risk. Each note says who it&#39;s about, how many points, and why, in a human sentence. Here is what one of anna&#39;s notes actually looks like:</p><pre>risk_object            = anna<br>risk_object_type       = user<br>risk_score             = 60          &lt;- the base, as the detection set it<br>calculated_risk_score  = 108         &lt;- after the risk factors; aggregate on THIS<br>risk_message           = &quot;5 failed then 1 successful SSH login for anna from 203.0.113.9&quot;<br>threat_object          = 203.0.113.9<br>annotations            = mitre_attack: T1110 (Brute Force)</pre><p>That two-field distinction is a real trap: risk_score is what the rule wrote, calculated_risk_score is what the machine will actually add up. Aggregate the wrong one and every threshold in your deployment is quietly wrong.</p><p>Nobody is paged for that note. Then, centrally, <strong>risk factors</strong> rescale those points based on who’s involved: a privileged user multiplies the score, a critical asset multiplies it again. The order is fixed and worth knowing: <strong>all additions happen first, then all multiplications</strong>, so a base of 40, plus 30, times 1.5 is 105, not 85. That’s how “the same act is worse on a crown-jewel server” gets encoded once, centrally, instead of copy-pasted into every rule.</p><blockquote><strong><em>Aside: the zero-point trick.</em></strong><em> You can give a detection a risk score of </em><strong><em>zero</em></strong><em>. It writes to the ledger as pure context, showing up in the story the analyst reads, without moving the needle. New engineers often “clean these up” and destroy the narrative analysts depend on.</em></blockquote><p><strong>Stage two: one watcher decides when enough is enough.</strong> A second kind of detection reads the ledger itself rather than the world. It fires when a single entity has crossed a line: enough total points, ideally from enough <em>distinct</em> rules, spanning enough <em>distinct</em> attacker tactics, inside a time window.</p><p>The distinctness is the clever part. One noisy rule firing five hundred times is still just one rule being noisy. But three <em>different</em> rules, mapping to three <em>different</em> stages of an attack, all pointing at the same entity: that’s not noise, that’s a story. The stock thresholds that ship with Splunk make this concrete: <em>score over 100 in 24 hours</em>; <em>events from three or more different sourcetypes over 3 days</em>; <em>multiple MITRE tactics observed over 7 days</em>.</p><p>Newer versions go further with a standing per-entity score, recalculated every twenty minutes over the last seven days and normalized to 0–100. It’s a weighted blend rather than a raw sum, and the reason is worth one sentence: a raw sum can be gamed by one chatty low-value rule firing five hundred times, while a blend rewards variety and severity over volume.</p><p>Now the intellectual payoff, stated flat. Each individual rule is <em>allowed</em> to be mediocre. Not encouraged. Allowed. Because the system doesn’t act on any single rule. It acts on accumulation against one entity. <strong>The alert isn’t a rule firing; the alert is the bookkeeping noticing that too many rules have fired about the same entity.</strong> That inversion does two things at once: alert volume drops by roughly an order of magnitude, and alert quality goes <em>up</em>, because every alert that survives arrives pre-assembled with its evidence.</p><p>Watch it on anna. Three mediocre signals, each worthless alone, each easily evaded in isolation. She is a privileged account (×1.5) and she is watchlisted on a critical asset (×1.2), so both factors apply to every note on her file. The brute-force-then-success rule is worth 60 at base, and <strong>108</strong> once the factors land. The rare-country rule is worth 40, and <strong>72</strong>. The threat-intel match on the source address is worth 30, and <strong>54</strong>. That’s <strong>234 points on one file, over the line of 100</strong>, and the numbers are on Diagram 8 above.</p><p>At base (60, 40, 30), not one of them crosses any line, and none of these rules would have paged anyone regardless: that was the output-type decision back in section 6. It is the factors and the accumulation <em>together</em> that condemn her: three distinct rules, across multiple attacker tactics, on one file. And anna becomes exactly one alert that reads like a sentence a human wrote:</p><blockquote>Privileged Finance admin, brute-forced from a rare country, from a known scanner IP, against a critical domain controller.</blockquote><p>That is the machine doing the one thing traditional SIEMs never could.</p><p><em>Where anna’s login is now: 234 points on one ledger entry, over the threshold, about to become the only alert anyone sees.</em></p><h4>9. Context: the same event is boring or terrifying depending on who</h4><p><strong>The question:</strong> where does “the account is privileged” and “a critical asset” actually come from?</p><p>Everything in the last section leaned on two multipliers I slipped past you. That ×1.5 and that ×1.2 have to come from somewhere, and they come from a context engine that keeps a merged phonebook of everything and everyone in the company.</p><p>Think of a hospital wristband system. Raw logs are a camera that only records barcodes: 10.2.3.4, anna. Useless alone. The context engine is the database that turns each barcode into a person: <em>that&#39;s the ICU&#39;s main monitoring server, critical priority; that&#39;s Dr. Anna, cardiac surgeon, admin access, on staff.</em></p><p>It’s built by merging the registries no single team keeps clean: the machine inventory (CMDB), the corporate directory, the HR export. Each is messy and partial. Merged, they resolve into entities with the fields that actually change a decision: is this person privileged, is this machine critical, who owns it, is anyone on a watchlist, which business unit.</p><p>The mechanics are worth two specifics, because both bite people. Machines merge when any of <strong>IP, MAC, NT host, or DNS name</strong> match; people merge on the <strong>identity</strong> field, whose pipe-delimited values ( anna|<a href="https://containers-itself-handbags-solutions.trycloudflare.com/cdn-cgi/l/email-protection">[email protected]</a>|ANNA) all resolve to one person. And when two source rows conflict on a field like priority, <strong>the row listed first wins</strong>, which makes the <em>ordering of your source lists</em> a real security decision, not a formatting one.</p><p>Matching an IP works like a routing table: try hardest first. An exact host record beats a general one, and the most specific network block beats a broader one. Miss the exact record and the event still gets broad network context, which may be wrong for that specific host.</p><p>Underneath sits a genuinely hard problem that’s easy to under-rate: <strong>identity resolution.</strong> The account’s short username, its email-style form in another log, and the IP it logged in from all have to resolve to the <em>same file</em>. If they don’t, if the machine treats them as three different actors, then anna’s three risk signals scatter across three files. And the same missing identity record that failed to merge those names also failed to tell the machine she is privileged and watchlisted, so the multipliers never land either: the three files sit at their base 60, 40, and 30. <strong>No merge means no factors, either.</strong> None of them crosses the threshold, and the alarm never trips.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*mmbpdMET0G6cgKwm.png" /><figcaption>Two-panel diagram of identity resolution. In the left panel, identity resolution has failed and anna’s three risk signals are scattered across three separate files: anna with 60 points from brute force, anna@corp.com with 40 points from the rare-country rule, and ANNA with 30 points from the threat-intel match. A note explains that no merge means no risk factors either: the same missing identity record that failed to join the names also failed to mark the account privileged and watchlisted, so these are base scores only. Each sits under the threshold of 100 and stays silent, so no alert is produced: no rule failed; the bookkeeping did. In the right panel, identity resolution works: all three name-forms resolve to one entity, anna, the factors land, and her scores become 108 plus 72 plus 54, summing to 234 from three rules across two attacker tactics, crossing the line of 100 and producing one alert.</figcaption></figure><p><strong>Diagram 9: The same three signals, filed under three names or one. Only one of these pages anybody.</strong><em>Nothing differs between the two panels except the bookkeeping. Same attacker, same three detections, same thresholds. The only variable is whether the machine knows that three name-forms are one person. On the left it doesn’t, so the signals never pool and the multipliers that depend on knowing who she is never land; on the right it does, and she pages someone. The left panel produces no error message to tell you which one you’re running.</em><strong>The attack becomes invisible not because any rule failed, but because the bookkeeping filed the evidence under three names.</strong></p><p>There’s a matching failure in the other direction: two genuinely different machines that happen to share an internal IP in two offices must <em>not</em> be merged, or the machine invents risk that isn’t there and cries wolf. So the phonebook also tracks which <strong>zone</strong> an entity lives in, to keep separate things separate.</p><p>And it’s worth seeing how much of the last section’s arithmetic comes from here rather than from any detection. anna’s single brute-force event (base 60, the same inert 60 sitting in the left panel above) becomes 60 × 1.5 × 1.2 = 108 purely because of who she is and what she touched. <strong>Context alone pushes that one event over the threshold, before the other two signals even land.</strong> Same detection, same attacker, entirely different outcome.</p><blockquote><strong><em>Aside: the leaver problem.</em></strong><em> An identity’s end date should retire it. If the HR export lags, a departed employee’s account still looks perfectly legitimate to the whole machine. Watch identity freshness the way you watch skip ratio: both are silent, and both are coverage.</em></blockquote><p>Context is what turns a shrug on a test box into an emergency on a domain controller, and it’s the difference between a page and silence.</p><p><em>Where anna’s login is now: decorated as a privileged, watchlisted Finance admin hitting a critical domain controller, and worth 108 points on its own.</em></p><h3>10. When to attach a fact: the three checkpoints</h3><p><strong>The question:</strong> every fact you attach to an event costs something. When you attach it decides what it costs and what it’s worth.</p><p>There are exactly three moments, and choosing well is an underrated craft.</p><p><strong>Table 4: Three moments to attach a fact, and what each one costs you.</strong> <em>(→ Table 4 card, asset 11)</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/758/1*F-aXxHGSZ72nUfij5JwOLw.png" /></figure><p>The decision rule fits on one line: <strong>how fast the fact changes decides where it lives.</strong> Stable and needed everywhere, bake it in. Volatile, look it up. Expensive and rare, wait for the alert.</p><p>Bake in “this user is privileged” today and next year’s logs will cheerfully lie to you about someone who changed roles. Conversely, run a live reputation query on every login and you’ll melt the ingest pipeline and the budget together.</p><p>The plumbing behind the middle option deserves one honest look, because it bites people. Remember from section 3 that the knowledge bundle ships <em>down to every worker</em> with the question. A small reference table is nothing. But one oversized table gets copied to every machine on every search, and can quietly slow <em>every</em> query in the building.</p><p>So the tables come in two flavors: a simple file, copied everywhere, fine when small and static; and a central live database, queried in place, right when the table is large or changes constantly. Choosing wrong is a self-inflicted, cluster-wide slowdown that looks like a mystery for weeks.</p><p><em>Where anna’s login is now: carrying a country baked in at ingest, a privilege level looked up live, and (once it alerts) a reputation check that would have been ruinous to run on every login.</em></p><h3>11. Threat intel: the list of known bad</h3><p>Threat intelligence sounds like a dark art. Demystified in one sentence: it’s a subscription to lists of addresses, domains, and file fingerprints that someone else already caught misbehaving. That’s it. Known bad things, compiled by other people, delivered on a schedule.</p><p>The pipeline is five verbs. <strong>Pull</strong> the feeds (TAXII for delivery, STIX and OpenIOC for the labels, plain CSV otherwise) typically every twelve hours. <strong>Normalize</strong> them into per-type collections, IPs here and file hashes there, each source carrying a <strong>weight</strong> so a match on a high-confidence feed adds more risk than one on a noisy free feed. <strong>Prepare</strong> deduplicated match tables. <strong>Match</strong> them continuously against the shared-vocabulary fields of incoming events. And <strong>write</strong> every match as, say it one more time, points on the entity’s file.</p><p>The matching step only works <em>because</em> of the CIM dictionary from section 4: the feeds are compared against src and file_hash, so every normalized source is checked at once, for free. The corollary from earlier returns with teeth: a source you never normalized is never checked against any threat feed, ever.</p><p>That last verb is the whole point, and it’s why threat intel composes so cleanly with everything else. A match is not a separate alarm system with its own screen and its own fatigue. It’s one more voice feeding the same ledger as the brute-force rule and the rare-country rule. When 203.0.113.9 turns out to sit on a known-scanner feed, that doesn&#39;t fire its own page. It adds anna&#39;s third signal to the same file, and <em>that</em> is what pushes the total over the threshold into a single undeniable story.</p><p><strong>Threat intel didn’t sound the alarm. It made the alarm’s story impossible to argue with.</strong></p><p>Two operational truths to end on, because this is where demystifying earns its keep. First: when a company says “we integrated threat intelligence,” it almost always means “we match IPs and hashes” (the easy indicator types) while the harder ones quietly go unmatched. The empty collections are silent blind spots. Second: indicators age. An address that was a malware server last year might be an innocent recycled cloud address today. A dead indicator left on a live list is a permanent false-positive machine, generating fake matches forever until someone prunes it. <strong>The feeds are only as good as their freshness, and freshness is nobody’s favorite chore.</strong></p><p><em>Where anna’s login is now: matched against a known-scanner feed, contributing a third independent signal to the same ledger entry.</em></p><h3>12. Keeping the machine honest: detections as code</h3><p>One last subsystem, quiet and easy to skip, and it exists because of a failure mode we’ve now seen three times.</p><p>Rules rot. Log formats drift. A vendor renames a field in an update, and a detection that quietly depended on that field stops catching anything: the scheduler section’s ghost, back again. No errors. The rule just goes dark, and in a badly run shop it can stay dark for eight months before anyone notices, usually because of an incident it should have caught.</p><p>The mature answer is to stop treating detections as things you click together in a GUI and start treating them as code. Each detection lives as a versioned text file in git, reviewed like software by a second engineer, with its history intact so you can answer “who made this rule less sensitive, and when, and why” months later.</p><p>And here’s the part that actually kills silent rot: <strong>each detection ships with a recording of a real attack, and an automated test replays that recording and confirms the rule still fires on it.</strong> A rule that stops catching its own attack fails a build. The failure becomes a red mark on a screen at nine in the morning instead of a blind spot discovered during a breach.</p><p>That single mechanism, a detection that proves itself automatically and forever, is the difference between a detection program and a pile of forgotten saved searches. Splunk’s own public content library is built exactly this way, in the open, and the toolchain is public too: <strong>ESCU</strong> for the content, <strong>contentctl</strong> for the build and test pipeline, and <strong>Sigma</strong> for rules meant to move between SIEMs.</p><blockquote><strong><em>Next in this series:</em></strong><em> </em>How detections are tested like software<em>: the YAML schema, the compiler, replaying recorded attacks in CI, and what breaks when you convert portable rules between SIEMs. This section is the trailer; that article is the film.</em></blockquote><p><em>Where anna’s login is now: caught by a rule that can prove, on every commit, that it still catches it.</em></p><h3>The close</h3><h4>13. The full run: one log line to one alert, and one human</h4><p>Let’s run the whole thing once, fast, and watch anna’s logins travel through every gear we’ve named.</p><p>A checkpointed agent ships the raw SSH lines; they are <strong>stored untouched</strong> in an immutable, time-sliced bucket, made queryable by an <strong>overlay of meaning applied at read time</strong>, normalized into a <strong>shared vocabulary</strong>, folded into a <strong>pre-computed summary</strong>. The <strong>scheduler</strong> skipped one run outright and caught the events on the next only thanks to a <strong>deliberate index-time overlap</strong>.</p><p>The <strong>detection</strong> spots the failures-then-success sequence and <strong>pages nobody</strong>. It writes sixty points to a ledger. The <strong>context engine</strong> multiplies them to 108, because the account is privileged and the machine critical. A <strong>rare-country rule</strong> adds a second signal and a <strong>threat-intel match</strong> a third, all landing on one file because <strong>identity resolution</strong> decided they’re one account. A <strong>watcher</strong> sees the pile cross the line (enough points, enough rules, enough tactics) and emits <strong>one alert</strong> carrying the entire narrative.</p><p>And then, finally, the part the machine hands off.</p><blockquote><strong>One log line. A dozen subsystems. One alert. One decision.</strong></blockquote><p>And now you know every gear that turned between them.</p><p>Which lets me close the loop on the three jobs from the opening. <strong>Detection</strong> was this whole article. <strong>Forensics</strong> is the same storage half, minus the timer: when that analyst pivots from the alert into anna’s last ninety days, they’re running ad-hoc searches over the exact same buckets and the exact same word indexes the detections scan, which is why the storage design mattered so much. And <strong>compliance</strong> is the frozen tier: the retention policy in the config <em>is</em> the promise made to the auditor. Same machine, three questions.</p><blockquote>The machine’s real achievement isn’t any single component: not the funnel, not the overlay, not even the scorekeeper. It’s a change in the question. <strong>The industry spent twenty years asking “is this rule right?” and drowning in the answer. Then it learned to ask something better: “is this entity’s story concerning?”</strong></blockquote><p>Every mediocre rule, every stale feed, every imperfect signal is allowed to be wrong, because the machine no longer bets on any one of them. It bets on the accumulation.</p><h4>14. The same machine, four name tags</h4><p>I said at the top that the mechanics are roughly the same in any SIEM. Here’s the receipt. Every product below solves the same problems in the same order. They just named the parts differently.</p><p><strong>Table 5: Every SIEM solves the same problems in the same order. They just named the parts differently.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/937/1*OiYHmpRaOfpUSvGWVY7GXw.png" /></figure><blockquote><strong><em>Aside: read this table as functional analogy, not exact equivalence.</em></strong><em> The Splunk column is verified against current documentation; the other three map </em>the job each part does in the machine<em>, and the details differ in ways that matter once you’re actually operating one. Sentinel’s KQL and Elastic’s KQL are different languages that share an acronym, which is exactly the kind of trap this table exists to warn you about.</em></blockquote><p>The value of knowing this is that everything in this article transfers. Learn the machine once and you’re reading a different dialect, not a different language.</p><h3>15. Takeaways</h3><ol><li><strong>A SIEM is storage plus detection.</strong> Storage is solved and elegant. Detection is unsolved and is where every interesting failure lives.</li><li><strong>Search is elimination, not reading.</strong> Time range, then bloom filter, then word index, then (only for the survivors) actual bytes. Every performance tip you’ll ever hear is “feed the funnel.”</li><li><strong>Data is immutable; meaning is editable.</strong> Storing raw and interpreting late is what lets you re-read all of history through a new understanding instead of re-ingesting it.</li><li><strong>Coverage is a property of the scheduler, not the rule.</strong> A skipped run and a clean run look identical from the outside. Watch your skip ratio; it’s the only number that reveals a failure everything else hides.</li><li><strong>The query is about 20% of a detection.</strong> The wrapper (entity, score, message, technique, and above all the output type) is what makes it useful or noisy.</li><li><strong>Individual rules are allowed to be mediocre.</strong> Risk-based alerting inverts the question: the alert isn’t a rule firing, it’s the bookkeeping noticing that too many rules fired about the same entity.</li><li><strong>Every failure in this machine is silent.</strong> Skipped searches, misparsed timestamps, truncated joins, stale indicators, un-normalized sources, rotted rules, unresolved identities. None of them produce an error. All of them produce a blind spot. <strong>Building a SIEM you can trust is mostly the work of making its silences audible.</strong></li></ol><h3>also, what this article didn’t cover</h3><p>Deliberate omissions, each worth its own piece: clustering and high-availability internals; SOAR playbooks in depth; UEBA products; federated and cross-cluster search; upstream ingest processing (Edge Processor, Cribl, and friends) that reshapes data before it ever reaches the SIEM; dashboarding and reporting; and the economics of tiering in real detail.</p><p><strong>Thanks for reading : D</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=127dd58c4e27" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[First Principle Thinking While Building a Secure Product — Part 1]]></title>
            <link>https://medium.com/@juhiechandra/first-principle-thinking-while-building-a-secure-product-part-1-552f1a16247b?source=rss-3cf168f0a9c1------2</link>
            <guid isPermaLink="false">https://medium.com/p/552f1a16247b</guid>
            <category><![CDATA[first-principles]]></category>
            <category><![CDATA[database]]></category>
            <category><![CDATA[product-development]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[database-security]]></category>
            <dc:creator><![CDATA[Juhie Chandra]]></dc:creator>
            <pubDate>Fri, 19 Sep 2025 19:57:14 GMT</pubDate>
            <atom:updated>2025-09-19T21:05:39.129Z</atom:updated>
            <content:encoded><![CDATA[<h3>First Principles Thinking While Building a Secure Product — Part 1</h3><h3>Table of Contents</h3><ol><li><strong>Is “Making It Work” enough?</strong><br><em>Understanding Trust Boundaries</em></li><li><strong>Step 1: Environment Setup and Separation of Concerns:</strong></li><li><strong>Step 2: Database Design — The Foundation:</strong></li><li><strong>The CIA Foundation</strong></li><li><strong>Deep Dive into Database Security:</strong><em><br></em><strong>5.1 Authentication</strong><em><br></em><strong>5.2 Authorization</strong><em><br></em><strong>5.3 Database Integrity</strong><em><br></em><strong>5.4 Availability and Recovery</strong></li><li><strong>Bringing It All Together</strong></li></ol><p>If I had to build a product from scratch, how would I <strong>design it to be secure</strong> from the ground up?<br> This blog series is my attempt to answer that. Let&#39;s take a basic example of a content generation platform. Along the way, we’ll layer in security at every step, from the core engine to the backend, frontend, and database.</p><p>The major components of the application:</p><ul><li>The core generation engine — video, audio, etc.</li><li>Backend</li><li>Frontend</li><li>Database</li></ul><h3>1: Is “Making It Work” enough?</h3><p>Most of us start with “making it work” — maybe the first MVP. But now let’s assume you have started gaining traction and things can go wrong:</p><ul><li>Users will try to hack around your systems</li><li>Your own code will have many bugs</li><li>Network requests can be intercepted (someone making direct requests to your backend APIs)</li><li>Servers can be breached</li></ul><p>This is where thinking about trust boundaries becomes critical.</p><h4>Understanding Trust Boundaries</h4><blockquote>When a user uploads content for course creation, that data goes from their browser (<strong>untrusted</strong>) to your backend (<strong>semi-trusted</strong>) to your video engine (<strong>trusted</strong>). Each crossing is a potential attack point.</blockquote><p>Think of your system like a series of checkpoints. Each layer catches what the previous one missed:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_-Uvw42CQunvCZ4D2unI_A.png" /><figcaption>you’re crossing more layers thank you think</figcaption></figure><p>Now, let’s start from the beginning and build our way up so that our trust boundaries won’t be violated.</p><h3>2: Environment Setup and Separation of Concerns</h3><p>Most developers create one big repository with everything mixed. But think about what happens when you need to give access to a contractor, or when you want to deploy different parts separately.</p><p>You should consider separate repositories for:</p><ul><li>Frontend code</li><li>Backend API</li><li>Video generation engine</li><li>Infrastructure configuration</li><li>Documentation and policies</li></ul><h4>Environment Strategy</h4><ul><li><strong>Development</strong>: Where you experiment and break things</li><li><strong>Staging</strong>: Where you test things that might go to production</li><li><strong>Production</strong>: Where real users and real money live</li></ul><p>For simplicity, let’s work with staging and production environments. The key principle: they should be completely separate with different databases, servers, and configurations.</p><h3>3: Database Design — The Foundation</h3><p>Here’s where most developers go wrong. They create one user table and dump everything there. But let’s think about what kind of data we’re actually storing.</p><h4>Data Classification</h4><ol><li><strong>Public data</strong>: Video titles, descriptions, public profiles</li><li><strong>User data</strong>: Email addresses, learning progress, preferences</li><li><strong>Sensitive data</strong>: Payment information, video processing queues</li><li><strong>Secret data</strong>: API keys, encryption keys, admin access logs</li></ol><p>Each type has different access patterns and protection requirements:</p><ul><li>Public data might be cached and served from CDNs</li><li>User data requires authentication</li><li>Sensitive data needs encryption</li></ul><h4>The Problem with Monolithic Tables</h4><p>Most developers dump everything into one giant user table. Here’s what that looks like versus the secure approach:</p><p><strong>Poor Design: Monolithic Table:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/399/1*zYhRHE0i8PMzVweiMu1-4g.png" /></figure><p><strong>Poor Design: No Security Separation:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/687/1*_FpRkPVPG_ZaWzs26ulSBg.png" /></figure><p>(Tables are fairly visible in the above diagrams)</p><p><strong>Secure Design: Separated by Purpose:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/678/1*pTUj6dFRn81mfBQ1Wfvvvw.png" /></figure><p><strong>users</strong> (Authentication only)</p><pre>├── id (PK)<br>├── email<br>├── password_hash<br>├── name<br>├── role_id (FK)<br>├── created_at<br>├── is_active</pre><p><strong>user_roles</strong> (Role definitions)</p><pre>├── id (PK)<br>├── role_name<br>├── description</pre><p><strong>subscription_plans</strong> (Plan definitions)</p><pre>├── id (PK)<br>├── plan_name<br>├── price<br>├── features (JSON)<br>├── max_uploads_per_month</pre><p><strong>user_subscriptions</strong> (User billing)</p><pre>├── id (PK)<br>├── user_id (FK)<br>├── plan_id (FK)<br>├── start_date<br>├── end_date<br>├── is_active<br>├── RLS ENABLED</pre><p><strong>uploads</strong> (File management)</p><pre>├── id (PK)<br>├── user_id (FK)<br>├── filename<br>├── file_path<br>├── file_size<br>├── upload_date<br>├── is_private<br>├── RLS ENABLED</pre><p><strong>generated_content</strong> (Content output)</p><pre>├── id (PK)<br>├── user_id (FK)<br>├── upload_id (FK)<br>├── content_type<br>├── file_path<br>├── generation_params (JSON)<br>├── created_date<br>├── RLS ENABLED</pre><p><strong>Why This Matters: Split by Access Patterns</strong></p><p><strong>Authentication</strong> only needs email and password hash. <br><strong>User roles</strong> define what users can do<br><strong>Subscription plans</strong> store available features and limits. <br><strong>User subscriptions</strong> track what each user has paid for. <br><strong>Uploads</strong> handle file storage with privacy control.<br><strong>Generated content</strong> manages AI-created output</p><p>By splitting these into different tables, we can define different security rules. Your authentication service only gets access to login credentials. Your billing service only sees payment data.</p><p><strong>Real-World Impact: What Actually Happens</strong></p><p><strong>File Access Scenario:</strong></p><ul><li><strong>Poor Design:</strong> xyz user runs SELECT * FROM uploads_simple and sees all 50,000 files from all users</li><li><strong>Secure Design:</strong> xyz user runs SELECT * FROM uploads WHERE user_id = xyz_id and sees only his 23 files (RLS automatically filters. RLS is covered later in the blog.)</li></ul><p><strong>Content Generation:</strong></p><ul><li><strong>Poor Design:</strong> User A can accidentally see User B’s private files and generation settings</li><li><strong>Secure Design:</strong> User A only sees her own content. Even if there’s a bug in the app, she can’t access others’ data</li></ul><p><strong>Subscription Privacy:</strong></p><ul><li><strong>Poor Design:</strong> Anyone can see who has premium subscriptions, payment history, and pricing details</li><li><strong>Secure Design:</strong> Users only see their own subscription. Admins see what they need for support</li></ul><p><strong>Role-Based Access:</strong></p><ul><li><strong>Poor Design:</strong> The Role is just a text field that can be changed easily</li><li><strong>Secure Design:</strong> Roles are defined in a separate table with clear permissions, linked by a foreign key.</li></ul><h3>4: The CIA Foundation</h3><p>Before diving into technical details, let’s establish the framework that should guide every security decision: the CIA model — Confidentiality, Integrity, Accountability (extra one here), and Availability.</p><h4>Confidentiality</h4><p>Ensures your sensitive data stays private. Think of customer information, financial records, or that debug log you forgot to delete.</p><h4>Integrity</h4><p>Guarantees your data hasn’t been tampered with. When someone updates a bank balance, you need absolute certainty that it was authorized and accurate.</p><h4>Accountability</h4><p>Means you can track who did what and when.</p><h4>Availability</h4><p>Ensures your database is accessible when people need it. The most secure database in the world is useless if no one can reach it.</p><h3>5: Deep Dive into Database Security</h3><h4>Database Hosting and Network Security</h4><p>Before we dive into authentication and permissions, let’s talk about where your database lives and how it connects to the world. As developers, we spin up a database and call it a day :)</p><p><strong>Isolating Your Database</strong></p><p>Your database should be treated like a VIP in witness protection.</p><p><strong>Network Isolation Options:</strong></p><ul><li><strong>Best</strong>: Disable network access entirely, use local socket files or named pipes only</li><li><strong>Good</strong>: Configure the database to only bind on localhost (127.0.0.1). But this isn’t always practical for distributed systems.</li><li><strong>Acceptable</strong>: Restrict network port access with firewall rules to specific hosts</li></ul><pre>Bad:  Internet → Your App → Database (exposed on 0.0.0.0:5432)<br>Good: Internet → Your App → Database (localhost only, socket connection)</pre><p>Think about it: if someone breaks into your web server, do you really want them to have direct access to your database too?</p><p><strong>Transport Layer Protection</strong></p><p>Here’s where most people mess up. Default database configurations are like sending postcards: everything’s readable by anyone who intercepts the mail.</p><p><strong>The Problem</strong>: Most databases start with unencrypted connections. Even if the login is encrypted, all your actual data flows in plain text. Your customer’s credit card numbers, personal messages, everything.</p><p><strong>The Solution:</strong></p><ul><li>Force encrypted connections only (reject any unencrypted attempts)</li><li>Install proper TLS certificates (not self-signed certificates)</li><li>Use modern encryption: TLSv1.2+ with AES-GCM</li></ul><p><strong>Secure Credential Storage</strong></p><p>Never, ever put database passwords in your source code. Not even in the comments. Not even “temporarily.”</p><p><strong>Where credentials should live:</strong></p><ul><li>Configuration files outside the web root</li><li>Environment variables (better)</li><li>Dedicated secret management systems (best)</li><li>Hardware security modules (enterprise, if u happen to read this blog, well)</li></ul><h4>5.1 Authentication: Proving You Are Who You Say You Are</h4><p>Authentication is your first line of defense — verifying identity before anyone gets near your data.</p><p><strong>Database Account Security</strong></p><p>Your database should never allow anonymous connections, even from localhost. Every connection needs to prove who it is.</p><p><strong>Database Account Best Practices:</strong></p><ul><li>Never use default accounts: No root, sa, or admin for applications</li><li>One account per service: Your web app, background jobs, and analytics should each have separate accounts ( might sound overkill for now )</li><li>Strong, unique passwords: Use password managers, not “password123”</li><li>Regular account reviews: Remove accounts when services are decommissioned</li></ul><h4>5.2 Authorization: Deciding What You Can Actually Do</h4><p>Authentication gets you through the door. Authorization decides which rooms you can enter and what you can touch once inside.</p><p><strong>The Principle of Least Privilege</strong></p><p>This is security gospel: give users the minimum access they need to do their job, nothing more. Your intern doesn’t need admin access to the customer database. Your marketing team doesn’t need financial projections.</p><p><strong>Database Permission Levels (Most Restrictive First):</strong></p><ol><li>Column-level: User can only see specific columns</li><li>Row-level: User can only see their own data</li><li>Table-level: The User can access specific tables only</li><li>Database-level: The User can access specific databases only</li><li>Server-level: User can connect from specific hosts only</li></ol><p><strong>What NOT to do:</strong></p><ul><li>Don’t use database owner accounts for applications</li><li>Don’t grant admin rights to application accounts</li><li>Don’t use database links unless absolutely necessary</li><li>Don’t allow connections from any host (use specific IPs/hostnames)</li></ul><h4>The Three Security Pillars in Action</h4><p>Here’s how these principles work in your database:</p><p><strong>Row-Level Security (RLS):</strong></p><ul><li>What it does: Automatically filters data based on who’s asking</li><li>Real impact: Users physically cannot see data they don’t own, even if your app has bugs</li><li>Example: B’s query automatically becomes SELECT * FROM uploads WHERE user_id = b_id</li></ul><p><strong>Role-Based Access Control (RBAC):</strong></p><ul><li>What it does: Different permissions for different user types</li><li>Real impact: Regular users can’t delete others’ content, admins can access support data</li><li>Example: Premium users get advanced features, free users have limits</li></ul><p><strong>Data Integrity Checks:</strong></p><ul><li>What it does: Ensures data makes sense and relationships are valid</li><li>Real impact: Can’t create content without a valid user, can’t have orphaned subscriptions</li><li>Example: Foreign keys prevent creating content for non-existent users</li></ul><p><strong>Making Authorization Dynamic</strong></p><p>Modern systems don’t just check permissions once. They continuously evaluate access based on context: location, time, device, and behavior patterns.</p><p><strong>Encryption and Hashing: Protecting Data at Rest</strong></p><p>You have two main tools: encryption and hashing, and they serve different purposes.</p><p><strong>When to Encrypt vs Hash</strong></p><p><strong>Encrypt</strong> data you need to read back later — like storing a user’s address or credit card information. You can decrypt it when necessary.</p><p><strong>Hash</strong> data you only need to verify — like passwords. You never need to see the original password again; you just need to confirm someone entered the right one.</p><p><strong>Password Hashing</strong></p><p>Never, ever store passwords in plain text. Here’s a suitable approach:</p><ul><li>Use proper algorithms: Argon2id is the gold standard in 2025, bcrypt works for legacy systems</li><li>Salt everything: Add random data to each password before hashing</li><li>Make it slow: Good hashing algorithms are intentionally resource-intensive</li></ul><p>Let&#39;s say even if two users have the same password, their stored hashes will be completely different.</p><pre>User Password + Unique Salt → Hash Algorithm → Stored Hash<br>&quot;password123&quot; + &quot;xyz789&quot; → Argon2id → &quot;$argon2id$v=19$m=...&quot;</pre><h4>5.3 Database Integrity: Keeping Data Trustworthy</h4><p>Integrity ensures your data remains accurate and unmodified by unauthorized parties. This is where SQL injection attacks try to do their damage.</p><p><strong>Preventing SQL Injection</strong></p><p>The golden rule: never trust user input.</p><ul><li>Use parameterized queries: Let your database handle the sanitization</li><li>Validate inputs: Check data types, lengths, and formats before processing</li></ul><p><strong>Maintaining Data Consistency</strong></p><p>Your database should enforce business rules automatically:</p><ul><li>Foreign key constraints prevent orphaned records</li><li>Check constraints ensure data falls within valid ranges</li></ul><h4>5.4 Availability: Let&#39;s talk about backups</h4><p>The most secure database is worthless if it’s down. Availability means planning for failures before they happen.</p><p><strong>Building Resilient Systems</strong></p><ul><li><strong>Redundancy</strong>: Multiple servers, multiple locations</li><li><strong>Load balancing</strong>: Distribute requests across healthy servers</li><li><strong>Regular backups</strong>: if feasible :)</li></ul><p><strong>Recovery Planning: if you want to go a step ahead</strong></p><p>When (not if) something goes wrong, you need a plan:</p><ul><li><strong>Recovery Time Objective (RTO)</strong>: How long can you be down?</li><li><strong>Recovery Point Objective (RPO)</strong>: How much data can you afford to lose?</li><li><strong>Incident response</strong>: Who does what when everything’s on fire?</li></ul><h3>6: Bringing It All Together</h3><p>Let’s see how all these pieces fit together in a real system:</p><pre>Frontend (React/Vue) <br>    ↓ HTTPS<br>Load Balancer <br>    ↓ Internal Network<br>API Gateway <br>    ↓ Service Mesh<br>Microservices <br>    ↓ Encrypted Connections<br>Database Cluster </pre><p>The goal is to reach the end where our trust boundaries won’t be violated at any layer of the application.</p><p>Covering other areas in my next blogs.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=552f1a16247b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Exploiting LLM Excessive Agency: Presentated at BSides Bangalore]]></title>
            <link>https://medium.com/@juhiechandra/exploiting-llm-excessive-agency-lessons-from-bsides-bangalore-0fd8586a57f3?source=rss-3cf168f0a9c1------2</link>
            <guid isPermaLink="false">https://medium.com/p/0fd8586a57f3</guid>
            <category><![CDATA[secure-coding]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[bsides]]></category>
            <dc:creator><![CDATA[Juhie Chandra]]></dc:creator>
            <pubDate>Sun, 08 Jun 2025 16:04:36 GMT</pubDate>
            <atom:updated>2025-06-08T16:34:54.729Z</atom:updated>
            <content:encoded><![CDATA[<p><em>A practical demonstration of OWASP LLM06:2025 vulnerability and its mitigation</em></p><h3>About BSides Bangalore</h3><p>BSides represents the grassroots spirit of the security community — conferences built by and for security professionals who want to share knowledge without barriers. The BSides Bangalore quarterly meetup continues this tradition, bringing together local security practitioners to explore emerging threats and share practical insights.</p><p>In March 2025, we presented a live demonstration of one of the most critical vulnerabilities in LLM applications: excessive agency. This wasn’t a theoretical discussion about AI risks, but a hands-on exploitation showing exactly how LLM applications can be compromised and, more importantly, how to fix them.</p><h3>The Growing Threat of Excessive Agency</h3><p>As organizations rapidly integrate Large Language Models into their applications, they’re often overlooking fundamental security principles. The OWASP Top 10 for LLM Applications 2025 identifies <strong>“LLM06: Excessive Agency” </strong>as a critical vulnerability that’s becoming increasingly common in production systems.</p><p>This presentation focused exclusively on demonstrating this vulnerability through a realistic scenario, showing both the exploitation and the defense. The goal was simple: help security professionals understand not just what excessive agency is, but how it manifests in real applications and how to prevent it.</p><h3>Visualizing the Problem</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9LtiAPyNOgozeIRxx7OaKA.png" /><figcaption>Explaining Tool Calling in Chatbot</figcaption></figure><p><strong>The attack flow is straightforward ( for example ) :</strong></p><ol><li>User initiates conversation with LLM-powered chatbot</li><li>User provides false information about their subscription</li><li>User requests refund based on false premise</li><li>LLM processes natural language request</li><li>LLM directly calls refund API without validation</li><li>Financial transaction is executed without human approval</li><li>Unauthorized refund is completed ( for eg. )</li></ol><p>Each step in this flow represents a point where proper security controls could intervene, but in systems with excessive agency, the LLM is trusted to make autonomous decisions about sensitive operations.</p><p><strong>This scenario illustrates the core problem:</strong> the LLM has been granted autonomous control over sensitive financial operations without proper safeguards. It can make decisions that should require human oversight or additional validation.</p><h3>Live Demonstration: Exploiting the Vulnerability</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4Hy6DVIKQb32eWcPPuhVHQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cFVAKd7gCwL6GUz6dNl1Yg.png" /><figcaption>Demo — Tool Calling Chatbot</figcaption></figure><p>We built a simple chatbot for our BSides demo. It had two versions: one without security checks (vulnerable) and one with checks (secure). This showed how the attack works and how to prevent it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SVfZ5SqeVOreyLkykLXvIA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9TJCZMH_VyZKTzRqxpRlYw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JrgNFBGlh3CYGJ3y6GoNHA.png" /><figcaption><strong>“Excessive agency done” — the successful exploitation</strong></figcaption></figure><p>The demo showed the vulnerability clearly. Within minutes, we got the chatbot to perform unauthorized actions through normal conversation. No complex techniques were needed.</p><p>The attack used simple conversation. The chatbot trusted user input and made decisions about sensitive operations without verifying claims or requiring approval.</p><p>The core issue: the chatbot operated without proper validation checks.</p><h3>The Solution in Action</h3><p>After demonstrating the vulnerability, we showed how proper security controls can prevent excessive agency while maintaining the LLM’s functionality.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*T-kW32nNU7NHNI7HTDjg-g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ezN-1ApddQ4aMrvCOfTaXQ.png" /></figure><p>The fixed version of the application implemented several key security mechanisms:</p><ul><li>Database-level validation before executing sensitive operations</li><li>Proper error handling when validation fails</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UZ4f8kL_rmHJGOsiKm-afw.png" /><figcaption><strong>Screenshot showing “Fix applied” with terminal logs</strong></figcaption></figure><p>The terminal logs from the secure implementation told a different story. When the same attack was attempted, the system properly validated the user’s claims against the database, detected the discrepancy, and required additional verification before proceeding. The LLM was no longer able to make autonomous decisions about sensitive operations.</p><p>This wasn’t about limiting the LLM’s capabilities — it was about implementing proper security controls around those capabilities. The chatbot could still assist users, answer questions, and even help with legitimate refund requests, but it could no longer be manipulated into unauthorized actions.</p><h3>Implementation Details: The Security Check</h3><p>The core of our mitigation centered around a fundamental principle that emerged from our research: “Over reliance on AI without putting checks at database level is one of the prominent reasons for excessive agency.”</p><p>The security implementation involved several key components:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CT0bEm6_FpBna0lKrg1PuQ.png" /></figure><p>The key insight was implementing validation at the database level rather than relying on the LLM to make these determinations. The LLM could still understand the user’s request and facilitate the process, but it couldn’t bypass fundamental security controls.</p><p>This approach maintained the user experience while preventing unauthorized actions. Users with legitimate requests would still receive assistance, but false claims would be caught by the validation layer.</p><p>The principle of least privilege is applied consistently — the LLM has access to the functions it needs to assist users, but it cannot bypass security controls or make unauthorized changes to critical data.</p><h3>Key Takeaways and Recommendations</h3><p>Our BSides demonstration revealed several critical insights about excessive agency in LLM applications:</p><p><strong>The Core Problem</strong>: Excessive agency isn’t just about LLMs having too many permissions — it’s about LLMs making autonomous decisions about sensitive operations without proper validation. Many organizations are implementing LLM features without considering the security implications of granting these systems decision-making authority.</p><p><strong>Database-Level Validation is Critical</strong>: The most effective mitigation we demonstrated was implementing validation at the database level. This ensures that regardless of how convincing the LLM’s reasoning might be, sensitive operations still require verification against authoritative data sources.</p><p><strong>Human Oversight for Critical Operations</strong>: While LLMs can streamline many processes, critical operations — especially those involving financial transactions, data deletion, or access control changes — should require human approval or additional verification steps.</p><p><strong>Practical Recommendations for Security Teams</strong>:</p><ul><li>Audit existing LLM implementations for excessive agency vulnerabilities</li><li>Implement database-level validation for all sensitive operations</li><li>Require human approval for high-impact actions</li><li>Apply principle of least privilege to LLM API access</li><li>Establish clear boundaries between LLM capabilities and critical system functions</li><li>Regular security testing of LLM-powered applications with realistic attack scenarios</li></ul><p><strong>For Development Teams</strong>:</p><ul><li>Design LLM integrations with security controls from the beginning</li><li>Implement proper validation layers rather than relying on LLM judgment</li><li>Create audit trails for all LLM-initiated actions</li><li>Test LLM applications with adversarial inputs and social engineering scenarios</li></ul><h3>Conclusion</h3><p>Excessive agency represents a fundamental shift in how we need to think about application security. As LLMs become more capable and integrated into critical business processes, the potential for unauthorized actions grows exponentially.</p><p><em>This article is based on the presentation “Exploiting LLM APIs — LLM06: Excessive Agency” delivered at BSides Bangalore Quarterly Meetup, March 2025, by Sanjeev Jaiswal (Security Architect, Flipkart) and Juhie Chandra (Security Engineer, Flipkart).</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0fd8586a57f3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[[nullBlr-chapter]Navigating Security Challenges in AI-Driven Applications: A Comprehensive Guide…]]></title>
            <link>https://medium.com/@juhiechandra/nullblr-chapter-navigating-security-challenges-in-ai-driven-applications-a-comprehensive-guide-be253d2c47a0?source=rss-3cf168f0a9c1------2</link>
            <guid isPermaLink="false">https://medium.com/p/be253d2c47a0</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[null]]></category>
            <category><![CDATA[ml-security]]></category>
            <category><![CDATA[ai-security]]></category>
            <category><![CDATA[aisec]]></category>
            <dc:creator><![CDATA[Juhie Chandra]]></dc:creator>
            <pubDate>Sat, 07 Jun 2025 16:46:59 GMT</pubDate>
            <atom:updated>2025-06-07T16:46:59.493Z</atom:updated>
            <content:encoded><![CDATA[<h3>[nullBlr-chapter]Navigating Security Challenges in AI-Driven Applications: A Comprehensive Guide for Modern Enterprises</h3><p>I presented at the end of last year in Null Meetups on the evolving space of AI security. This is one of the many areas I am researching and working on in my current role at Flipkart, where I serve as an SDE in the Cybersecurity department.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5E_O_0AXqNM6DCpnorLeqQ.png" /><figcaption>Grateful for the opportunity!</figcaption></figure><blockquote><a href="https://github.com/juhiechandra/Null-OWASP-23rdNov-PPT">https://github.com/juhiechandra/Null-OWASP-23rdNov-PPT</a></blockquote><h3>The AI Application Landscape: Understanding the Foundation</h3><p>Modern AI applications have evolved far beyond machine learning models. Today’s systems leverage large language models (LLMs) trained on billions of parameters, creating sophisticated applications that can generate text, images, audio, and more. These systems often incorporate advanced architectures like Retrieval Augmented Generation (RAG), multi-modal implementations, and agentic AI workflows.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LeJ3w4N3HGadeVLuz0KBCA.png" /><figcaption><em>Basic flow diagram showing how software leverages LLMs in modern applications, from user input through processing to generated output</em></figcaption></figure><p>The complexity of these systems creates a hierarchical security challenge. Unlike traditional applications with well-defined input/output boundaries, AI systems process vast amounts of unstructured data, make probabilistic decisions, and often operate with a degree of autonomy that makes traditional security controls insufficient.</p><h3>The Dual Nature of AI in Cybersecurity</h3><p>Interestingly, AI serves as both a source of security challenges and a powerful tool for addressing them. Forward-thinking security teams are already leveraging AI for enhanced protection:</p><ul><li><strong>Elastic Search AI</strong> enhances threat detection with AI-driven insights</li><li><strong>Automated KQL Query Generation</strong> accelerates security analysis</li><li><strong>AI-powered dump analysis</strong> transforms unstructured security data into actionable intelligence</li><li><strong>Multi-modal RAG solutions</strong> conduct automated architecture reviews and threat assessments</li><li><strong>AI-generated phishing simulations</strong> improve security awareness training</li></ul><p>This dual nature underscores a critical point: the organizations that successfully navigate AI security challenges will be those that embrace AI as part of their security toolkit while simultaneously protecting against AI-related threats.</p><h3>Comprehensive Risk Assessment: From Development to Deployment</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3U5X2bddiUaf8OdX_Yl7zw.png" /><figcaption><em>Comprehensive view of security risks across AI training, development, supply chain, and runtime operations</em></figcaption></figure><p>AI security risks span the entire application lifecycle, requiring a holistic approach to protection. The threat landscape can be categorized into three primary areas:</p><h3>AI Supply Chain Risks</h3><p>The foundation of AI security begins with the supply chain. Organizations must consider risks from commercial and open-source models, code libraries, and training data integrity. Model vulnerabilities, data poisoning attacks, and compromised vector database embeddings can undermine system security from the ground up.</p><h3>Development and Training Risks</h3><p>During development, teams face challenges including system prompt vulnerabilities, prompt template security, training data contamination, and sensitive data exposure. The fine-tuning process introduces additional risks, particularly when working with proprietary or sensitive datasets.</p><h3>Runtime Operational Risks</h3><p>Production AI systems face dynamic threats including prompt injection attacks, data exfiltration, denial-of-service attacks, hallucinations leading to misinformation, and unauthorized access through API integrations. These runtime risks require continuous monitoring and adaptive security measures.</p><h3>Industry Frameworks: Building on Established Standards</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nbXkqtDcECMoqLEfHSdfzw.png" /><figcaption><em>Key AI security frameworks including NIST AI RMF, OWASP Top-10 LLMs, and MITRE ATLAS</em></figcaption></figure><p>The rapidly evolving AI security landscape has prompted the development of specialized frameworks and standards. Key frameworks include:</p><p><strong>NIST AI Risk Management Framework (AI RMF)</strong> provides a structured approach to identifying, assessing, and managing AI risks across the organization. <strong>OWASP Top-10 for LLMs</strong> specifically addresses the most critical security risks in large language model applications. <strong>MITRE ATLAS</strong> offers a comprehensive knowledge base of adversarial tactics and techniques against machine learning systems.</p><p>Emerging frameworks like <strong>SAIF (Secure AI Framework)</strong> by Google and the <strong>OWASP Agentic AI</strong> guidelines address the unique challenges of autonomous AI systems. These frameworks emphasize the importance of governance, continuous monitoring, and adaptive security controls.</p><h3>Model Protection: Testing and Validation Strategies</h3><p>Protecting AI models requires proactive testing methodologies that go beyond traditional security assessments. Red-teaming approaches specifically designed for AI systems help identify vulnerabilities through simulated attacks.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vOHz5hDDS4N7jqBOTo9bxA.png" /><figcaption><em>Overview of open-source AI security testing tools and their capabilities</em></figcaption></figure><h3>Understanding Attack Vectors</h3><p><strong>Prompt Injection</strong> attacks embed hidden instructions within user inputs to bypass safety controls, while <strong>jailbreaking</strong> attempts disable safety features entirely. These attacks can operate independently or in combination, using techniques like:</p><ul><li><strong>Ignore Previous Instructions</strong> attacks that override safety prompts</li><li><strong>Strong Arm Attacks</strong> using authoritative commands like “ADMIN OVERRIDE”</li><li><strong>Base64 Encoding</strong> tricks that bypass content filters through encoding manipulation</li></ul><h3>Open-Source Security Tools</h3><p>The AI security community has developed numerous open-source tools for model testing:</p><ul><li><strong>Garak</strong> by NVIDIA provides comprehensive LLM vulnerability scanning</li><li><strong>Giskard</strong> offers automated testing for AI models</li><li><strong>Agentic LLM Vulnerability Scanner</strong> specializes in autonomous AI system testing</li><li><strong>PyRIT</strong> by Microsoft Azure provides red-teaming capabilities</li><li><strong>Prompt Fuzzer</strong> and <strong>Whistleblower</strong> offer specialized testing frameworks</li></ul><h3>Production Guardrails: Runtime Protection Strategies</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sPE0HZAtANO8I5HmJWo2oA.png" /><figcaption><em>High-level overview of AI guardrails implementation showing input/output moderation flow</em></figcaption></figure><p>Implementing effective guardrails in production environments presents unique challenges. Organizations must balance security with performance, managing latency concerns while providing comprehensive protection across multiple languages and use cases.</p><h3>Key Guardrail Challenges</h3><p>Production guardrails must address latency requirements, support vernacular languages, handle use-case-specific threats, minimize false positives, and maintain contextual understanding of data flows. These challenges require sophisticated solutions that can adapt to evolving threat patterns.</p><h3>Available Solutions</h3><p>Open-source guardrail solutions include <strong>Guardrails.ai</strong> for comprehensive input/output monitoring, <strong>NeMo Guardrails</strong> by NVIDIA for conversational AI protection, <strong>LLM-Guard</strong> for general-purpose security, and <strong>LlamaGuard-2</strong> by Meta for content moderation.</p><h3>Emerging Challenges and Future Directions</h3><p>The AI security landscape continues to evolve, presenting new challenges that require innovative solutions:</p><h3>Bias Detection and Mitigation</h3><p>AI systems can perpetuate various forms of bias, including dataset-based bias from insufficient representation, algorithmic bias from processing methods, geographical bias from location-specific training data, and contextual bias from misinterpretation. Addressing these requires comprehensive testing frameworks and ongoing monitoring.</p><h3>Advanced Threat Detection</h3><p>Organizations are developing automated testing frameworks for open-source GenAI components, implementing production-level content moderation for multi-modal systems, and creating detection mechanisms for AI-generated content across networks.</p><h3>ROI and Security Balance</h3><p>A critical challenge involves maximizing return on investment from AI implementations while maintaining robust security measures. This requires strategic planning and risk-based decision making.</p><blockquote>This article represents best practices in AI security as of early 2025. As the field evolves rapidly, organizations should stay informed about emerging threats and continuously adapt their security strategies. We now have new protocols in place, including MCP, A2A, and APM, and I will be writing an article on securing these protocols in the future.</blockquote><p><em>References:</em></p><ol><li><a href="https://www.pillar.security/resources/the-state-of-attacks-on-genai"><em>The State of Attacks on GenAl — Pillar Al Security</em></a></li><li><a href="https://www.gartner.com/en/webinar/610308/1358100"><em>Navigate Evolving Risks &amp; Security Challenges in Enterprise Al Systems — Gartner</em></a></li><li><em>Insights and Current Gaps in Open-Source LLM Vulnerability Scanners: A Comparative Analysis :<br></em><a href="https://arxiv.org/abs/2410.16527"><em> https:/arxiv.org/abs/2410.16527</em></a></li><li><a href="https://docs.nvidia.com/nemo/guardrails/index.html"><em>https://docs.nvidia.com/nemo/guardrails/index.html</em></a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=be253d2c47a0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My Six-Month Internship with Flipkart’s Infosec Team (Jan-Jul’24)]]></title>
            <link>https://medium.com/@juhiechandra/my-six-month-internship-with-flipkarts-infosec-team-jan-jul-24-cdf70413be76?source=rss-3cf168f0a9c1------2</link>
            <guid isPermaLink="false">https://medium.com/p/cdf70413be76</guid>
            <category><![CDATA[red-team]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[ai-security]]></category>
            <category><![CDATA[blue-team]]></category>
            <dc:creator><![CDATA[Juhie Chandra]]></dc:creator>
            <pubDate>Tue, 27 May 2025 20:10:41 GMT</pubDate>
            <atom:updated>2025-05-27T20:10:41.182Z</atom:updated>
            <content:encoded><![CDATA[<p>( publishing in 2025 :D )</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/749/1*lC5aXVXC1gVYP9A_ZdtHQg.png" /><figcaption>Flipkart Logo</figcaption></figure><h3>Table of Contents</h3><p>I. <strong>Starting My Internship at Flipkart</strong></p><p>II. <strong>Working on Gen-AI Security: A New and Exciting Area</strong></p><p>III. <strong>Gen-AI Engineering: Building Practical Security Solutions</strong></p><p>A. Helping the Cyber Defence Team: New Ways to Find Threats <strong>[ 2 Projects explained ]</strong></p><p>B. Improving Application Security (AppSec)</p><p>IV. <strong>Working Across Teams: DevOps &lt;-&gt; Cybersec</strong></p><p>V. <strong>What I Learned: New Skills and Knowledge</strong></p><p>A. Learning About Different Security Areas</p><p>B. Understanding Gen-AI and LLMs</p><p>C. Learning About Various Tools</p><p>D. The Importance of Collaboration</p><p>VI. <strong>Extra Activities: Volunteering and Trying New Things</strong></p><p>VII. <strong>Looking Back: A Great Start to My Career</strong></p><h3><strong>I. Starting My Internship at Flipkart</strong></h3><p>At the beginning of 2024, I started an exciting new part of my career: a six-month internship with Flipkart’s Information Security (Infosec) team. I secured this internship after rigorous interviews following Flipkart GRID 5.0, where my team and I won the hackathon in the Cybersecurity track.</p><p>I had a prior interest in Cybersecurity, having solved CTFs, OTW challenges, and actively contributed to OWASP projects during my college days. However, due to a lack of awareness at my college, I could not explore much in this field. This internship seemed like the perfect way to delve deeper into <strong>AI + Cybersecurity</strong>, where I could leverage my full-stack background <strong>(as I am now pivoting more towards AI Engineering in 2025)</strong> and my in-depth understanding of product development.</p><h3><strong>II. Working on Gen-AI Security: A New and Exciting Area</strong></h3><p>My main work focused on the new and growing area of ensuring Generative AI (Gen-AI) safety. Before I joined, Gen-AI project safety checks were initially more limited. I helped expand this work significantly. Key achievements included:</p><ul><li><strong>Organizing Past Work:</strong> I reviewed over 40 existing Gen-AI projects to understand our starting point.</li><li><strong>Planning for the Future:</strong> I contributed to a security roadmap for Gen-AI, which was even presented to senior leadership at Walmart. I also helped create standard operating procedures (SOPs) to ensure security was involved in all new Gen-AI projects from the start. I worked to make the security team more visible to other tech teams, like Machine Learning and Data Science.</li><li><strong>Active Research:</strong> I participated in “Red Teaming,” where we acted like attackers to find weaknesses, specifically testing for “prompt injection” in AI models. I researched the latest Gen-AI security tools and curated datasets using tools like Garak and Prompt-fuzzer to test for security issues specific to our company.</li><li><strong>Exploring Projects and Testing Tools:</strong> I reviewed and approved new AI developments, like the use of Llama AI models and various internal projects for customer analysis and trend spotting. I also led the testing of new security tools like Sydelabs (acquired by ProtectAI), SkyFlow, Arize (for monitoring AI models), and Nemo Guardrails (for protecting chatbots).</li></ul><h3><strong>III. Gen-AI Engineering: Building Practical Security Solutions</strong></h3><p>Beyond planning, I gained hands-on experience building security solutions using Gen-AI, working closely with the<strong> Cyber Defence (Blue Team) and Application Security (Red Team) teams.</strong></p><h4><strong>A. Helping the Cyber Defence Team: New Ways to Find Threats</strong></h4><p>My work here started with understanding the daily challenges of the Cyber Defence team and looking for ways AI could help.</p><h4><strong>A.1) The Log Analysis Project:</strong></h4><p>Any large tech company generates massive amounts of system records, or “logs,” from many different sources. The initial idea was to create a central “Data Lake” where all these logs could be collected. This would act as a form of “collective intelligence.” The vision was that team members could then ask questions in plain language, like “Show me all IP addresses that tried to do X,” and an LLM would analyze the logs to find the answer. However, building this was complex.</p><p>We discussed many challenges:</p><ul><li><strong>Data Ingestion:</strong> How to collect logs from numerous varied sources.</li><li><strong>Data Storage:</strong> Defining the technical architecture of the Data Lake.</li><li><strong>Log Parsing and Structuring:</strong> Addressing the challenge of unstructured logs, as many aren’t in a neat format. We needed to determine if we had to build a “log parser” (a tool to clean and organize logs) from scratch. I even experimented with using an LLM to convert messy, synthetic logs into a structured CSV format.</li><li><strong>Threat Detection:</strong> How to create systems that could automatically find patterns (correlation) or even predict future security incidents from the raw data.</li><li><strong>Validation:</strong> How to ensure our new system’s findings were as good as or better than existing security information tools.</li></ul><p>We also found that LLMs have limitations, especially with the huge volume of logs (sometimes 5–7 GBs of data, which could translate to hundreds of thousands of words if summarized as Indicators of Compromise). An LLM often has a “token limit,” meaning it can only process a certain amount of text at once. During a Proof of Concept (POC) using an internal GPT model with real log data (from Active Directory, Firewalls, and a log collection service), we saw that the small processing window was a challenge. The model also sometimes produced incorrect information (“hallucinations”), and fine-tuning open-source LLMs for our specific needs was difficult due to infrastructure and security concerns. This led to a shift in thinking. Instead of relying on LLMs to analyze all raw logs directly, we considered:</p><p><strong>Using an open-source SIEM or log management system (like an ELK Stack) and then adding an LLM “orchestration and chat layer” on top. This means the LLM would help users interact with the data, rather than processing it all itself.</strong></p><p><strong>Focusing the LLM on smaller chunks of log data, perhaps just 1–2 hours of logs per request.</strong></p><p>My work involved detailing these technical aspects, reaching out to various teams (Cyber Defence, Data Engineering, Data Analytics/Science) to gather requirements, collect sample logs, and define clear goals for what we wanted our POC to achieve. The focus became finding practical use cases that could work even with the LLM’s limited context window.</p><h4><strong>A.2) The Data Dump Analyzer Project:</strong></h4><p>Another key project was the “Data Dump Analyzer.” Data dumps, which can sometimes be found on less public parts of the internet, can contain sensitive information or clues about security breaches. The goal was to create a tool to analyze these dumps quickly. I was involved in developing “parsers” — small scripts or programs — to pull out useful information from the varied formats found in these dumps. This involved learning and using different scripting and query languages like KQL, Python, and Bash. I then helped develop a web application for this analyzer and tested it. This became a finalized use case, providing a practical tool for the team.</p><h4><strong>A.3) Other Explored Use Cases:</strong></h4><p>Through our brainstorming and POCs, we also explored other ways Gen-AI could help Cyber Defence:</p><ul><li><strong>Vulnerability Management:</strong> Helping prioritize which security weaknesses to fix first.</li><li><strong>Threat Hunting Guide:</strong> Developing guides (e.g., on how to hunt for threats starting with information from email security solutions).</li><li><strong>Automated Incident Report Generation:</strong> Speeding up the process of creating reports after a security incident by identifying the key data points needed.</li><li><strong>LLM as an Orchestrator:</strong> Using the LLM to coordinate other security tools or processes.</li><li><strong>Learning from Commercial Tools:</strong> Understanding how advanced commercial security orchestration tools work and seeing if LLMs could help analyze their findings or explain threats.</li><li><strong>Code Reviews (SAST):</strong> Using Gen-AI to help review reports from Static Application Security Testing (SAST) tools, which check code for vulnerabilities, potentially by integrating various open-source SAST tools under one application.</li></ul><h4><strong>B. Improving Application Security (AppSec)</strong></h4><p>For application security (ensuring our software is secure), I brainstormed ideas and conducted test projects in two main areas: using Gen-AI for document security reviews and for code reviews. This work helped create a plan for how Gen-AI engineering could be used in AppSec. I was actively working on a Document Security Review project.</p><h3><strong>IV. Working Across Teams: DevOps &lt;-&gt; Cybersec</strong></h3><p>I also had the opportunity to work with the team handling DevOps and Infrastructure (Infra). My primary project here was on AI-powered Code Migration. Key aspects of this project involved:</p><ul><li>Using LLMs to understand logs (as part of a Log Analysis Service).</li><li>Using Java error details (Stacktrace) to find and group similar logs on ELK and Signoz (testing which log management platform was suitable).</li><li>Setting up a system called ELK (Elastic, Logstash, and Kibana) for log management.</li><li>Setting up another tool called Signoz, both in the cloud and on our own servers (on-premises).</li><li>Identifying common error patterns during code migration jobs.</li><li>Clustering these errors together and identifying their remediation paths.</li><li>Developing an automated flow to trigger remediation once an error is identified.</li></ul><h3><strong>V. What I Learned: New Skills and Knowledge</strong></h3><p>These six months were a period of rapid learning. I gained diverse technical and interpersonal skills.</p><h4><strong>A. Learning About Different Security Areas</strong></h4><p>I had the opportunity to work with both the Cyber Defence and Application Security teams. This gave me a good understanding of their daily operations and the tools they use. With Cyber Defence, I learned about tools like Microsoft Sentinel, MDE, and Cortex XSOAR. With Application Security, I learned to use Burp Suite, solved all available PortSwigger Labs, and familiarized myself with various AI safety tools.</p><h4><strong>B. Understanding Gen-AI and Large Language Models (LLMs)</strong></h4><p>Most of my internship focused on Generative AI. I learned a great deal about LLM safety. I gained practical experience in testing LLMs (red teaming), building complete web applications using LLMs, prompt engineering, understanding web security for AI, considering AI policy, and methods for data sanitization to protect privacy.</p><h4><strong>C. Learning About Various Tools</strong></h4><p>Working with the DevOps team exposed me to tools for code migration, software development management systems (flow pipeline, CI/CD), and enhanced my Docker skills. I also learned how to use LLMs for predictive tasks and machine learning methods for data grouping and sorting (classification and clustering). Additionally, I learned about Java error message details (Java Stack Trace properties), how to set up the Elastic Stack, and how to deploy Signoz both in the cloud and on-premises. I also began learning about Google Cloud Platform (GCP) services.</p><h4><strong>D. The Importance of Collaboration</strong></h4><p>The fast-paced field of Generative AI necessitated collaboration with many people. I frequently interacted with the Data Science team and various business departments at Flipkart while reviewing their projects. This was invaluable for understanding how security integrates with different parts of the company.</p><h3><strong>VI. Extra Activities: Volunteering and Trying New Things</strong></h3><p>Besides my main projects, I actively sought ways to contribute to other security efforts at Flipkart.</p><ul><li><strong>Learning about Gen-AI for Security in the Industry:</strong> I looked at products from new Gen-AI security companies like <a href="https://seezo.io/">Seezo.io</a> and <a href="https://www.codeant.ai/">Codeant.ai</a> to see how they could be used for security.</li><li><strong>Trying New Things:</strong> I spent time experimenting with different methods for Personally Identifiable Information (PII) masking. This included exploring the use of LLMs or Machine Learning for real-time information hiding and setting up a tool called Presidio.</li></ul><h3><strong>VII. Looking Back:</strong></h3><p>My six-month internship with Flipkart’s Infosec team was a fulfilling experience. The opportunity to work on cutting-edge Gen-AI security projects with talented individuals significantly shaped my perspective on the world of online security. I learned a great deal, encompassing technical abilities in AI security, cyber defence, application security, and system reliability, as well as crucial interpersonal skills.</p><p>I am very thankful to my mentors and everyone in the Infosec department for their guidance, support, and for entrusting me with important tasks.</p><p>twitter : @cerulianj</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cdf70413be76" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My Summer of Code and Creativity at Headout]]></title>
            <link>https://medium.com/@juhiechandra/my-summer-of-code-and-creativity-at-headout-d6e62279921f?source=rss-3cf168f0a9c1------2</link>
            <guid isPermaLink="false">https://medium.com/p/d6e62279921f</guid>
            <category><![CDATA[travel]]></category>
            <category><![CDATA[framer]]></category>
            <category><![CDATA[internship-experience]]></category>
            <category><![CDATA[headout]]></category>
            <category><![CDATA[design-engineer]]></category>
            <dc:creator><![CDATA[Juhie Chandra]]></dc:creator>
            <pubDate>Tue, 08 Aug 2023 13:29:46 GMT</pubDate>
            <atom:updated>2023-08-08T13:33:04.413Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Fsj_4m3Is-ITU10G0RWhng.gif" /><figcaption>Headout</figcaption></figure><p>During the peak of my 3rd year in college, when everyone was busy applying for summer internships, I was on the hunt for a role that would allow me to combine my passions for tech and design. Throughout my college journey, I spent two years learning both of these fields along with college subjects. Starting as a UI/UX designer, I took up a few internships and soon realised that I craved the satisfaction of building something end-to-end. That’s when I made the switch to web development, eager to learn how to create end-to-end products. To enhance my learning further, I dived into open-source contributions, sharpening my skills in programming.</p><h4>From Application to Selection ✨🎉</h4><p>My search for the perfect role was driven by my desire to put all my acquired skills to the test and get things done in a dynamic environment. I was inspired from <strong>“</strong><a href="https://www.invisionapp.com/inside-design/design-better-book-design-engineering/"><strong>Design Engineering Handbook by Invision</strong></a><strong>”</strong> to pursue such a role. Amidst my tech Twitter adventures, one startup captured my heart: <a href="https://www.headout.com/"><strong>Headout</strong></a>. Their updates had me hooked, and I couldn’t help but admire their vibrant work culture. The prospect of working in a startup team while just stepping into my career excited me to no end, and Headout became one of my dream destinations during that time. I hence applied to the opening for “<strong>Design Engineering Intern</strong>”.</p><p>Going through several interviews and assessment rounds was very interesting. In total, there were three rounds: <strong>a Screening interview, an Assignment Round, and a Cultural-Fit Round.</strong> Of all, the Assignment Round was the most interesting part. I worked with a mentor on a problem statement, and our ability to achieve results quickly, debug problems, and ask the right questions was primarily judged.</p><p>It was so hard to find a role where I could do both “design” and “code”. Getting shortlisted for interview and then proceeding each and every round was a dream come true. I was thrilled when I was offered an internship position.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Fhu5XQYwwuDpVZMBRgOQqQ.jpeg" /><figcaption>Got my first office desk :)</figcaption></figure><h4>First Glimpse of the internship 😄</h4><p>I was thrilled to start my internship at Headout in Bangalore on June 5, 2023. On our first day, our mentor told us about design engineering and what we’re expected to do as “hackers” in this role. Headout has a structure for putting things into action, so it’s a bit tough to squeeze in side projects, but they believe in constant experimenting for new ideas. Our goal as design engineers is to keep innovation running in the roots of Headout. Design engineering helps bridge the gap between designers and developers, making sure all tasks get done properly.</p><h4>The Design Engineer Role: Unfolding the Multifaceted Tasks 👩🏻‍🎨👩🏻‍💻</h4><p>As a design engineer, one must be versatile and able to manage tasks across various teams and projects. Our team had a diverse array of interesting projects to choose from, including creating brand pages, building design tools, and initiating map-based discoveries, among others. I began by constructing “<a href="https://www.framer.com/developers/"><strong>Framer Code Components</strong></a>” which were powered by Headout’s API, while concurrently undertaking other smaller projects on Next.js, etc. The speed of development is rapid and requires fast adaptation. I initially dedicated time to explore Figma files and understand different workflows, while also posing probing questions. Gradually, I realized the extensive capabilities of Framer as a design and coding tool, and the remarkable results it produced.</p><h4>Finding Work-Life Balance 💼🏖️</h4><p>It was my first time living and working away from my home state that too in Bangalore, and I loved it throughout! I’d wake up early, do some work, then attend our daily 11 am standup meetings. After the call, we’d get to work in the office, and the best part was always lunchtime. We all enjoyed going out together for lunch, especially on Potluck or community lunch days, where we bonded as a team.</p><p>After lunch, we’d get back to work on our projects and whenever I got stuck, I’d discuss it with my mentor to solve the problems. At Headout, for every task we did, we wrote down all the details on Notion. This way, if someone needs to work on it in the future, they have all the information they need. During office hours, if I needed a break I could have a coffee or take a half day off if I wasn’t feeling well. Headout as a workplace is super flexible and understanding.</p><p>During the internship, we had fun activities like role-playing different professions and working together to solve real-world problems. We also got introduced to all the other teams and had sessions to learn about Headout’s engineering and the latest products. Headout’s work culture is amazing! We all bond well with each other, share our problems openly, and help each other out. There are weekly fun activities and games that keep the office lively. Even during the workation week, we had a blast playing fun games and got to know folks from other teams, making new friends.</p><h4>Fruitful Mentorship 🌻</h4><p>Working with the product team taught me professionalism and communication skills. Having regular one-on-one calls with my mentor was awesome as we’d reflect on my progress, find areas of improvement, and I could introspect on my own growth. Their advice really helped me build a strong work ethic.</p><p>Managing daily tasks with office work was a bit challenging, but my mentor always guided me and helped me fix my mistakes. An important part of my job involved reading through Headout’s central docs. This helped improve my writing skills.</p><p>The best part of working here is the brainstorming discussions for every project, no matter how big or small. It’s so enjoyable, and we work together to make things happen.</p><h4>When Good Things Come to an End 💜</h4><p>Now that my internship has wrapped up, it’s a bittersweet moment for me. I had the fantastic opportunity to work with the frontend team and the product design team, both of which were composed of incredibly talented individuals. I hold every single one of them in high esteem and am grateful for the skills and knowledge they imparted.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pHXomjMcPyHeqLz-CJ99-Q.png" /><figcaption>Breakout Area</figcaption></figure><p>Every day at Headout bought a new learning experience that I am taking forward in my career. Although my time at the company has come to a close, the relationships I’ve built won’t end here. I’m excited to continue our conversations, keep up with their work, and learn from the sidelines. 💛</p><p><a href="https://juhiescvandpf.framer.website/">Juhie Chandra</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d6e62279921f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Summer Of Bitcoin 2022: Blog (3/3)]]></title>
            <link>https://medium.com/@juhiechandra/summer-of-bitcoin-2022-blog-3-3-947898920c01?source=rss-3cf168f0a9c1------2</link>
            <guid isPermaLink="false">https://medium.com/p/947898920c01</guid>
            <category><![CDATA[design]]></category>
            <category><![CDATA[summer-of-bitcoin]]></category>
            <category><![CDATA[ux]]></category>
            <dc:creator><![CDATA[Juhie Chandra]]></dc:creator>
            <pubDate>Sun, 28 Aug 2022 14:02:24 GMT</pubDate>
            <atom:updated>2022-08-28T14:02:24.126Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w5PtgNqEtAwTx0R_DMsvuA.png" /></figure><p>This is my third blog related to the internship under Summer of Bitcoin 2022. This in continuity with other 2 blogs, check them below:</p><ol><li><a href="https://medium.com/@juhiechandra/summer-of-bitcoin-2022-blog-1-3-2e02ee37c156"><strong>Blog (1/3)</strong></a></li><li><a href="https://medium.com/@juhiechandra/summer-of-bitcoin-2022-blog-2-3-c2f62abe296e"><strong>Blog (2/3)</strong></a></li></ol><h3>Table of Contents</h3><ol><li>About the Program</li><li>My Work Procedure</li><li>Backup, Health Check and Recovery Flow for Wallets</li><li>Creating Small Screen Variations for existing screens</li><li>Creating CKTap Demo App</li><li>Buy Bitcoin UI/UX</li><li>Transfer Policy for BTC</li><li>UI testing for Keeper</li><li>Whirlpool Setup</li><li>Bitcoin 4 India Initiative</li></ol><h3>About the Program</h3><p>Summer of Bitcoin is a global online summer internship program that introduces university students to bitcoin open-source programming and design. The whole program is divided into many phases for which information is given on the <a href="https://www.summerofbitcoin.org/how-it-works">Summer Of Bitcoin Website</a>. There were two tracks: a) Developers and b) Designers. I applied for the second track this time.</p><h3>My Work Procedure</h3><p>The majority of work around this phase of internship was developing a few new features. The research part for features was done individually and I collaborated over UI with my mentor and a fellow intern at Bithyve.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VwRl2jlyYHHme7RB9aN3kA.png" /></figure><h3>Backup, Health Check and Recovery Flow for Wallets</h3><p>A digital wallet must have a way to create an online and offline backup so that we can always restore it if we lose access to it. We should periodically check on our wallet keys and passwords as responsible users. Thus, making the user accountable for their digital wallet was one of our main objectives.</p><h4>Backup Flow</h4><p>There are two methods for creating a backup in Keeper:</p><ol><li>Using Cloud</li><li>Using Seed Words</li></ol><h4>Using Cloud Backup</h4><p>The app will automatically detect cloud service based on mobile devices. User will be asked to save the “App Generated Password” that is automatically generated. The user proceeds after saving password. A modal appears showing creation of cloud backup. At the end, user sees the confirmation of backup.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Oof9g1E1Tevx4ISxmxDkmg.png" /></figure><h4>Using Seed Words</h4><p>The app contains separate 12-phrase seed words for each and every wallet. User can export seed words from settings of wallet. When user proceeds to seed words screen, there user needs to click on each and every seed word one by one to reveal it. The user is expected to copy and write them down on a page. Then user proceeds to confirm these seed words where user is asked to enter a random seed word. After confirmation, user is shown a success message.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*e17ZFojqBXWPq1R8QlffnA.png" /></figure><h4>Recovery Flow</h4><p>This is most crucial to a new user or an existing user returning back to the wallet. There are two ways user can recover wallet: via seed words or via cloud backup.</p><h4>Using Seed Words</h4><p>To recover a wallet, user needs to enter all the seed words and then proceed with it. In case user enters wrong seed word, there is an error message that is shown. The user is asked to enter the seed words again from start. After the user is done with all seed words, then a modal is shown representing creation of wallet image in the background.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6B_1o4C6j8wh2ijx7wkdUA.png" /></figure><h4>Using Cloud Backup</h4><p>To recover account, user needs to select the google account used to backup wallet on the first part. The app automatically checks for the folder in which recovery keys are present. User is then asked to enter the “App Generated Password” for confirmation. After entering password, the recovery process starts and user is finally shown a success message.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OXAyVvrSooR9GMSc9fDsEw.png" /></figure><h4>Health Check</h4><p>Every digital wallet has to have its backup, whether it was created using seed words or the cloud, checked once a month. User messages on the home screen will catalyze the health check. After a predetermined amount of time, the user will be prompted to do a health check.</p><p><strong>Health Check for seed words: </strong>User will be asked any one random seed word from set of 12 seed words for confirmation.</p><p><strong>Health Check for cloud backup: </strong>User will be asked to enter the “App-Generated Password” that was provided while backing up keys on cloud.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*e1hy9Cqb0BngUjUCxZW_RQ.png" /></figure><p>A summary of user actions is displayed to the user after the health check is successful. <br>The user has the option to forego the health check. However, the user will see a warning message if they choose to skip the health check.</p><h3>Creating CKTap Demo App</h3><p>CKTap is an opensource application with minimal UI and only to test SATSCARD and TAPSIGNER. The flow for the application was very simple:</p><p><strong>● </strong>User will be shown an onboarding screen</p><p><strong>● </strong>User then proceeds to read the instructions to setup</p><p><strong>● </strong>User is asked to proceed and scan their NFC card</p><p><strong>● </strong>Depending on the type of card, the application will load functions to perform.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GLH61dR3qaVx75u_y1mD0w.png" /></figure><h3>Buy Bitcoin UI/UX</h3><p>Purchasing Bitcoin directly from public exchanges and depositing it into one’s public wallet is a key feature of digital wallets. <br>We have following choices for purchasing Bitcoin from (within Keeper):</p><ol><li>Swan Bitcoin (<a href="https://www.swanbitcoin.com/">https://www.swanbitcoin.com</a>)</li><li>Wyre (<a href="https://www.sendwyre.com/">https://www.sendwyre.com</a>)</li><li>Ramp (<a href="https://ramp.network/">https://ramp.network</a>)</li></ol><p><strong>● </strong>The trigger for buying BTC will be from homescreen of wallets.</p><p><strong>● </strong>An information screen regarding Swan, Wyre or Ramp will shown based on selection.</p><p><strong>● For Swan Bitcoin, </strong>in Keeper we will only link the already existing Swan Account with a public wallet.</p><p><strong>● </strong>The<strong> tags </strong>on the wallet interface assist the user better grasp what the protocols are for the current wallet, preventing them from<strong> mixing UTXOs</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*82Y_qaeRMgu4qEZm53vlwQ.png" /></figure><h3>Transfer Policy for BTC</h3><p>One of Keeper’s key benefits is its ability to automate challenging user operations like “<strong>Transfer BTC from wallets to vault</strong>” There is an automatic mechanism called Transfer Policy that may be used for similar operations. The threshold that will trigger the transfer must be determined by the user. It is set to <strong>0.01 BTC</strong> by default.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PlCb__5X8B4_HzirbAbmyQ.png" /></figure><h3>UI testing for Keeper</h3><p>I spent a week pointing out problems with the Android Keeper Dev release. I had to identify minor UI flaws and comprehend delays in the current UX flow for the wallet we designed, which was a nice learning experience. I wrote down every problem and gave it to Keeper’s testing team, who later opened issues on Github for front-end developers to fix.</p><h3>Whirlpool Setup</h3><p>(This is a very short summary, to be covered in detail in the next article.)</p><h4>What is Whirlpool/Coinjoin?</h4><p>Samourai Whirlpool is a <strong>free and open source</strong> (FOSS), <strong>non custodial</strong>, chaumian CoinJoin platform. Its goal is to mathematically disassociate the ownership of inputs to outputs in a given bitcoin transaction. This is to increase the privacy of the users involved, protect against financial surveillance, and to increase the fungibility of the Bitcoin network as a whole.</p><p>(Data: <a href="https://docs.samourai.io/whirlpool/start">https://docs.samourai.io/whirlpool/start</a>)</p><h4>Market Research</h4><p>I spent a week using Sparrow and Samourai wallets to conduct transactions and understanding whirlpool. My main goal is to comprehend how to make this challenging process simpler and more user-friendly. Additionally, our team looked through additional wallets and spoke with the Samourai team about the same.</p><p>Here are a few snapshots from all the paperwork! Zoom in 😌🔍!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*niV-s-5eenNBmlB_i-wJcw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4UHlMgVeIJRtrlFAPJOlcw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lUPWJ1eMusJTZ-qBcjFP-g.png" /></figure><h4>Wallets Structure in Keeper</h4><p>The user has three separate wallets, <strong>clearly</strong> marked.</p><p>- Public Wallet/ KYCed funds</p><p>- F&amp;F Wallet/ from known individuals but not institutions like exchanges etc</p><p>-Private Wallet/ where there is no personal info associated with the funds (They act like default labels);users can have other wallets too for work.</p><h4>Public wallets:</h4><ol><li><em>KYC Seed</em></li><li><em>Mostly exchanges</em></li><li><em>Identity is disclosed to the public</em></li></ol><p><em>(whenever user performs send and receive , there should be a message for user warning them repercussions of it)</em></p><h4>Friends and Family Wallet:</h4><ol><li><em>Not exactly a public wallet as identity is disclosed to our group whom we have added with us on hexapay</em></li></ol><h4>Private Wallet:</h4><p>1. <em>this is a highly sensitive wallet and user must be guided time to time to appropriate decisions for optimal usage of funds</em><br>2. <em>a single wrong transaction can spoil privacy of the whole blockchain data</em><br>3. <em>Cannot receive transactions from any exchange or any other public wallet</em></p><h4>First technical discussion: How flows were changed?</h4><p>The major change that was brought into consideration was that the whole process for whirlpool could not be implemented inside the vault. Earlier it was decided to have the whirlpool within the vault. However, inside the vault, the UTXOs will be with secured with different signers. Hence, when these UTXOs will be merged with other UTXOs inside a pool then the “Digital Footprints” of these transactions will be easy to trace because of signers. This will ruin the very core element of whirlpool that is anonymity. Finally, it was decided to perform whirlpool inside private wallets. This changed the complete flow.</p><h4>The new flow and what changes did it bring?</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UfU6QflTPLC3Dz_V-e6icA.png" /></figure><h4>Second technical discussions: If whirlpool will be a separate entity or a transient thing?</h4><p>A new viewpoint on the whirlpool setup was presented during the second technical discussion. It was decided on two ways to present it. One method is to display Whirlpool inside the application as a totally different entity. The second strategy is to portray a whirlpool as a fleeting phenomenon. Here, the user can only watch the entire process as a progress bar and not alter any intermediate steps. The course of the process is still up for debate.</p><h4>Converted the current flow into basic UI (temporary)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Wx7fFsVwJaNESy_MKAgKDQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BO4jyrsf7mUGo88xiDtUAA.png" /></figure><h4>So what’s the latest update?</h4><p>This area of the Bitcoin ecosystem is expanding quickly, and daily changes are being made to numerous legal regulations. A few security holes needed to be discussed with the Samourai wallet team. As a result, this feature was delayed for a few sprints. This would be taken up following the official app launch.</p><h3>Bitcoin 4 India Initiative</h3><p><strong>Bitcoin4India is a thriving community of selfless volunteers, bitcoin enthusiasts, bitcoin thinkers, and bitcoin technologists.</strong></p><p>The major goals this initiative wants to achieve are:</p><ul><li>Educate 1.3 billion people about bitcoin.</li><li>Create bitcoin-only communities and bitcoin-related job opportunities.</li></ul><p>Under Summer of Bitcoin 2022, I got this huge opportunity to design logo for this community!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*425bWUogyWUKKDMUnUmP0Q.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=947898920c01" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Summer Of Bitcoin 2022: Blog (2/3)]]></title>
            <link>https://medium.com/@juhiechandra/summer-of-bitcoin-2022-blog-2-3-c2f62abe296e?source=rss-3cf168f0a9c1------2</link>
            <guid isPermaLink="false">https://medium.com/p/c2f62abe296e</guid>
            <category><![CDATA[summer-of-bitcoin]]></category>
            <category><![CDATA[internships]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[ui-design]]></category>
            <category><![CDATA[bitcoin]]></category>
            <dc:creator><![CDATA[Juhie Chandra]]></dc:creator>
            <pubDate>Wed, 06 Jul 2022 21:19:57 GMT</pubDate>
            <atom:updated>2022-07-06T21:19:57.016Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6qEgCg2gINNV-mB68b26sA.png" /><figcaption>Cover</figcaption></figure><p>This is my second blog related to the internship under Summer of Bitcoin 2022.</p><h4>Table of Contents</h4><ol><li><strong>Understanding Keeper</strong></li><li>My <strong>Work Procedure</strong></li><li>Meet the<strong> Product Team </strong>of Keeper</li><li><strong>Week-2</strong> : Getting the basics of UI right</li><li><strong>Week-3</strong> : Diving deeper into the core fundamentals of Hot Wallets</li><li><strong>Week-4</strong> : Time to take independent decisions for UX</li><li><strong>Week-5</strong> : A week of intense learning</li><li>Thanking note 👋</li></ol><h3>Understanding Keeper</h3><p><a href="https://hexawallet.io/">Hexawallet</a>, the Bithyve Organization’s flagship product, will now be available in two versions, each one tailored to a different user’s needs.</p><p>They offer three definitions of users:<br>A) Pre-coiner Pam: Being new to the field, she first wants to test out the wallet and educate herself about bitcoin.<br>B) New-coiner Neeraj: He has some bitcoin thus far, but wants to use them in new ways.<br>C) Bitcoiner Bob: has a sizable sum of bitcoin and wants to spend them safely.</p><h4><strong>Two products:</strong> <strong><em>Keeper</em></strong> is primarily for the C types of consumers, and Hexapay is intended for both A and B.</h4><p>1.User possesses a sizeable BTC worth (between $ 10,000 and $ 100,000).<br>2. User holds it on a hardware wallet but wants to increase security/resiliency, or Holds it on an exchange but is afraid to withdraw for fear of losing it<br>likes having self-control.<br>3. User is privacy-conscious also contemplating the possibility of inheriting his Bitcoins.</p><p><em>(Information based on the company’s research)</em></p><h3>Work Procedure</h3><p>There are sprints for each new version of the Keeper application, and the entire project is managed on Github.</p><p>The development and testing teams work at a lower sprint level than the design team. My mentor reviews the tasks when I’ve finished them.</p><p>Every Thursday, the tech team sees the <strong><em>final release</em></strong> for each sprint and provides input. Final revisions must be completed by Friday to put to development in the very next sprint.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hMmC7xl46fHJ_HliGPJfLg.png" /><figcaption>Process for the week</figcaption></figure><h3>Product Team</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1WdMlbedsn9K0qU8PDLzeQ.png" /></figure><h3><strong>Week-2 (30 May 2022–3 June 2022) :</strong></h3><p>In the Monday morning meeting, the task for the week was given. I’ll discuss the conclusions I reached and why.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a0LxPCQMq3MuXGbEn0OVRQ.png" /><figcaption>Sketching Thought Process/Tasks/Feedback from Mentor</figcaption></figure><h3>Task 1: Creating a version of the home screen when nothing is setup</h3><p><strong>Goal: </strong><br> ⇒ Understand<strong> </strong><a href="https://hexawallet.io/"><strong>Hexawallet</strong></a><strong>’s </strong>Wallet Creation Process ( Keeper will have a similar journey )<br> ⇒ Understand the Primary and Secondary journeys of user<br> ⇒ Understand user messaging in a minimal way<br> ⇒ Create an iteration from the design system and a few designs provided based on understanding</p><p><strong>Thought Process: <br>● </strong>Users will land on a screen where they&#39;re asked to either “Add a wallet” or “Add a vault”; buying BTC can be an optional addition to the screen.</p><p><strong>● </strong>Some users may prefer both options on the same while others may go for separate locations. Hence, I created two different iterations.</p><p><strong>●</strong>I have to strictly stick to the typeface provided by the mentor and the branding elements like the colors and gradients etc.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qRyQop8o6CA5vaJm7yudiQ.png" /></figure><p><strong>Feedback from mentor and team:<br>•</strong>Avoid using tags for user messaging, it is meant for categorizing things.<br>•The second iteration is better because it’s more informative and visually pleasing.</p><h3>Task 2: Creating Settings Screen</h3><p><strong>Goal: </strong><br> ⇒ Understand Hexawallet’s Settings elements that will be repeated in Keeper<br> ⇒ Understand the Primary and Secondary journeys of user<br> ⇒ Understand Features of Keeper</p><p><strong>Thought Process: <br>● </strong>As the user is going into a secondary journey, the screens must be of secondary color.</p><p><strong>● </strong>The first iteration was an experiment with green over beige color with some gradient for the CTA part.</p><p><strong>●</strong> The second iteration was focused to be minimal and added a search bar for improving the search experience of the user.</p><p><strong>●</strong> The third iteration was created after discussing with the mentor regarding elements in UI and talking with developers regarding the features.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*t6M68SakaOd5TMKYgpJAUg.png" /></figure><p><strong>Feedback from mentor and team:<br>•</strong>Avoid using gradient elements on gradient background for CTA<strong> </strong><br>•The search bar should be a minimum of 38px in width</p><h3>Task 3: Creating Login Flow for Keeper</h3><p><strong>Goal: </strong><br> ⇒ Understand Hexawallet’s Login elements that will be repeated in Keeper<br> ⇒ Understand different journeys of user<br> ⇒ Create an iteration from the design system provided based on understanding</p><p><strong>Thought Process:</strong></p><p><strong>● </strong>The first two iterations were created to demonstrate different contrast of secondary color on login screen</p><p><strong>●</strong> I tried using tags for giving user message ( which I realised was not a good practice ).</p><p><strong>●</strong> The third iteration was more focused on how primary color will contrast with white for the login screen.</p><p><strong>●</strong> Similar to Hexawallet I added inbuilt numpad in login screen.</p><p><strong>● </strong>My major concern was the amount of information user needed for a smooth login experience.</p><p><strong>● </strong>I thought of highlighting the particular block in which user was typing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AgcXg5Xpn7EBvv0S9EJdaA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TLAp1Ars1jI5L_v4H1w49g.png" /></figure><h3>Task 4: How Error while Login will be shown?</h3><p><strong>Goal: </strong><br> ⇒ Understand Hexawallet’s Login elements that will be repeated in Keeper<br> ⇒ Understand different journeys of user<br> ⇒ Create an iteration from the design system provided based on understanding<br> ⇒ Understand what is ideal way to show error which does not inhibit the authenticity of design and spoils user’s mental state</p><p><strong>Thought Process:</strong></p><p><strong>● </strong>The first iteration would turn all the dots into hollow depicting there is some error.</p><p><strong>● </strong>The second iteration was intended to be more bold and visibily clear that user needs to enter the passcode again.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1dW0vU9BJwTXM0oBlSbuDg.png" /></figure><p><strong>Feedback from mentor and team:<br>•</strong>Avoid using texts between 11px to 12px for user messaging while error as it is hardly visible.<br><strong>• </strong>The idea to highlight blocks with a shade of red was appreciated.</p><h3>Task 5: Design a flow for creating a new wallet in Keeper</h3><p><strong>Goal: </strong><br> ⇒ Understand Hexawallet’s userflow for creating a new wallet<br> ⇒ Understand different wallet types<br> ⇒ Create an iteration from the design system provided based on understanding<br> ⇒ Understand what is ideal way to create screens for user entry that is not overwhelming for users.</p><p><strong>Thought Process:</strong></p><p><strong>● </strong>I experimented with the contrast levels of secondary color as this is secondary journey for a user.</p><p>● Minimum number of fields for user to enter the required information and getaway with the first step as soon as possible.</p><p>● Also, mentioned number of maximum characters based on the space available on home screen for showing wallet details.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BiFiz3_nlGEhTh05Z_sGUw.png" /></figure><p><strong>Feedback from mentor and team:<br>•</strong>The design was confirmed and sent for development</p><h3>Week-3 <strong>(6 June 2022–10 June 2022)</strong> :</h3><p>In the Monday morning meeting, the task for the week was given. I’ll discuss the conclusions I reached and why.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*U7buniyizTeKC06q2NCmHg.png" /><figcaption>Sketching Thought Process/Tasks/Feedback from Mentor</figcaption></figure><h3>Task 1: Creating Send Journey</h3><p><strong>Goal: </strong><br> ⇒ Understand Hexawallet’s userflow for sending SATS<br> ⇒ Talking to product manager regarding specific details <br> ⇒ Create an iteration from the design system provided based on understanding<br> ⇒ Understand what is ideal way for a user to perform transaction without being obstructed by high priority information flowing in</p><p><strong>Thought Process:</strong></p><p><strong>● </strong>I experimented with a few design samples provided by my mentor and also took inspiration from few crypto wallets</p><p><strong>●</strong> For the selection of receiver, providing different options to user was important. However, major focus should be on the scan part because it’s easily accessible and fast.</p><p>● Creating screen where user enters the amount and other details was a tough task as I needed to find appropriate words to be used for this was a High Priority Task.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*osFglrp2f9FY7tY7ot2MZQ.png" /></figure><p>● After creating a few iterations, I had a discussion with mentor about improvements and realised I was repeating a few things and ignoring some important details like “<strong>What is the reason for transaction?</strong>”.</p><p>● I created few iterations as below based on feedback and also trying to complete the whole procedure in minimum number of steps.</p><p>● <strong>Custom Priority</strong> is a new thing for user. Hence, the best way they could understand what it meant was to show it along other ways of Transaction Priority: <strong>High, Medium and Low</strong>. User would get a basic idea that — The more the Fees, the fast transaction would be completed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0R6SR8f3qbx42IGoAdF81Q.png" /></figure><p><strong>Feedback from mentor and team:<br>•</strong>The design was confirmed and sent for development</p><h3>Task 2: Creating Receive Journey</h3><p><strong>Goal: </strong><br> ⇒ Understand Hexawallet’s userflow for receiving SATS<br> ⇒ Talking to product manager regarding specific details <br> ⇒ Create an iteration from the design system provided based on understanding<br> ⇒ Understand what is ideal way for a user to perform transaction without being obstructed by high priority information flowing in</p><p><strong>Thought Process:</strong></p><p><strong>● </strong>I experimented with a few design samples provided by my mentor and also took inspiration from few crypto wallets</p><p><strong>●</strong> The most important things are : QR code, Address of the wallet and the amount user will receive (optional)</p><p>● Why will user enter amount to receive? : The QR part and Receive SATS option work together. When user enters 200 SATS for instance and the sender scans the QR, the amount 200 SATS will automatically be filled in sender’s entry field.</p><p>● User can also copy the address of the wallet and share it with the sender.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pDsb-HvmK24vnAC-Xo6kug.png" /></figure><p><strong>Feedback from mentor and team:<br>•</strong>The design was confirmed and sent for development</p><h3>Task 3: Creating Transaction List</h3><p><strong>Goal: </strong><br> ⇒ Talking to product manager regarding specific details <br> ⇒ Create an iteration from the design system provided based on understanding<br> ⇒ Understand what are the most important elements of any transaction on a blockchain network<br> ⇒ Understand which elements would be useful from a user’s point of view</p><p><strong>Thought Process:</strong></p><p><strong>● </strong>I researched through a few wallets and made list of important aspects of a bitcoin transaction.</p><p><strong>●</strong> The most important things are : Transaction ID, Amount, Sender and Receiver’s wallet ID and the transaction fees.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Sjnt2_c79uqptLsWqMpb8g.png" /></figure><p><strong>Feedback from mentor and team:<br></strong>•My mentor explained me about the standard practice of making transaction lists.<br>•Also, the design would vary as per the wallet hence this design was moved to lower priority and kept for redesigning.</p><h3>Task 4: Creating a Settings screen for a wallet</h3><p><strong>Goal: </strong><br> ⇒ Talking to product manager regarding specific details <br> ⇒ Create an iteration from the design system provided based on understanding<br> ⇒ Understand what are the most important elements of any wallet</p><p><strong>Thought Process:</strong></p><p>● The design would be similar to Keeper Settings screen.</p><p>● The most important things are : Show XPub and Wallet’s seeds.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_gnGaQwOcTvm8rochhH1vA.png" /></figure><h3>Task 5: Creating flow for exporting wallet individual seeds</h3><p><strong>Goal: </strong><br> ⇒ Talking to product manager regarding specific details <br> ⇒ Create an iteration from the design system provided based on understanding<br> ⇒ Understand and simply the complex procedure for developers using userflows<br> ⇒ Intergrating privacy check features within the UI</p><p><strong>Thought Process:</strong></p><p><strong>● </strong>To increase security, user will be asked to confirm the passcode again before exporting seeds.</p><p><strong>●</strong> Only a single seed word would be visible at a time on tap. This is done to prevent screenshot of the screen and make the process longer hence much serious.</p><p><strong>●</strong> In the note, user will be informed to keep the seed words safely as losing it will lead to permanent loss of access to the wallet.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2-98XSTTE4V2-H0bqibheg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EtGW3zfB3Tgfh7F3_2h-Kg.png" /></figure><p><strong>Feedback from mentor and team:<br>•</strong>The design was confirmed and sent for development</p><h3>Week-4 (<strong>13 June 2022–17 June 2022</strong>) :</h3><p>In the Monday morning meeting, the task for the week was given. I’ll discuss the conclusions I reached and why.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UwPt9tCj1_jHjpPwWnitPQ.png" /><figcaption>Sketching Thought Process/Tasks/Feedback from Mentor</figcaption></figure><h3>Task 1: Creating a screen for inheritance flow</h3><p><strong>Goal: </strong><br> ⇒ Talking to product manager regarding specific details <br> ⇒ Create an iteration from the design system provided based on understanding<br> ⇒ Understand the crucial details within the process of “Inheritance of Keeper”<br> ⇒ Simplifying complex vocabulary in much simpler way for a user</p><p><strong>Thought Process:</strong></p><p><strong>● </strong>The whole process of inheritance would be a checklist to complete one after another.</p><p><strong>●</strong> The second step can be initiated only after completion of first.</p><p><strong>●</strong> Also, making Know-more screens for inheritance is on list of future works so that user can be guided well throughout the process.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fPitDe33Mv74S0HdiNgLGA.png" /><figcaption>Inheritance in Keeper</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UIgg8PI66TFSPK4957rCUQ.png" /></figure><p><strong>Feedback from mentor and team:<br>•</strong>The design was approved however number of steps were reduced.</p><h3>Task 2: Creating a success message after password reset</h3><p><strong>Goal: </strong><br> ⇒ Create an iteration from the design system provided based on understanding<br> ⇒ Understanding that timely user feedback is very necessary</p><p><strong>Thought Process:</strong></p><p>● This was a low effort task and the thought process was pretty much obvious.</p><p>● Such positive user feedbacks are necessary to improve the user experience</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hUzK-fZxRTBiZ9Yrqv-4-g.png" /></figure><h3>Task 3: Creating screens for setting up tapsigner</h3><p><strong>Goal: </strong><br> ⇒ Talking to product manager regarding specific details <br> ⇒ Create an iteration from the design system provided based on understanding<br> ⇒ Understand the crucial details within the process of “Setting Up Vault from Tapsigner”<br> ⇒ Understanding how does a Tapsigner works</p><p><strong>Thought Process:</strong></p><p><strong>● </strong>The actual flow will include a screen showing all the possible hardware supported by Keeper. User can select the respective hardware wallet used by them.</p><p><strong>● </strong>After entering CVC code during setup process, the Tapsigner takes a while in the backend to retrieve data and show it on the frontend.</p><p>To solve this, different levels of process will be shown so the user can understand what is happening in the meanwhile.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j9I470vUkMBJ8xpJAcnJmQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sSaQJCaOT31V_IVMkvjWbA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*89wUEepY4USswWyyvu4sGw.png" /></figure><h3>Task 4: Creating screens for transferring funds from wallet to vault</h3><p><strong>Goal: </strong><br> ⇒ Talking to product manager regarding specific details <br> ⇒ Create an iteration from the design system provided based on understanding<br> ⇒ Understand the crucial details within the process of “Transfering BTC from wallet to vault within Keeper”<br> ⇒ Understand the trigger policy</p><p><strong>Thought Process:</strong></p><p><strong>● </strong>The most important aspect of Vault is to secure the funds. A wallet is made for daily basis transaction. Hence, when wallet crosses a certain amount of money, user is asked to transfer it to vault for increasing security.</p><p><strong>● </strong>The <strong>trigger policy</strong> for this can be changed by users themselves. This will be shown as a user message on homescreen.</p><p><strong>● </strong>Also, we would require the user to complete the procedure in minimum number of steps as much as possible. Hence, only two screens with heavy details were to be made.</p><p><strong>●</strong> Before any such high priority task, there is always a <strong>confirmation modal</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wVeIRx7j68QT3ucXMamMZg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YHt3bxG7BRgxZ84PuATbQA.png" /></figure><p><strong>Feedback from mentor and team:<br>•</strong>The design was confirmed and sent for development</p><h3>Week-5 (13 June 2022–17 June 2022) :</h3><p>In the Monday morning meeting, the task for the week was given. I’ll discuss the conclusions I reached and why.</p><h3>Task 1: Create settings screen modified version</h3><p><strong>Goal: </strong><br> ⇒ Talking to product manager regarding specific details <br> ⇒ Create an iteration from the design system provided based on understanding</p><p><strong>Thought Process:</strong></p><p><strong>● </strong>This was a low effort task and only a single element “Backup Keeper” was to be added.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/344/1*SllHS5MXFQ4ZluzHOHYwpg.png" /></figure><h3>Task 2: Understand Backup, Recovery, and Health Check of wallet</h3><p><strong>Goal: </strong><br> ⇒ Perform <strong>Backup, Recovery and Health Check</strong> of wallet on Hexawallet and understand the fundamentals before creating a new flow.<br>⇒ Divide the intensive task into chunks and create userflows which can be later used for usability testing for each process</p><p>The ETA for this task was assigned for the next weekend.</p><p><strong>The userflow was created many times by us and changes were made with more meetings. The following userflow was finalized by the UX designer.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x8gqbQkPu2xlVWrr-Wp-Bw.png" /><figcaption>Performing Keeper Recovery using Seed Words</figcaption></figure><h3>Task 3: Create Recovery via seed words flow for Keeper</h3><p>The following screens were created as per the userflow:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XIOLoNhIegPq8EK2gP3EJQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x11dD7yjw9l8dImAXjlptA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1escoivPMdxS2-GRIEMgsA.png" /></figure><p><strong><em>The remaining part of this BHR flow would be covered in the next blog</em></strong></p><h3>Many thanks for sticking with me</h3><p>It took a long time for me to document my work along with minor details behind every design. A few things I would like to mention apart from the work:</p><p>💛 The Hexawallet/Bithyve team is really helpful and supportive. Everyone is considerate enough to lend a hand when necessary. Working with them throughout this initial round of my internship was a lot of fun. From Morning Scrums through Evening Community Times, here are a few screenshots:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*weUa83W6027EMHP0I4f8PQ.png" /><figcaption>The feeling when your designs come live 💜</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dAJjc-TAufX1jdsmIxkwfQ.png" /><figcaption>Just me messing with Japan’s Pani Puri XD</figcaption></figure><p>💙 I met quite a few designers who are part of Summer of Bitcoin 2022 and made great friends! A special thanks to <a href="https://hsrambofig.super.site/"><strong>Harsh Singhal</strong></a> for supporting me, bearing with my rants, and offering advice in the manner of a mature senior. For LN Capital, he is building a design system that is excellent.</p><p>🖤 Also, a warm note for fellow design interns at Hexawallet. Thanks for being super supportive <strong>Yusuf </strong>and <strong>Jessica</strong>! You guys are amazing.</p><p>🤎 Thank you <a href="https://pkagrawal.me/"><strong>Pranshu</strong> </a>for guiding me through complex topics in weekly study sessions and keeping a check on my progress.</p><h4>Thank you all for being so kind! This is the spirit of learning in community.</h4><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c2f62abe296e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Summer Of Bitcoin 2022: Blog (1/3)]]></title>
            <link>https://medium.com/@juhiechandra/summer-of-bitcoin-2022-blog-1-3-2e02ee37c156?source=rss-3cf168f0a9c1------2</link>
            <guid isPermaLink="false">https://medium.com/p/2e02ee37c156</guid>
            <category><![CDATA[design-process]]></category>
            <category><![CDATA[case-study]]></category>
            <category><![CDATA[summer-of-bitcoin]]></category>
            <dc:creator><![CDATA[Juhie Chandra]]></dc:creator>
            <pubDate>Sun, 26 Jun 2022 17:14:02 GMT</pubDate>
            <atom:updated>2022-06-27T07:52:14.346Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wht6Z_IYoejRN2yt6jn81Q.png" /><figcaption>Cover</figcaption></figure><h3><strong>About the Program</strong></h3><p>Summer of Bitcoin is a global online summer internship program that introduces university students to bitcoin open-source programming and design. The whole program is divided into many phases for which information is given on the <a href="https://www.summerofbitcoin.org/how-it-works">Summer Of Bitcoin Website</a>. There were two tracks: a) Developers and b) Designers. I applied for the second track this time.</p><h3><strong>The process of being selected</strong></h3><p>I learned about this program in January 2022 and applied along with a few design case studies. I was chosen for the second round after the first phase, where we had to provide a thorough proposal for our idea. During this time, there were also a limited number of learning workshops about the Bitcoin Ecosystem. In April, I was concurrently working on proposals for Outreachy and the Summer of Bitcoin. I went with the Hexawallet organization for Summer of Bitcoin.</p><p><strong>Here are the two proposals I put forth on April 18, 2022:</strong></p><ol><li><a href="https://docs.google.com/document/d/1cSMqWTETyDCyYypLdENmlRK70x-_xuwIbCXsGgvXunU/edit?usp=sharing">Bitcoin and Friends — Secure chat-like interface for the interaction between wallets</a></li><li><a href="https://docs.google.com/document/d/1hJK6VE7yvmJfbT3smf5Qu2KecF3paC_BILhEWy3S-MQ/edit?usp=sharing">Bitcoin and Learning — A wallet that teaches bitcoin as you use them</a></li></ol><p>After submitting my proposals, I was given an assignment that required me to finish a few tasks and turn them in to my mentor. Since there were multiple viable project proposals, it was an elimination round. After passing, I received a call for a one-on-one interview. I had my first interview for a position in product design. It was a success! Throughout the entire interview process, my mentor was incredibly nice and supportive.</p><p><strong><em>The selection notice finally arrived in the mail for me on May 3, 2022.</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*DeBOiBGoEFPGnEaz" /><figcaption>Email</figcaption></figure><p>I was extremely grateful for being selected! It was highly competitive this year as there were 20,000+ applicants and over 1500+ proposals.</p><h3><strong>Community Bonding Phase</strong></h3><p>My organization, Hexawallet, had a head start on community-building. On May 13, 2022, we held our “SOB interns — Induction session.” Hexawallet chose six interns for the SOB 2022 program. Interns were made introduced to the company and the projects we will be working on this summer by our mentors.</p><p>On May 16, there was a “Task and GIT hub alignment session” where we learned about managing issues on Github. Additionally, the weekly Show and Tell call, during which each member briefs their individual week’s work, would take place on Friday. I was assigned to design for the organization’s software “Keeper.” My mentor <strong>Sumaiah Khan</strong> would oversee the entirety of my job.</p><h3>Work Assignment</h3><p>I had my first meeting regarding the work assignment on the 23rd of May 2022 “Keeper Design Orientation”. My mentor told me about the number of meetings and working hours each day. Four segments would make up the entire day:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aDaEuEqZLaqNjR5JUKIpyA.png" /><figcaption>Schedule</figcaption></figure><p>Typically, the tasks for the day were told during the morning briefing call with the mentor or the morning standup call. I had to submit the work or update the team on my progress during the evening. This timetable was adhered to during the first stage of the internship and is expected to remain unchanged during the second stage as well.</p><h3><strong>Week — 1 (23 May 2022–27 May 2022): Learning the Design System and Getting Familiar with AdobeXD</strong></h3><p>The design system for Keeper, which was being developed at the time, was introduced to me by my mentor. I had to learn it and use it to recreate a few patterns. I’ll be providing a few pictures below for the same:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gfLsLLbpa_yonCn62jfZRQ.png" /><figcaption>Week-1 Summary</figcaption></figure><p>We held a Show and tell call with the team on the 27th of May in which everyone presented an overview of their work. Listening to my fellow interns taught me a lot about various fields.</p><h3>Extras:</h3><ol><li>Every week on Thursday, we had Chaincode Seminars which followed the following schedule:</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bHa7JnKmN84SwAB119QmtA.png" /><figcaption>Seminars</figcaption></figure><p>The selected interns were given weekly reading materials and questions based on that. In Thursday’s meeting, we had to discuss the same topic with our assigned group and ask doubts from mentors regarding the same. These seminars proved to be informative and taught me a lot about Bitcoin from the very core. On the 23rd of June 2022, we had the last seminar for Bitcoin Protocol Development. I’m looking forward to learning about Lightning Network through the next phase of these seminars.</p><p>2. For managing weekly notes and tracking my workflow, I used Notion.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XKibg6KOCfUCuTywbMP39w.png" /><figcaption>Notion Workspace</figcaption></figure><p><strong><em>The next blog will be a detailed walkthrough of my entire work for Phase 1 of the internship. Thank you for reading.</em></strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2e02ee37c156" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Realization]]></title>
            <link>https://medium.com/@juhiechandra/realization-e0041cb266d7?source=rss-3cf168f0a9c1------2</link>
            <guid isPermaLink="false">https://medium.com/p/e0041cb266d7</guid>
            <category><![CDATA[family]]></category>
            <category><![CDATA[life]]></category>
            <category><![CDATA[law]]></category>
            <category><![CDATA[lost-love]]></category>
            <category><![CDATA[past]]></category>
            <dc:creator><![CDATA[Juhie Chandra]]></dc:creator>
            <pubDate>Wed, 10 Nov 2021 16:27:56 GMT</pubDate>
            <atom:updated>2021-11-10T16:27:56.428Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LLlW1Lqe37itUBAalsA0RQ.png" /><figcaption>Thinking about my past</figcaption></figure><p>I have been thinking about some souvenirs. It is an old incident of which, unfortunately, or fortunately, I have been an eyewitness. MY SCHOOL DAY, I was on the bus with my friends from home to my school. About 8 to 9 years ago (I wonder how much I have changed over the last few years). I was in third or fourth grade. I do not remember until I go back to those places we had left as we shifted from Samana to Patiala to our new home (a decision that was taken suddenly one night when my mother was seriously humiliated by our house owner, yes it was our 2nd rented house in Samana).</p><p>So, through the windows, my friends and I saw two bodies covered in white clothing along the side of the road that leads to Patiala from Samana. Ironically, there has been a government school just 10 to 20 meters from this rugged place with a sacred Gurudwara located within its confines. I fail to recall what had been the reactions of everyone, but that’s just so superficial in front of something irreversible, something which is inevitable but we humans crave for a return.</p><p>Guess what, I reached my school and went to class. One girl of 10th class was all in tears sitting on the sofa near the reception room and a thought sparked inside my brain what if that accident has to do with some student of my school or what if that accident is about belonging to that very girl.</p><p>I struggled with internal voices and out of curiosity of a child, I tried to ask people what had happened. The only reply I could find was ‘a public holiday declared to return home with your respective buses’. I was in my class and my friends were just telling me someone of class 10th,a bright child, the favorite of all teachers, leader of our school is either dead or in hospital due to that accident.</p><p>I really didn’t have a clue who the school leader was. I was always oblivious to those school details and I was so mad about it. After a few hours, I was on the road to the house (my family’s first rented house) and I saw so many people gathered around this house. I wondered what would happen if that could bring an adjective of home to this house, how it would happen again?</p><p>My family has not been back there for over 5 years to gather information about what happened after we left. Although we did pray that things would go well. My mother says that praying comes true when it is done with a pure heart. My personal belief is that there is no clue to life. I pray only when I have done something wrong and I ask either to punish me or to give me another opportunity. It’s still a blend of the two I get.</p><p>I watched my mom leave the house. It was a fully furnished bungalow. My mother grabbed my hand and took me through the crowd to another house just in front of that house. It was the home of my childhood friend Josheen (I never forget the names once someone becomes an authentic part of the journey negatively or positively). I tried to ask my mother that who had passed away? My mother was in tears and she did not answer me.</p><p>I heard back from Josheen’s mom. He was Sahib’s brother (elder brother among the two brothers we lived as a rented family to) and I was lost, my movements froze and my lips cracked. I didn’t have the nerve to talk for months to anyone after that day. I haven’t even spoken with Sahib after that day. If I see him again, even if he’s at university or if they’ve been transferred overseas, I will never be able to say a single word.</p><p>Should I provide details on the accident? You know what is common in our daily lives when brilliant students like him let themselves be drawn into bad groups. They start doing things they shouldn’t have done. It was an accident between a truck and a motorcycle driven by three boys and sadly he turned out to be one of them.</p><blockquote>What is even more depressing is that the accident occurred close to the school where his mother was a teacher. What worse can a mother expect every day? What does it mean to live in the absence of someone who means everything to you every day? What is the cure for this hollow heart that we wear every day and that has witnessed this unexpected and unfortunate accident?</blockquote><p>Again in gold letters in our sacred book which we are obliged to touch as a sign of truth when we are supposed to deliver our verdict in the courtroom. I often wonder about our trustworthiness. I often wonder about the framework of our own constitution and our judiciary.</p><p>Leaving that for another blog, the quotation says:</p><p><strong>Souls never die, Our flesh has a date of expiration.</strong></p><p><strong>How easy it is to write , How hard it is to accept.</strong></p><p><strong>These are rudimentary principles. Things are mortal.</strong></p><p>These days, I’ve made it clear within my mind that I’m temporary, so you are and everyone and everything around you. We are witnessing everyday difficulties and daily challenges. We are witnessing how our extra thirst brings us grief and how we can stay happier with less. But we continue to deny facts and truths, we continue to believe in our falsehoods.</p><p>Just so you can escape reality. And I wonder what else we can do with our great imaginary thinking abilities. Every company, every brand, everything we wear and tear apart, everything we buy and throw away, everything we design and destroy, everything we do so we are told to do and told this is the way humans have to work so we do it.</p><p>Everything from the construction of a skyscraper to a black lampblack mark on the forehead of a baby is pure fiction. We have created a system and we never realize that we obey it every day because it is too late in our generations. We’re so high on the ladder. We cannot go back to change the framework of roots.</p><p>This whole issue needs to be thoroughly discussed and we will consider it later.</p><p>I had these thoughts about living with dying since 2018 when I first realized how fragile a human is, how fragile I am while I was watching nurses and doctors taking an old man on a stretcher to ICU at PGIMER. His body was trembling beyond control. He was almost dead. He must have been suffering from an illness. That is not a unique case. <strong>When you go into an immense hospital, you see the innocence of the intelligent faces we encounter every day. You see that the only requirement is just to pray for another breath.</strong></p><p>You see people carrying those bags linked to their kidneys hanging from their waist to knees. You see people of almost all age groups waiting and sitting on uncleaned floors in a hope for their recovery or just to hear what they fear-You have this a lifetime, you may never be cured. It is unnecessary to teach everyone —<strong> Life is not for granted, Your health is not for granted</strong>.</p><p>My mother punctuated it well in Hindi, which I write -Only those who have seen it in reality can understand it deeply. Otherwise, there’s no point in explaining it to someone who would dump life for money. But, who am I to pass judgment on someone, who am I to tell them.</p><p>It’s got to be their powerlessness or their greed.</p><p>These seven sins never leave any human body unless it dies.</p><p>If I continue to fear everyday what may happen next, I dig a path for sorrow and unhappiness. I’ll ruin the present.</p><p>I can’t wrap it up. I write to unravel this thread of my past that I eventually understood growing up. I leave it to my readers to give meaning to my few words and I hope this shed light on what lies behind everything we do every day.</p><p>We are not taught about the building blocks of our existence in schools, it is left on us how we are going to relate everything we see, we fear, we experience to what is truth.</p><p>It is often left in name of spirituality, which must be given an honor of ultimate understanding.</p><blockquote><em>Written by Juhie Chandra</em></blockquote><blockquote><strong>( </strong>Follow me for such more stories and writeups. You can also check out my twitter handle <a href="https://twitter.com/CerulianJ"><strong>CerulianJ</strong></a><strong> )</strong></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e0041cb266d7" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>