Date: 2026-06-28 Author: cs-chief-of-staff (on behalf of the founder) Status: UNDER REVIEW
Authorized offensive-security work — bug bounty hunting, penetration testing, red-teaming, and continuous attack-surface management (ASM) — depends on reconnaissance: discovering an organization's internet-facing assets (subdomains, IPs, ports, services, web apps, technologies, secrets, and exposures). Today that work is fragmented across dozens of best-of-breed CLI tools (ProjectDiscovery's subfinder/httpx/naabu/nuclei/katana/dnsx, OWASP Amass, BBOT) glued together with brittle bash pipelines (reconFTW) or run through self-hosted web UIs (reNgine / reNgine-ng).
The incumbent self-hosted web platform, reNgine, proved the demand — but in 2025 it shipped multiple broken-access-control / authentication-bypass CVEs, exposing that "recon platform" and "secure software" are too rarely the same thing. Commercial workflow platforms (Trickest) and distributed-scan tooling (Axiom/ax) are powerful but are either closed/hosted or require deep DIY assembly.
There is a clear gap: a self-hosted, secure-by-design, enterprise-grade platform where an authorized researcher brings their own API keys and own tools, and the platform automates the entire recon pipeline end-to-end with a polished, reliable UI — without the researcher surrendering their data to a SaaS or hand-rolling orchestration.
ReconForge is a dual-use security tool. Its legitimate users are authorized researchers operating under bug-bounty scopes, signed pentest engagements, or on assets they own. The same capability can be abused for unauthorized scanning. Therefore authorization, scope enforcement, and abuse prevention are not features bolted on later — they are core architecture. This is both the right thing to do and the single biggest differentiator versus existing tools.
Should we build ReconForge, and if so, at what scope and architecture for v1 — given that it is a dual-use security tool that must be enterprise-grade, secure-by-design, and abuse-resistant from day one?
-
Option A — Full Enterprise Platform, Big-Bang Build. Build the complete vision up front: multi-tenant SaaS-grade control plane, distributed/ephemeral scan fleets (Axiom-style), Temporal orchestration, full RBAC + SSO, marketplace for community tool adapters, continuous monitoring, and a polished UI — all before first release. Highest ceiling, highest cost, slowest to first value, largest attack surface to secure at once.
-
Option B — Secure Walking-Skeleton MVP, then Scale (RECOMMENDED). Ship a self-hosted, single-tenant-first product that does the whole pipeline well for one authorized user/team via
docker compose up. Reuse proven OSS scanners (MIT/Apache); build only the differentiated core: the DAG orchestrator, the Authorization & Scope Engine, the BYO-key/BYO-tool adapter system, and a polished React UI. Security controls (authn+TLS by default, server-side authz, scope enforcement, audit log, encrypted secrets) are in the walking skeleton from commit one. Architect the seams (Temporal, typed-event model, worker isolation) so multi-tenant + distributed scale is a later increment, not a rewrite. -
Option C — Do Nothing / Adopt-and-Contribute. Don't build a new platform. Use or fork an existing one (reNgine-ng or a reconFTW + ProjectDiscovery + Axiom assembly), and contribute upstream. Zero build cost; inherits others' architecture and security posture (including the access-control class of bugs); no differentiation; no control over the authorization model.
- The operator is an authorized security researcher (bug-bounty participant, contracted pentester, or asset owner). The product's job is to make authorized use easy and unauthorized use hard, not to police a determined bad actor who controls their own infra — but it must not be a turnkey abuse machine.
- Best-of-breed recon capability already exists as permissively licensed OSS (ProjectDiscovery suite, Amass, BBOT). Re-implementing scanners is wasted effort; orchestration, authorization, integration, and UX are where the value and the build effort belong.
- Self-hosting is a hard requirement: target users distrust sending recon data/keys to a third-party SaaS. Data and BYO-keys stay on the operator's infrastructure.
- "Enterprise-grade, polished, bug-free" implies: authenticated + TLS by default, RBAC, audit logging, automated tests (unit/integration/E2E), accessibility (WCAG 2.2 AA), reproducible Docker deployment, and documented SLOs.
- Initial team is small (founder + AI coding agents, or a 1–3 person team). Time and people are the binding constraints, not infrastructure cost.
- Time: First secure, self-hostable end-to-end release (v0.1 "walking skeleton") within ~10–14 weeks; feature-complete v1.0 within ~6 months.
- Money: Self-hosted and OSS-based. Near-zero external spend for the open-core build (compute is the operator's own). Optional later spend on code-signing certs, a managed CI, and a third-party security audit before any 1.0 GA (~$15–40K for an external pentest of our own platform — non-negotiable given the dual-use nature).
- People: Small. Cannot staff parallel multi-tenant + distributed + UI tracks simultaneously at quality; must sequence.
- Reversibility: Most product choices are two-way doors (tools, UI components, individual adapters). Three choices are effectively one-way doors: (1) the core orchestration engine (Temporal vs custom queue), (2) the authorization/scope-enforcement model and data model, and (3) the open-source license + dual-use positioning. These three deserve the most boardroom scrutiny.
- cs-ceo-advisor — strategic framing, dual-use positioning, "why us / why now"
- cs-cto-advisor — architecture, scaling cliff, build-vs-buy, orchestration choice
- cs-ciso-advisor — threat model, blast radius, abuse prevention, secure-by-design (the reNgine lesson)
- cs-general-counsel-advisor — CFAA/legal liability of a dual-use tool, OSS licensing, terms of use, safe-harbor alignment
- cs-cpo-advisor — JTBD, who is this for, what to cut, kill criteria
- cs-cfo-advisor — cost structure, build effort, sustainability / open-core economics
- cs-cmo-advisor — (secondary) positioning vs reNgine/Trickest
- cs-vpe-advisor — (secondary) how to ship it bug-free with a tiny team
- cs-chief-of-staff — synthesis
Measured at v0.1 (walking skeleton) and v1.0:
- S1 (Pipeline): A user runs the full recon DAG (scope → subdomain enum → DNS → ports → web probe → crawl → screenshot → nuclei → secrets → dedup → report) on an authorized target end-to-end from one UI action, with resumable/observable execution. (v0.1: ≥6 stages; v1.0: full pipeline.)
- S2 (Authorization): Zero scans execute against a target the operator has not passed scope/authorization checks for. Out-of-scope assets discovered mid-scan are blocked from active probing and flagged. Verified by an automated abuse-prevention test suite. (Hard gate.)
- S3 (Secure-by-design): Ships authenticated + TLS by default; passes our own OWASP ASVS L2 checklist and a third-party pentest with zero Critical/High findings before 1.0 GA. No access-control bug of the reNgine class (every server endpoint enforces object-level authz server-side).
- S4 (BYO extensibility): A user adds their own API key (≥5 providers: Shodan, Censys, SecurityTrails, Chaos, VirusTotal) and registers ≥1 custom tool via the adapter manifest without code changes to core; keys are never persisted in plaintext.
- S5 (Polish/quality): WCAG 2.2 AA on core flows; ≥80% backend unit coverage on the authz/scope engine; green E2E suite on the golden-path scan;
docker compose upto working instance in <10 min on documented hardware.
What would tell us in ~90 days this was the wrong call (and the action):
- K1: We cannot enforce scope/authorization reliably — i.e., the abuse-prevention test suite cannot reach near-zero out-of-scope execution without crippling legitimate use. → Stop / redesign the authorization model before any further feature work. (This is the existential one.)
- K2: Orchestration reliability is unacceptable — pipeline runs are flaky/non-resumable and engineering spend on the engine exceeds ~40% of total for two consecutive months. → Reassess build-vs-buy on the orchestrator (Option B's one-way door).
- K3: No differentiation realized — by v0.1 we are not measurably more secure or more usable than reNgine-ng for the target user. → Revert to Option C (adopt-and-contribute).
- K4: Legal/abuse exposure judged unacceptable by counsel even with guardrails (e.g., the dual-use positioning creates liability we can't mitigate via ToU + technical controls). → Halt public distribution; keep private/internal only.
Routing: this brief proceeds to /cs:boardroom for 6-phase deliberation (Phase 2 isolation), then to the founder for a go/no-go decision.