← Back to projects

Bakas.
Follow the evidence.

A portfolio-scale SIEM that turns uploaded security logs into explainable alerts, investigations, and incident reports.

Focus
Tier 1 SOC workflows
Interface
React · TypeScript · Tailwind CSS
Backend
FastAPI · PostgreSQL
Bakas sign-in screen
The entry screen for an evidence-focused analyst workspace.

Why I built it

I wanted to put SOC concepts into practice through a working system. Bakas connects log analysis, detection rules, alert triage, and investigation notes so I can follow an event through to a documented decision.

Project goal

Build a manageable, end-to-end analyst workflow: upload security logs, inspect explainable detections, investigate the evidence, and turn related alerts into an incident report.

One investigation, from intake to hand-off.

  1. Bring the logs together

    CSV, JSON, and JSONL uploads are parsed and normalized into a common event schema. Field aliases handle inconsistent vendor names while the original raw log stays available.

  2. Make detections explainable

    Six configurable rules cover brute force, successful login after brute force, multiple failed logins, new account creation, suspicious PowerShell, and known IOC matches.

  3. Give the analyst context

    Filter and assign alerts, inspect raw and normalized events, reconstruct a timeline, and record a structured analyst assessment.

  4. Close the loop

    Link alerts into an incident, merge their evidence chronologically, record a resolution, and export a Markdown report.

Key screens

Actual captures from the local Bakas application, using fictional sample events. Select an image to view it full size.

Sign in

Bakas sign-in interface

The entry point to the analyst workspace.

  • JWT-based authentication with bcrypt password hashing.
  • Light and dark themes across the application.

Dashboard

Bakas dashboard with sample event totals, severity breakdown, and detection-rule chart

An overview of the current alert workload and recent activity.

  • Alert totals, severity breakdown, and a 14-day trend.
  • Alerts grouped by rule, top source IPs, and affected users.
  • Incident counts and recent activity feeds.

Alert triage

Bakas alert triage queue populated with fictional authentication and PowerShell detections

A focused queue for deciding what needs investigation.

  • Filter by severity, status, and detection rule.
  • Search, sort, assign an analyst, and add investigation notes.
  • Resolve alerts or mark false positives with a required reason.

Investigation

Critical successful-login-after-brute-force alert with evidence timeline

Move from an alert to the events that explain it.

  • A timeline combines evidence and surrounding context.
  • Inspect the original raw log and normalized event fields.
  • Record what happened, affected scope, and recommended action.

Incidents & reports

Keep related findings together and prepare a clear hand-off.

  • Link multiple alerts and review their merged timeline.
  • Track case notes, status, and a documented resolution.
  • Download a Markdown report containing evidence and response notes.

Log ingestion

Bakas log ingestion screen

Upload CSV or JSON logs, or load the bundled fictional samples.

Detection rules

Bakas detection rules screen

Review enabled detection rules, severity, and MITRE mappings. This screen is read-only.

Tech stack

React and TypeScript power the analyst interface. FastAPI connects file ingestion and rule-based detection to PostgreSQL, while Docker Compose brings the local stack together.

Simple rules.
Deliberate boundaries.

React + TypeScriptAnalyst workspaceFastAPIParse → Normalize → DetectPostgreSQLEvents · Alerts · Incidents

Test rules without a database

Detection rules operate on plain Python dataclasses. A service bridges database records to the engine, keeping detection logic independently testable.

Reduce duplicate work

The detection service skips alerts with the same rule and evidence event set. Re-running detection after another upload avoids identical findings in the queue.

Map only what the evidence supports

Technique-based rules use T1110, T1059.001, or T1136 where applicable. Generic IOC matches intentionally have no MITRE technique mapping.

The supporting stack

Recharts supports dashboard visualizations; React Router handles navigation. Authentication uses JWT and bcrypt. Docker Compose runs PostgreSQL, FastAPI, and an nginx-served frontend.

A failed login is an event. A sequence tells a story.

This example follows the bundled fictional Windows authentication scenario documented in the project.

  1. Load the sample

    Authentication events produce a high-severity brute-force alert and a critical successful-login-after-brute-force alert.

  2. Inspect the evidence

    Assign the critical alert, inspect the failed-login sequence and subsequent success, and complete the analyst assessment.

  3. Build the case

    Promote the alert to an incident and link related alerts. The timeline combines evidence into a deduplicated chronological account.

  4. Document the decision

    Record the resolution and export a Markdown report with related alerts, MITRE techniques, evidence, notes, and recommended response.

Small by design.
Clear about the trade-offs.

Bakas prioritizes an understandable investigation workflow over enterprise-scale infrastructure. Logs are uploaded as files, detection re-scans stored events, and authenticated users share a single analyst role.

Testing boundaries

The repository includes unit tests for parsing, normalization, detection rules, alert and incident business logic, and report formatting. API routes, database-dependent services, and the frontend rely on manual scenarios.

Next engineering steps

  • Database migrations for safer schema changes.
  • PostgreSQL-backed integration tests for API and query behavior.
  • Incremental ingestion rather than full-table re-scans.
  • Separate analyst and administrator permissions.