<?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 Codeward on Medium]]></title>
        <description><![CDATA[Stories by Codeward on Medium]]></description>
        <link>https://medium.com/@info_51405?source=rss-0b9ee46ee603------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*SzP0FhDa85otRNuwTEdmiw.png</url>
            <title>Stories by Codeward on Medium</title>
            <link>https://medium.com/@info_51405?source=rss-0b9ee46ee603------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 07:43:25 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@info_51405/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[We built a scanner. Then we found out the hard part was the data.]]></title>
            <link>https://medium.com/@info_51405/we-built-a-scanner-then-we-found-out-the-hard-part-was-the-data-806ada51c199?source=rss-0b9ee46ee603------2</link>
            <guid isPermaLink="false">https://medium.com/p/806ada51c199</guid>
            <category><![CDATA[vulnerability]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[information-security]]></category>
            <category><![CDATA[security]]></category>
            <dc:creator><![CDATA[Codeward]]></dc:creator>
            <pubDate>Wed, 12 Aug 2026 05:42:37 GMT</pubDate>
            <atom:updated>2026-08-12T05:42:37.827Z</atom:updated>
            <content:encoded><![CDATA[<h3>Part 2 of why we built Codeward and why our scanner now reads its vulnerability data from our own intelligence database</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wVPUTclXavvHYQOUIgatuQ.png" /></figure><p>Our first post here was about why we built Codeward: enterprise governance tools cost more than our runway, the open-source pieces didn’t fit together, and we got tired of stitching. That post ended with “we built the tool we wished existed.”</p><p>There was a part we skipped over.</p><p>The scanner shipped with a bundled trivy-db. It worked. It was also somebody else’s database, baked into our binary, and we couldn’t answer basic questions about it.</p><p>A developer would ask why a package got flagged. We’d say “it’s in the database.” They’d ask which database, and where that entry came from, and whether the severity was NVD’s opinion or GitHub’s, because those two often disagree. We didn’t know. The bundle had already picked a winner and thrown the argument away.</p><p>That bothered us more the longer it went on. We’d built a governance tool whose entire premise is that you should be able to see why something is being blocked. And the most important input to that decision was a black box we shipped inside our own binary.</p><h3>Three things that kept coming up</h3><p><strong>Somebody has to break the tie, and it’s usually invisible.</strong> Here’s a real one out of our own data: CVE-2026–33036, an entity-expansion bug in fast-xml-parser. NVD, GHSA and OSV all rate it HIGH. Red Hat rates it MEDIUM. Four sources, one dissent. Most tools hand you a single severity with no sign there was ever an argument.</p><p><strong>“Is there a CVE” is the easy question.</strong> The one people actually ask is “does this matter to us, this week, in this service.” Here’s the shape of it: of the roughly 894,000 vulnerability records we track, 4,230 have a known public exploit and 1,661 are on CISA’s exploited list. Half a percent, and a fifth of a percent. A CVE count tells you almost nothing. The thin slice that matters is spread across feeds nobody joins for you.</p><p><strong>CI is where free tiers die.</strong> Query a public vulnerability API from every runner on every build across every repo and you find the rate limit fast. The usual fix is to pay someone. The other fix is to download a bulk dump and re-plumb it yourself, which is a second product you didn’t want to build.</p><h3>So we built the join</h3><p>Codeward Intel currently runs 25 sources and agents. The vulnerability side is NVD, OSV, GitHub Advisories and Red Hat’s CVE feed. Severity and exploitability come from EPSS, CISA KEV, and proof-of-concept data aggregated from Exploit-DB, Nuclei templates and GitHub. Licences come from the SPDX list, ScanCode LicenseDB, choosealicense.com and the OSADL compatibility matrix. Package facts come from the registries, deps.dev, GitHub repo metadata, endoflife.date and OpenSSF’s malicious-package database. Weaknesses come from MITRE CWE.</p><p>Right now that’s about 879,000 vulnerability records, 370,000 packages, 1.5 million versions, 2,435 licences and 969 CWEs across ten ecosystems.</p><h3>Show the working</h3><p>Every field keeps its sources attached. That same advisory, asked for its provenance, gives you the working rather than just the answer:</p><pre>{&quot;field&quot;: &quot;severity&quot;,<br> &quot;value&quot;: &quot;HIGH&quot;,<br> &quot;winner_source&quot;: &quot;nvd&quot;,<br> &quot;strategy&quot;: &quot;priority&quot;,<br> &quot;candidates&quot;: [<br>   {&quot;source&quot;:&quot;nvd&quot;,    &quot;priority&quot;:90, &quot;value&quot;:&quot;HIGH&quot;, &quot;winner&quot;:true},<br>   {&quot;source&quot;:&quot;ghsa&quot;,   &quot;priority&quot;:80, &quot;value&quot;:&quot;HIGH&quot;},<br>   {&quot;source&quot;:&quot;osv&quot;,    &quot;priority&quot;:80, &quot;value&quot;:&quot;HIGH&quot;},<br>   {&quot;source&quot;:&quot;redhat&quot;, &quot;priority&quot;:80, &quot;value&quot;:&quot;MEDIUM&quot;}]}</pre><p>NVD wins because it outranks the others, 90 against 80, and strategy names the rule that decided it here priority, elsewhere longest value or union across sources. Red Hat’s dissenting MEDIUM isn’t thrown away. It stays in the record where anyone can see it and disagree with us.</p><p>The more interesting field on that same CVE is affected_packages. NVD wins severity and returns <strong>null</strong> there — it has nothing to say about which versions are affected. OSV and GHSA both have the range. Red Hat has neither the range nor the same severity, but it does have the RHSA advisory and the fix state per RPM.</p><p>No single one of those four is the answer. That is the entire argument for merging rather than picking a favourite, and it’s why we stopped trying to find the one good source.</p><p>There’s an endpoint that lists the fields where sources currently disagree, which is how we found this example. You can check it yourself — <a href="https://intel.codeward.io/api/v1/vulnerabilities/CVE-2026-33036">public URL</a>, no key.</p><h3>Deciding what to do, not just how bad it is</h3><p>Severity tells you how bad a bug is. It doesn’t tell you what to do on Tuesday. So every vulnerability also carries an SSVC decision. CISA’s Stakeholder-Specific Vulnerability Categorization which comes out as one of four actions: Track, Track*, Attend, Act.</p><p>The fast-xml-parser CVE resolves to <strong>Attend</strong>: <em>“remediate sooner than your next regular cycle; involve whoever owns this dependency.”</em> The decision points that got it there are shown rather than implied — exploitation: none, automatable: yes, technical impact: total. Its exploit maturity is tracked separately, because “someone published a proof of concept” and “someone weaponised it” are not the same Tuesday.</p><p>Underneath that sits the line we’re proudest of:</p><p><em>“Derived from attacker-side signals only (KEV listing, exploit maturity, EPSS, CVSS vector). It does not know your deployment, so mission and exposure are still yours to weigh.”</em></p><p>We can compute the half of SSVC that comes from the attacker’s side. We cannot compute the half that depends on what your service does and who can reach it, and a tool that pretended otherwise would be quietly lying. So it says so, on every record.</p><p>That action also lands in the list view, which is the part that actually changed how we work. You can sort a live vulnerability feed by what to do about it instead of by CVSS.</p><h3>Aggregating isn’t the interesting part</h3><p>Once the join existed, we had a pile of facts about a package and still no opinion. That’s where the actual work turned out to be — and it’s the difference between a database and something you’d let block a build.</p><p>Take langchain. The raw fact is “24 advisories, 15 of them critical.” That number on its own tells you to panic, and it would be the wrong reaction.</p><p>What we compute on top of it: a track record grade, with the sentence behind it — <em>“24 advisories over 3.8 years, 24 of them with a published fix, weighted for recency and normalised by how widely the package is used.”</em> The grade is poor. But the median time from disclosure to fix is <strong>one day</strong>. That’s not a neglected package. That’s a fast-moving one with a lot of surface, maintained by people who turn fixes around in 24 hours, and no single number expresses that.</p><p>Then it resolves the advisories against the version you’d actually install, rather than counting them. lodash has ten advisories on record and the page says so plainly: none of them affect the current release. The scary number and the actionable number are different numbers, and most tools only show you the scary one.</p><p>It also walks the tree. langchain has 22 known vulnerabilities directly and <strong>64 in its transitive dependencies</strong>, across 5 distinct licences — one of which is the SPDX expression MPL-2.0 AND (Apache-2.0 OR MIT), because real dependency trees are not tidy.</p><p>The score itself is four weighted dimensions — vulnerability out of 60, maintenance out of 25, licence out of 20, popularity out of 15 — each with its own subtotal, under a versioned rule set, so the same inputs give the same number and you can tell when we changed our minds.</p><p>And the field we’re most attached to is unmeasured. If a factor has no data behind it, it doesn’t quietly score zero and drag the total down — it’s named as unmeasured and the confidence drops. langchain sits at medium confidence for a specific, stated reason: <em>“One advisory’s version range could not be parsed for this ecosystem, so the exposure factor is partly an estimate.”</em></p><p>A zero we measured and a zero we invented look different, because they are different. If you only take one idea from this post, take that one.</p><p>Some of what fell out was uncomfortable. lodash is one maintainer and 167 million weekly downloads. We track release-cadence anomalies — a package dormant for a year that suddenly ships — because that shape turns up before a lot of account takeovers. And when a package is on a malware feed it says so at the top with the report ID and every affected version listed, rather than leaving it to a risk number.</p><h3>The part we didn’t expect</h3><p>We thought the API was the product. It isn’t.</p><p>Once Intel existed, the obvious move was to have the scanner call it. We did that, and it worked, and then it nagged at us. We’d replaced a database we didn’t control with an API we did control. Better for us. Not obviously better for you. Your build pipeline now depended on our uptime, and you needed a key, and we were one product decision away from putting a login in front of it.</p><p>So we did the other thing.</p><p>The scanner now reads its data from files instead of calling anything. Signed SQLite snapshots, published as release assets at <a href="https://github.com/codeward-io/intel-db">github.com/codeward-io/intel-db</a>, rebuilt on a schedule.</p><p>The corpus is about 2 GB across 22 segments, and it’s split so you only take your own ecosystem. A Go project pulls four segments — core, CWEs, Go packages, Go advisories — which is about 8 MB compressed. A Python project is about 12 MB, Maven about 7 MB. npm is the honest exception at roughly 88 MB, because npm genuinely is most of the corpus.</p><p>Every segment is checksummed into a manifest, and the manifest is Ed25519-signed. Verification is on by default. The attribution for the CC-BY sources is carried inside that signed manifest too, so the credit travels with the data instead of living on a page someone forgets to copy.</p><p>And for CI you don’t re-download any of it. Once you have a baseline there’s a delta endpoint that returns only what changed since a timestamp:</p><pre>curl &quot;https://intel.codeward.io/api/v1/db/delta?segment=vulnerabilities&amp;since=2026-04-01T00:00:00Z&quot;</pre><p>No key. No rate limit. No account. It works in air-gapped environments, because after the first download there’s nothing left to reach.</p><p>We kept the API too, and it’s public and needs no signup:</p><pre>curl https://intel.codeward.io/api/v1/packages/npm/lodash/assessment</pre><h3>What this is</h3><p>A vulnerability, package and licence database you can use without asking us for anything. Query it over HTTP, or download the SQLite files and never talk to us again. It feeds our scanner. It’ll feed yours — the API doesn’t know whose client is calling, and the snapshots are just SQLite.</p><p>There’s also just a website, and every filter lives in the URL. <a href="https://intel.codeward.io/packages?malicious=true">/packages?malicious=true</a> is a live list of the 10,000-plus packages OpenSSF has confirmed malicious, sorted by weekly downloads, and it is a bracing thing to scroll. Search takes npm/lodash, CVE-2021-23337, MIT or CWE-79 and jumps straight to the record. And there’s an end-of-life view covering 29 runtimes and frameworks, which also shows up per package — lodash will tell you which Node versions still have support.</p><h3>What this isn’t</h3><p>It isn’t a new vulnerability source. Nearly everything in Intel comes from public feeds other people maintain, and we say which ones on every record. The work is in the joining, the tie-breaking and the delivery, not in discovering anything. There’s an attribution page that names who did the hard part.</p><p>It isn’t complete, and the gap is bigger than we’d like. About 403,000 of those 879,000 vulnerability records carry no severity from any source — that’s 46% sitting at unknown, and no amount of joining fixes it, because nobody upstream has rated them. Coverage is also thinner outside npm, PyPI, Go and Maven, and plenty of packages have no health data at all.</p><p>Some of it is model-generated and we label it as such. Plain-language summaries, remediation notes and reachability analysis come from LLM agents, and they carry a confidence field. We keep them strictly separate from the sourced facts, because a summary is not evidence, and we’d rather you knew which one you were reading.</p><p>It isn’t a replacement for a security programme. Same as last time.</p><h3>Mostly we want to know if it’s useful</h3><p>We built this because our own scanner needed it. We’ve been running on it for months and it solved our problem. That’s the entire basis on which we’re telling you about it — not market research, not a roadmap, just “this worked for us, maybe it works for you.”</p><p>If you try it and something obvious is missing, tell us. If you point your own scanner at it, we’d genuinely like to hear what broke.</p><p><a href="https://intel.codeward.io/">intel.codeward.io</a> · <a href="https://docs.codeward.io/docs/intro/">docs</a> · <a href="https://github.com/codeward-io/scanner">scanner</a> · <a href="https://github.com/codeward-io/intel-db">intel-db</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=806ada51c199" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why We Built Codeward: An Open-Source Code Governance Scanner]]></title>
            <link>https://medium.com/@info_51405/why-we-built-codeward-an-open-source-code-governance-scanner-4f9d261f65c7?source=rss-0b9ee46ee603------2</link>
            <guid isPermaLink="false">https://medium.com/p/4f9d261f65c7</guid>
            <category><![CDATA[information-security]]></category>
            <category><![CDATA[code-quality]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[code-scanning]]></category>
            <category><![CDATA[security]]></category>
            <dc:creator><![CDATA[Codeward]]></dc:creator>
            <pubDate>Mon, 09 Feb 2026 07:10:19 GMT</pubDate>
            <atom:updated>2026-02-09T17:05:47.692Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*m-roSkO3QlaSqwg8krRsCQ.png" /></figure><p>When enterprise solutions cost more than your runway and open-source alternatives leave you stitching together a Frankenstein of tools, sometimes you just have to build it yourself.</p><p>Now we’re sharing it in case others find it useful too.</p><p>This isn’t a product launch announcement. It’s more of a “hey, we made a thing” post.</p><p>Here’s the thing about code governance: it’s always been a problem. Developers pull in dependencies without checking licenses. Packages get added because someone on Stack Overflow said it worked. A library that seemed fine two years ago now has three CVEs. Kubernetes manifests get copy-pasted with default values that work in dev but break production. Code flows into repositories faster than anyone can review it properly.</p><p>This isn’t new. What’s new is the pace.</p><p>AI-assisted coding tools have accelerated everything. Code comes faster now, from Copilot suggestions, from vibe coding sessions, from developers moving at speed. More code, less supervision. The fundamental problem hasn’t changed, but the volume has.</p><p>We started thinking more seriously about code governance when we noticed packages appearing in our PRs that nobody explicitly chose to add. Someone hit Tab on an autocomplete suggestion, and suddenly we had new dependencies in our tree. Most of the time, that’s fine. But occasionally we’d discover a package with a license that didn’t fit our needs, or a dependency that had known issues.</p><p>So we went looking for tooling.</p><h3>What We Found</h3><h4>The Enterprise</h4><p>The application security space has some genuinely excellent tools. Snyk, Checkmarx, Veracode, and others have built comprehensive platforms that serve enterprise needs well. Our first call was great. The sales process felt like buying a car, except the car cost $150,000 annually.</p><p>The demo was impressive. Dashboards everywhere. Integrations with everything. The works.</p><h4>The Open-Source Maze</h4><p>On the open-source side, Trivy, ScanCode, Checkov, and Semgrep are powerful and battle-tested.</p><p>Okay, we thought, we’re engineers. We can assemble something ourselves.</p><p>The open-source ecosystem for code security is genuinely impressive. Trivy for vulnerability scanning. ScanCode for license detection. Checkov for IaC policies. Semgrep for custom rules. All powerful, battle-tested tools.</p><p>But integrating them into a coherent governance workflow? That is where things fell apart.</p><h4>The Real Problem</h4><p>Code governance isn’t just about finding issues it is about managing them. And the core challenge has existed for as long as developers have used third-party code:</p><p>When someone adds a dependency, do they check the license? Maybe. Do they look at the maintainer’s track record? Rarely. Do they verify there are no known vulnerabilities? Sometimes, if the tooling makes it easy. Usually, they just check if it works.</p><p>And it’s not just dependencies. Configuration files matter too. A Kubernetes manifest with the wrong resource limits can bring down production. A Dockerfile missing a security flag can expose your container. An API version that’s been deprecated will break on the next cluster upgrade. These aren’t hypotheticals, they’re Tuesday.</p><p>This was true before AI. It’s more true now. The Tab key is faster than due diligence.</p><p>We needed something that could:</p><ol><li><strong>Catch what changed.</strong> If a PR introduces a new critical vulnerability, block it. If the vulnerability existed last week and isn’t part of this PR, track it separately, but don’t block the developer who’s just trying to fix a typo.</li><li><strong>Be transparent.</strong> No black boxes. Show us exactly what rule was triggered, what the finding is, and why it matters. JSON output we can parse. Markdown comments we can read.</li><li><strong>Progressive enforcement.</strong> Start by informing developers. Then warn them. Then, when the team is ready, start blocking. Don’t go from zero to “all builds fail” overnight.</li><li><strong>Cost nothing to start.</strong> We can’t spend $100K validating whether a tool actually works for us.</li></ol><p>We looked everywhere. The tool didn’t exist.</p><h3>So We Built It</h3><p>Codeward started as an internal script. A wrapper around Trivy that compared findings between the base branch and the PR branch, filtered out anything that wasn’t new, and posted a clean comment on the PR.</p><p>We added license scanning. Then dependency analysis. Then custom validation policies, things like “ensure every microservice has a Dockerfile” or “block PRs that add deprecated API versions” or “require resource limits on all Kubernetes deployments.”</p><p>The internal script became a proper GitHub Action. The GitHub Action became a project. The project now has documentation, examples, and we want to grow a community around it.</p><h3>What Codeward Does (And Doesn’t Do)</h3><p>This is the core of what makes Codeward different, so let’s be precise.</p><p><strong>Codeward is a governance toolkit, not a scanner that dumps findings at you.</strong> It’s strictly configuration-driven, it makes no assumptions and does nothing out of the box. No automatic scanning. No default reports. No opinions about what matters.</p><p>You define three things:</p><ol><li><strong>What to check</strong> — the policy (vulnerabilities, licenses, custom file validations)</li><li><strong>What to do when something is found</strong> — info, warn, or block</li><li><strong>Where to send it</strong> — PR comment, GitHub issue, JSON file, webhook</li></ol><p>Without all three, nothing happens. This is intentional. You stay in control.</p><p>At its core, Codeward detects what has changed between two branches, usually main and the branch being merged into it. But it goes further than just “new vs existing.” It categorizes findings as new, existing, changed, or removed, and you can route each category differently.</p><p><strong>This is where the philosophy becomes operational:</strong> route new findings to PR comments to block the merge. Route existing findings to GitHub Issues for backlog tracking. The gate gets guarded. The graveyard gets documented, separately. Developers only see what’s relevant to their changes, not a mountain of problems they didn’t create.</p><h3>What Codeward IS</h3><ul><li>A governance toolkit where you define the policies</li><li>Strictly configuration-driven, zero assumptions, zero defaults</li><li>Diff-aware with smart routing: new → block, existing → backlog</li><li>Flexible outputs: PR comments, GitHub issues, JSON files, webhooks</li><li>Multiple formats: Markdown, HTML, JSON — whatever fits your workflow</li><li>A standalone Go binary with Trivy embedded, no complex dependencies</li><li>Open source (Apache 2.0), free forever for the core scanner</li></ul><h3>What Codeward IS NOT</h3><ul><li>A tool that finds all possible issues for you</li><li>A scanner that runs automatically without configuration</li><li>A replacement for comprehensive security programs</li><li>A tool that will make your existing 10,000-issue backlog disappear</li></ul><p>The philosophy is simple: <strong>guard the gate, not the graveyard.</strong> It’s not enough to detect issues, you need a system to govern them. Block new risks before they merge. Route existing debt to the right place. Give developers actionable feedback on the changes they actually made.</p><h3>How It Works</h3><p>Add this to your repository:</p><pre># .github/workflows/codeward.yml<br>name: Codeward<br>on:<br>  pull_request:<br>jobs:<br>  scan:<br>    runs-on: ubuntu-latest<br>    steps:<br>      - uses: codeward-io/scan@v0.1.0</pre><p>That’s it for the basic setup. No API keys. No SaaS signup. No enterprise sales call.</p><p>When a PR opens, Codeward checks out both the base branch and the PR branch, runs vulnerability, license, and policy scans on both, diffs the results, categorizes each finding, and routes them according to your configuration.</p><h3>Defining Rules</h3><p>You control what gets flagged. Here’s a rule that blocks new critical</p><pre>{<br>  &quot;vulnerability&quot;: [{<br>    &quot;name&quot;: &quot;critical-vulns&quot;,<br>    &quot;actions&quot;: { <br>      &quot;new&quot;: &quot;block&quot;, <br>      &quot;existing&quot;: &quot;info&quot; <br>    },<br>    &quot;outputs&quot;: [<br>      { &quot;destination&quot;: &quot;git:pr&quot;, &quot;changes&quot;: [&quot;new&quot;] },<br>      { &quot;destination&quot;: &quot;git:issue&quot;, &quot;changes&quot;: [&quot;existing&quot;] }<br>    ]<br>  }]<br>}</pre><p>The rule section filters what this policy applies to — in this case, only critical severity vulnerabilities. You can filter by severity, package name, license type, or any other attribute in the finding.</p><h3>Action Levels</h3><p>For each finding, you control the response:</p><ul><li><strong>info</strong> — display for awareness, no action required</li><li><strong>warn</strong> — flag it clearly, but don’t stop the merge</li><li><strong>block</strong> — exit with code 1, stopping the merge until it’s resolved</li></ul><p>That exit code 1 on block makes integration trivial, any CI/CD pipeline or pre-commit hook can catch it. No special plugins or integrations needed. Even if you don’t configure an output destination, a blocking rule will still fail the action, you’ll see why in the action logs.</p><h3>Running Elsewhere</h3><p>The GitHub Action is the quickest path to getting started, but Codeward is just a Go binary. You can run it anywhere: locally during development, in GitLab CI, in Jenkins, in a pre-commit hook. Check the<a href="https://docs.codeward.io/"> docs</a> for examples of different setups.</p><h3>Open Source, Not Open Core Theater</h3><p>Let’s be direct about our model.</p><p><strong>The scanner is open source. Fully.</strong> Apache 2.0 licensed. You can run it forever, on unlimited repos, with all policy types, completely free. No “community edition” with half the features missing. No artificial limits. No telemetry. Fork it, modify it, run it however you want.</p><p>We’re building this because we needed it. We’re open-sourcing it because we believe governance tooling should be accessible to teams of any size. The startup with three developers deserves the same ability to enforce standards as the enterprise with three thousand.</p><h3>What About the Cloud?</h3><p>We’re building a cloud platform for teams that want more:</p><ul><li>Centralized dashboards showing governance across all repositories</li><li>Historical trend analysis to track risk reduction over time</li><li>Team management and notification routing</li><li>Advanced policy templates for common compliance frameworks</li></ul><p>Let’s be real: cloud costs money to run. The cloud offering will have a cost, we’re still figuring out the right pricing, but it will be significantly cheaper than enterprise alternatives. Think tens of dollars per month, not tens of thousands per year.</p><p><strong>The core scanner will always remain open source and free.</strong> The cloud is for teams that want convenience and don’t want to build dashboards themselves.</p><p>Interested? <a href="https://forms.gle/JibSxYmiRSaZMB7Q8">Join the waitlist</a> and help us shape what we build.</p><h3>We Built This for Teams Like Ours</h3><ul><li>If you’re a startup that can’t afford $100K security tools, this is for you.</li><li>If you’re a platform engineering team trying to enforce standards across 50 repositories without blocking every build, this is for you.</li><li>If you’re watching code flow into your repositories faster than you can review it, this is for you.</li><li>If you want to catch misconfigurations before they hit production, this is for you.</li><li>If you’re tired of security theater and want governance that developers actually use, this is for you.</li><li>Give it a try. Star the repo if it helps.</li></ul><p><strong>We built the tool we wished existed. Now it does.</strong></p><h3>We’d Love Your Input</h3><p>This is early days. The tool works for our use cases, but we’re sure there are gaps and rough edges we haven’t encountered yet.</p><p>If you try it out and run into issues, we want to hear about it. If you have ideas for features that would make it more useful, tell us. If you want to contribute, the codebase is straightforward and we’re happy to review PRs.</p><p>The best place to reach us right now is<a href="https://github.com/codeward-io/scan/discussions"> GitHub Discussions</a>. We’re also considering Discord if there’s enough interest — let us know.</p><p>We’re not trying to build the next big security company. We’re just sharing something that’s been useful to us, in case it’s useful to you too.</p><p><strong>Try Codeward today:</strong></p><p>🔗 GitHub:<a href="https://github.com/codeward-io/scan"> github.com/codeward-io/scan</a> 📚 Docs:<a href="https://docs.codeward.io/"> docs.codeward.io</a> 🌐 Website:<a href="https://codeward.io/"> codeward.io</a> 📋</p><p><strong><em>Guard the gate, not the graveyard.</em></strong></p><p><em>Have questions? Found a bug? Want to contribute? Join the conversation on</em><a href="https://github.com/codeward-io/scan/discussions"><em> GitHub Discussions</em></a><em>. We’d love to hear how you’re using Codeward.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4f9d261f65c7" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>