TactiCore is the beginning of a hobby platform that gives me a place to exercise my creative mind while deliberately putting myself in the shoes of the customers I serve in my 9-to-5. Tacti Journey is where I document the architecture choices, hands-on testing, wrong turns, and small progress leaps while I build it.
Right now:Wave 01 is approved and merged. Builds 01–06 are complete. Wave 02 architecture — Observables, extraction, correlation and interactive security context — is now being designed.
Problems I keep seeing
The features around the feature matter.
A product can have a great primary workflow and still be frustrating to operate. These are recurring gaps I have run into across tools I have used, supported, integrated with, or had to explain to customers. TactiCore is my chance to treat them as design requirements instead of afterthoughts.
01
The API is an afterthought
If something important can be done in the interface, I want a clear, documented API path for doing it programmatically. Integrations should not depend on hidden endpoints or special browser behavior.
02
Events are trapped inside
Important changes should produce useful events that other approved systems can consume. Creating, updating, assigning, changing status, and closing work are all meaningful—not just creation.
03
Management APIs are incomplete
Operational APIs are not enough. Administrators need supported ways to manage configuration, tenants, access, integrations, and other platform objects without turning every administrative task into a manual UI exercise.
04
Create without delete
Basic lifecycle symmetry matters. If the product lets me create an object, there should be a deliberate answer for how I retire, disable, archive, or delete it. “You can create it but not clean it up” is not finished functionality.
05
RBAC stops at three roles
Administrator, Analyst, and Viewer are useful starting points, not the end state. I want granular permissions separated from scope so organizations can eventually compose roles around how their people actually work.
06
Audit logs require translation
An audit log should tell a human what happened, who did it, where it applied, when it happened, and why. The technical evidence should still be there—but I should not need to decode JSON to understand the event.
07
Audit history is locked in the product
Audit data is operational data. I want it available through supported interfaces so it can be searched, retained, reported on, or consumed outside TactiCore when policy permits.
08
Documentation explains buttons, not operations
I need documentation that explains both sides: how to configure and manage the platform, and how to operationalize it day to day. An administrator and an analyst should each be able to understand the system they are responsible for.
09
Power without clarity
Advanced capability is useful only when people can understand what the system did and why. Explainability, consistent UX, sensible defaults, and progressive disclosure are part of the capability—not decoration around it.
Why TactiCore
Tactical precision at the center of an investigation.
The name grew out of how I think about security operations. My military background taught me the value of understanding the situation, keeping the right context, knowing who is responsible, and making deliberate decisions with incomplete information. TactiCore blossomed from that idea: tactical precision at the core of security operations.
My vision
The case is not a ticket. It is the durable story of an investigation.
I want TactiCore to preserve what arrived, what changed, who acted, what was discovered, why decisions were made, and how related activity connects over time. Analysts should be able to move quickly without losing track of where information came from or what happened to it along the way. Managers should be able to understand the work without reconstructing it from scattered tools. Integrations should interact through a robust API while obeying the same product rules.
That means multi-tenant isolation enforced below the UI; granular permissions separated from scope; explainable access decisions; durable domain events and human-readable audit history; preserved raw evidence; normalized Signals; observable extraction and correlation; durable Cases; assignments, tasks and evidence; powerful search; retention controls; reporting; and first-class APIs.
Meaningful state changes should become events. Audit, reporting, notifications and approved integrations can consume those events without each feature inventing its own version of history.
The modules ahead
A case-management platform built as deliberate capabilities.
I do not want one giant application where every feature reaches into every other feature. Each module should own its internals and expose explicit contracts so I can improve one area without destabilizing the whole platform.
01
Platform foundation
Application shell, design system, tenant and organization context, Teams/Pods, actor and authorization context, audit, notifications, and module registration.
BUILDS 01–06 COMPLETE
What is already in place
Build 01 established the responsive shell, semantic design tokens, module-driven navigation, shared object interactions and centralized time presentation. Build 02 added real tenant boundaries, Pods, human/service identities, granular permission + scope decisions, explicit denies, temporary access, scoped administration, impact previews, persisted state and a human-readable event trail backed by immutable events.
02
Data intake
Raw ingestion first, then mapping and Signal normalization. Preserve the original vendor-shaped source data and its history before interpreting it.
Builds 03–05 complete
Webhook and Direct Email intake now preserve real source evidence, then explicit versioned Processing Profiles map it into normalized Signal meaning. Email uses TactiCore-owned receive-only addresses with sender trust; Gmail remains optional. Interpretation comes after preservation so the original is never lost.
BUILDS 03–05 COMPLETE
03
Signal operations
Signal core, triage, bulk operations and ingestion protection.
Build 06 complete
Real tenant-owned Signals now replace the synthetic preview. Analysts can filter actual intake by receiver, severity, processing state and time, open mapped or failed Signals, and drill from analyst-first meaning into exact technical evidence.
04
Security knowledge
Observables, extraction, tenant-scoped correlation, entity resolution and external references.
Wave 02 — planning now
Extract IPs, users, domains, hashes and hosts as tenant-scoped canonical Observables with role-aware Observations, exact source provenance, assessments that describe knowledge without changing behavior, and correlation that informs before explicit rules automate anything.
05
Investigation
Case core, Signal-to-Case relationships, investigation workspace, tasks, templates, evidence and preservation.
Builds 09–12
Turn Cases into durable investigation records rather than tickets. Connect Signals without erasing their independent history, support team/person ownership, investigation work and templates, and distinguish preserved evidence from temporary context.
06
Discovery and analyst work
Interactive security objects, global search, saved views and My Work.
Builds 08, 14 and 15
Make recognized security objects interactive everywhere, add full-text and entity-aware discovery, preserve useful saved views, and give analysts a focused view of assigned work and team-owned work without losing tenant context.
Keep analyst assessments attributable, build tenant-specific security knowledge, expose ingestion health and controls, define retention by data class, and create reporting foundations for operational and customer-facing views.
08
Event stream and audit
Meaningful changes produce durable domain events and understandable history.
FOUNDATION COMPLETE
Established in Build 02
Meaningful access changes already emit versioned immutable events with actor, tenant/scope, object, recorded/effective time, reason and before/after context. The Event Trail translates that evidence into plain English while keeping the original technical record available.
09
API as a first-class surface
A robust API should expose core capabilities while preserving the same authorization and tenant boundaries.
A platform-wide rule
The browser should not get a privileged shortcut around the architecture. As modules become real, their useful operations should be available through explicit server contracts so integrations and approved clients can use the same guarded capabilities.
The story behind the reset
The first prototype proved AI could build a lot. Then it proved why that wasn't enough.
This project did not begin with a clean architecture diagram. It began as an experiment: could increasingly capable AI models turn a case-management idea into a real security product? Each generation got further. Eventually the prototype became useful enough that the harder question changed from “can AI build this?” to “can we keep improving what it built without creating a tangled mess?”
From one-prompt curiosity to something worth taking seriously
My original goal was case management. Over time the experiment accumulated ingestion, investigations, API connections, credentials, workflow concepts, automation, and increasingly serious UX. The capability was exciting, but every new success made the structural weaknesses more expensive.
The lesson wasn't that AI had failed. It was almost the opposite: AI could build fast enough that architecture became the limiting factor.
Too many responsibilities were growing together
The prototype had accumulated too many responsibilities inside one evolving system. A change to credentials could affect workflow behavior; a case-management UX decision could drag automation concerns with it. The project could keep accumulating features, but that was not the same thing as becoming a maintainable product.
I stopped coding and started asking one architecture question at a time
I began the rebuild with boundaries rather than implementation. TactiCore became the clear focus: a security-operations and investigation product with explicit module boundaries and contracts.
Then “modular” was made concrete. Modules own their internals. Cross-module behavior goes through explicit contracts. Tenant ownership is a security boundary. Shared platform capabilities must actually be shared. UI components and semantic design tokens are modular too.
Prompt → build → use it → polish → approve
Instead of another giant implementation prompt, the platform was decomposed into bounded progress leaps. Only one detailed module specification is active at a time. A build can pass every automated check and still be unfinished until I use it myself and decide the experience is ready.
Later modules are not allowed to hide defects in earlier ones. If the foundation is weak, stop and fix the foundation.
Wave 02 approved • Sep 26, 2026
Signals became security memory — and the interface finally found its identity.
Wave 02 moved TactiCore beyond intake and triage: realistic vendor events can normalize through OCSF Mapping Packs, security objects are extracted and correlated inside the tenant, Home and Signals became drillable operational workspaces, and hands-on review forced a complete visual reset before Case Core begins.
Wave 02 in practice
A CrowdStrike-shaped event can arrive and become useful analyst context without hand-mapping every field.
TactiCore now recognizes bounded proof families for CrowdStrike Falcon, Okta System Log and Microsoft Entra ID Protection, applies a pinned Mapping Pack, normalizes supported meaning into OCSF 1.9, preserves the exact original independently, and feeds vendor-neutral extraction downstream.
A realistic Falcon event produced a Signal with user, device, IP, domain and file-hash context. Repeated security objects become tenant-scoped Observables with role-aware history instead of disconnected strings. Correlation informs the analyst; assessments record knowledge without secretly blocking, suppressing or automating anything.
The visual work changed too. The first “polish” technically passed and still looked generic. We rejected it. The replacement Home and Signals workspaces use a much more visual command-center language, and their metrics now drill directly into visible, editable Triage filters instead of behaving like dashboard wallpaper.
Responsive means recompose, not “shrink the desktop until it fits.”
The access experience is tested at phone widths too. That matters now, while the shared shell and components are still young enough to improve centrally instead of becoming dozens of one-off fixes later.
How this gets built
Small leaps. Real gates.
I am deliberately resisting the temptation to ask AI to create the whole platform in one heroic run.
01
One bounded build
Plan a coherent slice small enough to understand, test, criticize, and improve.
02
I use it myself
Passing tests is not approval. I use the actual experience, find what feels wrong, and fix it before I let the next module depend on it.
03
Stabilize, then move
Polish the current build, lock the useful contract, and only then let the next capability depend on it.
UX is architecture too
“Make it modular” applies to the pixels.
One of the strongest planning decisions was refusing to treat UX as something to fix after the backend. Shared visual behavior is supposed to be defined once and inherited everywhere.
01
Semantic tokens
A header consumes a concept such as surface.header, not a random hex value. Change the shared token and compliant headers change together.
02
Context over navigation
Recognized IPs, users, domains, hashes, hosts, and external references should behave consistently wherever they appear. Investigating something related should not destroy the analyst's working context.
03
Progressive disclosure
TactiCore can be powerful without displaying every capability simultaneously. Complexity stays available through contextual menus, drawers, detail panels, and drill-down when the analyst needs it.
Build 01 in practice
Hands-on testing changed the product.
The shell was not approved simply because it rendered. Hands-on use exposed responsive layouts that needed real recomposition, synthetic SOC data that needed more fidelity, and repeated security objects that needed useful context without forcing navigation away from the current Signal.
That feedback became shared behavior: responsive navigation, centralized time and timezone presentation, reusable object interaction, richer Signal context, and a design foundation meant to improve globally rather than screen by screen.
Why this matters later
Good patterns become infrastructure.
When a broadly useful interaction becomes good, the question is not “where else should we copy this?” It is “which token, primitive, shared component, or interaction contract should own it?”
That is the practical meaning of modularity in the interface—and one of the main reasons this platform was restarted instead of endlessly patching the earlier prototype.
Build journal
What happened, not just what shipped.
The “make it impressive” request failed once — so we stopped and redesigned the visual foundation
The first Wave 02 polish passed its automated checks and still looked almost like the old application. That was not good enough. Instead of letting another dozen modules inherit a visual language I did not want, we stopped before Case Core and reset the design direction.
The new Home and Signals experiences finally landed where I wanted: a darker command-center feel, stronger visual hierarchy, more color, modular instruments, and security objects that feel like things you investigate rather than ordinary text fields. Just as important, the dashboard is operational now: clicking severity, processing state, or other supported summaries drills into Triage with the filter visibly carried forward.
A screenshot can pass every test and still fail the product. Visual acceptance became a real gate, not a side effect of browser automation.
Stop making customers map obvious vendor fields
I hated the mapping experience even though I wanted the escape hatch to exist. So TactiCore standardized on OCSF as its canonical normalized event model and added deterministic, versioned Mapping Pack proofs for bounded CrowdStrike Falcon, Okta System Log, and Microsoft Entra ID Protection event families.
We also stopped demonstrating the platform with toy “headline + severity” JSON. The test corpus now uses vendor-shaped synthetic events based on real documented structures. In hands-on review, a realistic CrowdStrike event traveled through Webhook Intake → Processing → Mapping Pack → OCSF → Signal → Security Context without me manually teaching TactiCore the obvious fields.
The mapper stays for custom sources. The normal experience for a known product should be review, not data-entry homework.
Signals stopped being isolated records
Wave 02 added bounded Bulk Jobs and ingestion protection, canonical tenant Observables, deterministic extraction, tenant-local correlation, append-only assessments, interactive security objects, and a more capable safe-mail reconstruction. The same hash or domain can appear once as a canonical object while still preserving the different contexts in which it was observed.
Hands-on review kept behavior deliberately conservative: correlation does not create Cases or trigger actions, and marking something benign or malicious records knowledge only. If TactiCore eventually blocks, suppresses, allowlists, notifies, or automates, that must be an explicit separate policy or action.
Builds 04–06 became one usable vertical slice
Email Intake, Processing Profiles, and Signal Core/Triage were implemented sequentially but reviewed as one system. Owner testing corrected a Gmail-centric design into TactiCore-owned receive-only Direct Email, proved spoof/unlisted sender and relay rejection, durable deduplication, processing failure preservation, real triage filters, tenant isolation, restart persistence, and Windows command usability.
UX review then moved normalized analyst meaning ahead of receipt JSON, made profile mapping sample-driven, separated the reporting email from the attached reported phish, and advanced a bounded Safe Content Inspection capability that creates inert PNG reconstructions without executing hostile HTML or contacting attacker infrastructure.
Wave 01 proved the new rhythm: modules stay independent, engineering keeps moving through a bounded wave, and the owner reviews the integrated experience before merge.
One palette file changed the entire application
The Journey site's black-and-green visual language became a deliberate test of the modular UI architecture. The application-wide identity changed centrally with zero module-local color edits, proving the semantic-token strategy was real rather than aspirational.
Webhook Intake became the first real Signal source
Tenant-bound receivers gained stable routes, optional authentication, credential rotation, Activity, lifecycle controls, preserved payloads and real Signal creation. Hands-on testing covered malformed data, authentication failures, disable/enable, URL regeneration, rotation overlap, profile snapshots and concurrent edits.
Build 03 is complete and merged. It is historical foundation now—not the current planning phase.
Authorization moves below the UI
The second build established the authorization foundation and was exercised through hands-on review. Ten synthetic identities exercise different combinations of role, Pod membership, direct grants, hierarchy grants, temporary access, explicit denies, scoped administration, and lifecycle state.
I reviewed it hands-on: I switched identities, attempted protected reads and mutations, inspected why access existed, previewed changes, suspended an analyst, advanced the deterministic review clock, and inspected the resulting event trail.
The architectural bet: permission answers what; scope answers where. Role names are bundles, not the security mechanism.
The shell survived contact with a human
The first build established the application shell, semantic design tokens, shared primitives, module-driven navigation, contextual security-object behavior, and shared time presentation. Hands-on testing forced responsive recomposition and more realistic synthetic SOC data before approval.
A technically correct capability with a weak workflow is unfinished. UX is part of the feature, not a cleanup phase.
We stopped building the giant thing
The earlier prototype proved that AI could create a surprising amount of product. It also proved that piling case management, automation, credentials, workflows, and UI into one evolving mass makes every later change harder.
My answer was not “prompt harder.” I reset around explicit modules, public contracts, tenant boundaries, and review gates.
The rebuild gets a deliberate foundation
I created a clean repository to rebuild TactiCore around explicit module ownership, public contracts, tenant boundaries, and a shared design system instead of continuing to patch the earlier prototype.
Hands-on review • Build 02 approved
The tests passed. The audit log still wasn't good enough.
Build 02 is now approved, but the most useful part of the review happened after the automated suite was already green.
I tested authorization as a person, not just as a test suite.
I moved through real scenarios one at a time: a Platform Administrator could reach Bob; Joe inherited Pod Alpha access to Acme but an explicit Bob deny overrode his Pod access; Sam could read but not mutate; a scoped Acme administrator could administer Acme without becoming a global administrator; and Pod membership by itself granted nothing.
I then changed authorization live. Joe's deny was previewed before removal, the impact was explained, and the next protected request changed from 403 to 200 without a restart. Jane was suspended, her existing work surfaced a handoff requirement without silently rewriting work status, and restoring her to Active restored the grants that suspension had preserved.
The evidence was excellent. The experience was not.
The Event Trail faithfully preserved immutable event type, actor, scope, reason, timestamps, revision, and before/after state. Technically, it was strong. But understanding what happened required opening raw JSON and mentally translating event identifiers such as context.actor.lifecycle.v1.
Authoritative audit data is not the same thing as an understandable audit experience.
JSON became evidence instead of the interface.
Build 03 stayed locked. The only authorized polish was the Event Trail. Events now lead with a plain-English action and meaningful change, keep reason and metadata visibly separate, and place the original immutable identifiers and before/after JSON behind View technical details. Unknown future event types degrade safely instead of inventing a story.
I retested the result and described the Event Trail as beautiful. Only then was Build 02 approved and merged.
What Build 02 leaves behind
A real operating context for everything that comes next.
TactiCore now has server-enforced tenant boundaries, Pods and responsibility, durable human and service identities, permission bundles separated from scope, exact/subtree/temporary grants, explicit-deny precedence, scoped administration, explainable decisions, impact previews, lifecycle behavior, persisted state, and immutable event history.
Those aren't flashy investigation features yet. They're the rules future Signals, Cases, ingestion, search, reporting, and integrations will have to obey.
The process worked
Green tests did not get the final vote.
The implementation arrived with strict compilation, architecture checks, server authorization tests, browser tests, responsive checks, and accessibility coverage. I still found something worth fixing when I used it myself.
That is why this project has gates: Plan → Build → Test it myself → Polish → Approve → Stabilize → Next.
Up next — Build 10 preparation
From security memory to Cases.
Wave 02 is owner-approved and merged. The next bounded build is Case Core + Signal/Case Relationships: durable tenant-owned Cases, explicit relationships to existing Signals, Team/person ownership semantics, lifecycle and audit contracts — without prematurely building the entire investigation workspace. The same rule still applies: prepare the boundary, build the smallest coherent slice, use it hands-on, then decide what earns the next dependency.