BrainGu

Why We'll Never Grow Up into a Traditional Defense Contractor (And That's Okay)

2026-02-16T00:00:00Z

The defense world has a gravity well. If you stay in it long enough, you tend to drift toward the same destination: staff augmentation, bodies-for-hours, and a business model optimized for capturing headcount instead of delivering capability.

BrainGu was built to fight that gravity. We treat product as the center of gravity, not labor. And we are not going to age out of that stance.

This isn't a philosophical preference. It's a practical one. The Department of Defense has been clear about where it wants to go: more speed, more commercial leverage, more modularity, and more continuous delivery. The Software Acquisition Pathway and the Warfighting Acquisition System reflect the same message. Leaders are being told to buy commercial when possible, cut layers, embrace iteration, and field capability faster.

None of that aligns with the classic GovCon labor model. Product companies are built for this future. Staffing companies are built for the past.

The GovCon Gravity Problem #

Start from first principles: staff augmentation is predictable revenue, but it scales linearly and delivers marginal returns to the mission. You get a contractor army, not a capability. You get more coordination overhead, not more outcomes.

Traditional defense firms know this and optimize for it. They are rewarded for labor volume, process adherence, and compliance theater. Innovation happens accidentally, not by design.

The Department's acquisition reform efforts call this out directly. They emphasize urgency, modular open systems, portfolio thinking, and rapid increments instead of fully baked requirements. None of that works if your business model is selling hours.

A product-first company can move with this shift. A labor-first company cannot.

Product-First Delivers 80 Percent, Immediately #

There is a common fear in government that a product company can only deliver 20 percent of what a program needs. The reality is the acquisition community itself has already made the opposite argument. Senior DoD leaders consistently push toward commercial solutions that satisfy the bulk of mission needs quickly, with the remaining gaps addressed through integration and continuous improvement.

A mature product organization that invests heavily up front can deliver the 80 percent solution on day one. Not because it cuts corners, but because it builds repeatable infrastructure, security, pipelines, documentation, and operator experience into the platform itself.

The last 20 percent becomes configuration, not reinvention. That is the entire point of productization: build once, deliver everywhere.

This is why SmoothGlue exists. We built the developer ecosystem, the secure pipeline, the compliance automation, the observability stack, the deployment patterns, and the user experience guardrails. No one pays us to rebuild them a thousand times. We build it once, then focus on the mission problems that actually require human brains.

Why Staying Agile Matters in Defense Contracting #

Three advantages define a product-first culture in this space.

1. Developer speed without sacrificing rigor #

The new acquisition frameworks prioritize speed with rigor. That is exactly how a platform behaves.

SmoothGlue can be deployed in under two hours. It reaches full configuration at high impact levels in days, not months. It already runs at IL4, IL6, IL6/REL, IL6/NF, IL6 Edge, and TS/SCI with full ATOs. Most programs fight for years to reach that bar.

Speed is something we design into the product, not something we negotiate.

2. Reduced headcount without reduced outcomes #

Traditional contractors scale by hiring more humans. Product companies scale by making humans more effective.

SmoothGlue supports USAF ABMS CBC2. It supports USCYBERCOM Unified Platform. It supports the LevelUp software factory. It supports thousands of concurrent users across North America.

We do that with a platform that multiplies developer capability, not an army of contractors. We are the opposite of bloated headcount. We deliver capability curves that keep climbing without collapsing under staffing pressure.

3. Alignment with the transformation the Department is already demanding #

The Department is clear about the future it wants to build:

Commercial preference
Modular open systems
Direct-to-supplier contracting
Fewer layers
Portfolio outcomes
Iterative increments
Buy what works

These are product values, not staff augmentation values.

SmoothGlue as a Proof Point: Mission Outcomes Without the Contractor Army #

Here is the evidence.

SmoothGlue is deployed on missions operating at the highest classification levels.
It is the backbone for ABMS CBC2 application and DevSecOps operations.
It powers key components of USCYBERCOM Unified Platform.
It supports WIDOW mission planning, now used by the Air Force and evaluated by the Navy.

These are not prototypes. They are not experiments. They are critical mission systems delivered without building a 200-person contract team.

This is the model the Department says it wants: capability fielded at the speed of relevance, with reduced friction, modularity, and commercial leverage.

Why We Won't Grow Into a Traditional Defense Contractor #

It would be easier. Selling hours is easier than building platforms. Scaling staff is easier than building reusable infrastructure. Chasing every RFP is easier than saying no.

But easier is not better.

A traditional GovCon model would slow us down. It would dilute the product. It would replace engineering culture with contract culture. It would push us toward compliance-first, operator-last thinking.

The Department is asking for speed, integrated portfolios, iterative delivery, modularity, commercial preference, and accountable leaders empowered to make trades. That is the world product companies thrive in.

We intend to stay that kind of company.

The Bottom Line #

Product-first is not a branding exercise. It is a strategic alignment with where defense acquisition is going.

The Department wants 80 percent solutions that arrive quickly, mature continuously, and integrate cleanly. Product companies deliver that. SmoothGlue delivers that across multiple critical missions today.

We are not going to grow up into a traditional defense contractor, because the future of defense contracting has already moved on. The Warfighting Acquisition System lays it out. The Software Acquisition Pathway enforces it. The missions we support prove it.

BrainGu will stay the kind of company built to deliver capability, not headcount.

And that is more than okay. It is necessary.

The Hidden Costs of "Free" Software: Flexibility vs Commercial Polish

2026-01-07T00:00:00Z

Organizations love the idea of “just use open source.” On paper, it sounds clean. It’s flexible. It’s free. And if you squint hard enough, it looks like a shortcut to digital transformation.

But here’s the honest read: open source is never free. Not in regulated environments. Not in DoD mission systems. Not in any place where uptime, security, traceability, or accreditation matter. You can get incredible capability from open ecosystems, but if you want something that actually holds up in production, you will pay for it one way or another.

At BrainGu, we believe in open ecosystems. We contribute to them, and SmoothGlue builds on top of them—but we also operate in the real world. If you want commercial polish and mission-grade reliability, you need more than a GitHub folder. You need engineering discipline, lifecycle management, compliance automation, and a path to accreditation. That’s where the real cost lives.

This post walks through what “just use open source” actually means, why the operational burden is consistently underestimated, and how SmoothGlue strikes the balance between open flexibility and productized reliability.

The Technical Reality Check #

“Free” open source gives you the parts, but it does not give you a working platform. And it definitely doesn’t give you a path to mission-ready accreditation.

If you attempt to recreate what SmoothGlue provides using only open-source components, here’s the starter list of what you’re signing up for.

The Tool Sprawl Problem #

Before you write a line of application code, you need to select, configure, integrate, and secure north of thirty individual pieces:

Core Platform: Kubernetes distro, container runtime, CNI, storage layers, ingress controller, cert manager, DNS.
Service Mesh: Istio or Linkerd or Consul. Pick one, learn it, tame it.
Identity: Keycloak, Dex, Authelia, plus OIDC/SAML wiring and mesh authZ. CAC/PKI if you're lucky enough to be in DoD.
CI/CD: GitLab or a Jenkins/Gitea/Harbor Frankenstack. Add GitOps. Add artifact repos.
Security: Policy engines, hundreds of policies, scanners, SCA tools, static analysis, secrets, image scanning.
Observability: Prometheus, Alertmanager, exporters, fluent bit, Loki/EFK, Tempo/Jaeger, Grafana dashboards, Kiali.
Backup/DR: Velero plus storage integration and restore exercises.
Collaboration: Mattermost or whatever your ATO allows.

That's the baseline. No apps. No compliance. No accreditation. No mission impact yet.

The Integration Nightmare #

Each one of those tools needs to talk to several others. You'll spend months reading documentation, resolving version mismatches, writing glue code, mapping identity flows, and trying to decipher mesh failures.

This is where most teams underestimate effort. Integration is not a one-time task. It is continuous. Every update, patch, or CVE nudges you off balance.

The Air-Gap Amplifier #

If you’re in a disconnected or classified environment, multiply the pain. Images must be mirrored. Charts must be patched for offline URLs. Binaries are staged, OS repos cloned, and documentation needs to be preserved because you can’t search the internet.

Tools like Zarf or Hauler help, but now you’ve added yet another layer to the stack.

The Maintenance Treadmill #

Let's say you get it all working. Congratulations, day zero is done. Now you inherit the ongoing cost structure:

Dozens of monthly security updates
Version compatibility checks
Upgrade orchestration
Configuration drift fights
Dependency failures
Tribal knowledge walking out the door

This is where organizations finally understand the difference between "free" and "sustainable."

The Real Cost of "Free" #

Here's the distilled version.

Hidden Cost	Reality
Tool selection	Weeks evaluating, months regretting
Initial integration	6–12 months to production-ready (on a good day)
Tribal knowledge	Documentation debt and a bus factor of 1
Ongoing maintenance	1–3 FTEs just keeping the lights on
Compliance	Manual evidence collection, continuous audits
Upgrades	Fear-driven and always late

This is why so many teams get stuck on Kubernetes 1.24 three years later. Every update risks breaking the tower they built out of duct tape and optimism.

What Productization Actually Delivers #

SmoothGlue doesn’t replace open source. It elevates it. It gives you the parts you want with the polish you need.

SmoothGlue delivers: #

Tested combinations across 35+ tightly coupled tools.
One deployment artifact instead of dozens of Helm charts and interdependent configs.
Air-gap native packaging built for disconnected from day one.
Unified operations through a single CLI to install, configure, upgrade, or tear down.
A version matrix so upgrades are predictable, not roulette.
Full compliance automation that produces a ready-to-submit Body of Evidence.
Enterprise-ready security baked directly into the platform, not bolted on after the fact.
Deployment flexibility from cloud to edge to TS//SCI networks.

Open source remains open. You can customize anything. But SmoothGlue lets you start from a working, mission-ready baseline instead of a spreadsheet full of unresolved dependencies and contradictory documentation.

How SmoothGlue Fits into the Open Ecosystem #

We don’t treat open source as a competitor. We treat it as the foundation.

SmoothGlue integrates cleanly into platforms like Platform One’s Big Bang, and we contribute upstream to make the ecosystem better for everybody. We sit on the Platform One Technical Oversight Committee, enhance Big Bang and Iron Bank, and build on open standards to support improvements.

This is the balance: open contribution, but with commercial-grade productization.

Proof Point: Mission-Ready, Not Just Market-Ready #

Our customers don’t buy SmoothGlue because it’s shiny. They buy it because it works in the hardest possible places.

Full ATOs at IL4, IL6, and TS//SCI, including a 5-year package at TS//SCI.
Running production workloads across USAF, ABMS CBC2, Kessel Run, Unified Platform, and multiple intelligence frameworks.
Deploys mission-ready in under two hours in cloud environments.
Installs and configures end-to-end at IL4+ in under two days.
Built-in guardrails for reliability and security at every layer.
Supports thousands of concurrent users across the continent.
Designed for cloud, on-prem, and edge deployments with the same operational model.

This is what commercial polish looks like when applied to open tools. Not pretty UI chrome. Predictability. Repeatability. Security. Outcomes.

The Bottom Line #

Open source is a powerful starting point, but building a mission-grade platform from scratch is not free, fast, or simple. It’s an engineering marathon that quietly drains time, budget, and focus from the real goal: delivering capability.

SmoothGlue gives teams a way out of the operational slog. You get the flexibility of open ecosystems with the reliability of commercial productization. You get to innovate instead of spending your year wiring together YAML files.

That’s the tradeoff. Not open vs closed. Not free vs paid. It’s whether you want to spend your time integrating infrastructure or delivering impact. At BrainGu, we built SmoothGlue so you don’t have to choose between flexibility and polish. You get both. And your mission gets what it actually needs: software that works.

From Chaos to Control: Secure, Auditable Deployments with SmoothGlue Console

2025-12-31T00:00:00Z

In highly regulated industries, the need for strict security controls and clear audit trails often clashes with the desire for developer agility. This friction creates complexity—a chaotic environment where moving quickly feels at odds with staying secure.

To solve this, we looked beyond the surface. Traditional analysis of a developer workflow often focuses only on the "frontstage"—the visible UI or CLI commands. The real chaos, however, lives "backstage" in the complex web of system interactions, permission handoffs, and automated processes that are typically missed. By applying a Service Blueprinting approach, we mapped the entire end-to-end deployment journey. This deeper analysis illuminated the hidden friction points and security gaps that traditional methods overlook, allowing us to build a solution that streamlines the whole process, not just the visible parts.

The result is a powerful new feature that brings order to that chaos: SmoothGlue Deployments, now fully integrated into the SmoothGlue Console. This capability turns complex operational tasks into a simple, controlled, and auditable workflow.

What is the SmoothGlue Console? #

For those new to the platform, the SmoothGlue Console is the central hub for managing your entire software development ecosystem. It's a unified interface where administrators can structure organizations, manage team members, and automate the creation of projects across integrated tools like GitLab, Jira, and ArgoCD. For developers, it provides a single pane of glass to access their projects and tools, streamlining their day-to-day work. By centralizing user and project management, SmoothGlue Console establishes the foundation of governance and control that makes secure, automated workflows like this new deployment feature possible.

How It Works: A GitOps Workflow with Built-in Guardrails #

From the user's perspective, the process remains simple. Behind the scenes, SmoothGlue Console orchestrates a secure, GitOps-native workflow designed for compliance.

User Initiates Deployment: A developer selects their application and target environment within the familiar Console UI.
Console Enforces Permissions: Before any action is taken, the Console's backend acts as a centralized policy enforcement point. It verifies the user's project-level permissions and ensures the requested deployment adheres to pre-defined rules.
A SmoothGlue Deployment is Created: Once authorized, SmoothGlue Console uses its own cluster-wide ServiceAccount to create a SmoothGlue Deployment custom resource on the local cluster.
Crossplane Manages Remote Resources: This new SmoothGlue Deployment is picked up by Crossplane, which is where the power of using the Kubernetes API as a universal control plane comes into play. Crossplane allows us to manage resources on any remote cluster declaratively, just like native Kubernetes objects. It acts as the engine that translates our simplified SmoothGlue Deployment request into the correctly configured, low-level resources (like namespaces and permissions) on the target environment. This provides a powerful abstraction, enabling the platform team to define how infrastructure should be provisioned while developers can consume it simply and securely.
ArgoCD Syncs the Application: Finally, ArgoCD on the remote cluster deploys the application from your source repository, ensuring the running state is a perfect reflection of its declarative configuration.

Built for Control and Compliance #

This feature was designed specifically to meet the stringent requirements of regulated environments. It provides security and auditability by default, not as an afterthought.

Centralized Audit Trail: Every deployment initiated through the Console is logged, providing a clear record of who deployed what, where, and when. This, combined with the immutable history from Git, creates a comprehensive audit trail for regulators.
Enforced Separation of Duties: The security model clearly defines roles. System Integrators establish secure, trusted connections between clusters. Developers, on the other hand, interact only with the Console UI and never receive direct credentials or kubectl access to remote, sensitive clusters.
Principle of Least Privilege in Practice: By mediating all actions, the Console ensures users can only perform the tasks they are explicitly authorized for. The system uses a specific, pre-configured ServiceAccount for execution, preventing privilege escalation and minimizing the attack surface.

Under the Hood: The Declarative Manifest #

SmoothGlue Console generates a declarative manifest that bundles all application and infrastructure configuration into a single, version-controllable resource. This ensures deployments are consistent, repeatable, and less prone to human error.

apiVersion: smoothglue.io/v1alpha1
kind: Deployment
metadata:
  name: widow-deployment
  namespace: structsure-system
spec:
  parameters:
    # Points to the remote cluster configuration
    k8sProviderConfigName: smoothglue-run-k8s-access
    # The namespace to be created on the remote cluster
    namespace: widow
    # Defines the ArgoCD AppProject with RBAC
    appProject:
      name: widow-project
      groups:
        readOnly: ["/widow/developers"]
        privileged: ["/widow/admins"]
    # Defines the application(s) to be deployed by ArgoCD
    applications:
      - name: widow-backend
        source:
          repoURL: https://code.build.smoothglue.io/BrainGu/WIDOW/widow-python.git
          targetRevision: master
# ... and other configurations

Ship Fast, Ship Safe #

With the integration of SmoothGlue Deployments into SmoothGlue Console, you no longer have to choose between developer velocity and the stringent security controls your organization demands. You can now provide a simplified, rapid deployment experience while ensuring every change is authorized, audited, and compliant.

Keep an eye out on our releases for more new features, as well as SmoothGlue Documentation to help you get started.

Matthew Shaver's School for Developers Who Don't Code Good

2025-12-24T00:00:00Z

I've led teams shipping into IL6 and TS//SCI. The constraint set is real: air-gapped networks, policy gates, inherited monoliths, and zero margin for sloppy change control. The job is not to admire the complexity. The job is to deliver outcomes safely, fast.

Below is the playbook I've used with teams. It is opinionated on purpose.

1. The debugging decision matrix #

Pick the tool that gets you to high-confidence evidence with the least blast radius. Use this like a checklist before you touch code.

Situation	First move	You get signal if...	If not, escalate to	Stop and rewrite when...
Repro in prod only, impact contained, logs are noisy	Read logs with scoped correlation IDs; increase log level on the slice, not the service	You can tie errors to a single boundary (API, queue, DB)	Localized debug session in a hermetic replica with prod parity data shape	The fix requires cross-cutting changes to 2+ bounded contexts or breaks a shared contract
Repro in lower env, flaky tests, recent dependency bump	Pin versions and bisect the change set; run failing tests with trace	One commit window correlates with failure	Attach a debugger and single-step the narrowest suspect function	The root cause is a leaky abstraction you do not control and cannot sandbox
Performance regression with headroom gone	Capture a short CPU/mem profile and a single request trace	A single hot path dominates >40% of time	Debugger with perf counters on that hot path only	Data model or access pattern is fundamentally wrong for the workload
Security finding blocks release	Reproduce the finding locally with the same scanner and rules	The repro is deterministic	Step through the code that builds the artifact, not the app code	The supply chain is unpinned and unreproducible, or the policy cannot be satisfied without redesign

Rules of thumb: #

If a log statement would have prevented this, add it now. Not later.
If you cannot reproduce within 90 minutes, you are missing a boundary. Instrument, mock, or split until you can.
Never attach a debugger to prod. Recreate the conditions, not the environment.

2. Practical strategies for large monoliths in compliance-bound orgs #

You inherited a monolith. Fine. Treat it like critical infrastructure and evolve it with discipline.

Stabilize at the edges. Wrap external calls behind explicit interfaces. Lock API contracts. Add consumer-driven tests at every boundary so change control has evidence, not vibes.
Carve by seams, not by dreams. Split where the data or deployment seams already exist. Reporting, batch jobs, and adapters are usually first. If you need a strangler, start with read paths.
Pin and pave. Pin build and runtime toolchains. Pave a golden path for new features that starts outside the monolith whenever possible. Make it easier to add a service than to add another god-class.
Make the monolith boring. No new frameworks inside the core. Invest in observability and deployment reproducibility, not novelty.
Prove compliance continuously. Automate SBOMs, provenance, and policy checks in the pipeline so auditors see evidence attached to every artifact, not a once-a-quarter scramble.
Plan migrations like incident response. Small steps, reversible changes, an exit plan for every cutover. If rollback is folklore, you are not ready.

3. The day-to-day flow that keeps you fast and safe #

Short, sealed loops. Every change has the tests, tracing, and policy proofs to ship without a meeting. If a change needs a meeting, the loop is not sealed.
Radical reproducibility. Infra as code, environment as code, data shape as code. Same commit builds the same artifact everywhere.
Evidence over ceremony. Replace status docs with pipeline artifacts and dashboards that show readiness for release, not opinions.
Pre-mortems over post-mortems. Before changes, ask what breaks and how you will see it. Write the alert first.
Kill heroics. If a fix lives only in someone's head or local env, it does not exist.

4. When to rewrite #

Rewrites are last resorts. Do it when at least two are true:

The core abstraction is wrong and blocks policy compliance or basic scaling.
The cheapest safe change requires touching 3+ bounded contexts.
You cannot get to single-digit MTTR with instrumentation and tests.
Auditable supply chain is impossible without a new build path.

When you do rewrite, do it outside the blast radius: new module, new deployable, strangler on the read path first, then write.

5. Proof point from our world #

We built SmoothGlue to operationalize this discipline so teams can debug quickly and deploy safely in the hardest places. SmoothGlue provides a paved path to production built on top of Big Bang and aligned to DoD DevSecOps best practices, so teams get a production-ready platform with compliance and security controls baked in, not bolted on. That is why it is used across DoD initiatives at the highest impact levels and in mixed cloud, on-prem, and edge deployments.

The result for teams is straightforward: a code-low, deploy-high model where scaffolding, policy checks, and golden paths are pre-integrated, which shortens the distance from diagnosis to a secure update, even in IL-restricted environments.

6. A compact checklist you can print #

Can I reproduce in 90 minutes or less with the current boundaries and data shape?
Do I have logs, traces, and tests at the exact boundary that failed?
Is my change attached to an SBOM, provenance, and policy proofs in CI?
Can I roll forward or back without a meeting?
Did I make the next failure cheaper to diagnose than this one?

If the answer to any is no, fix that before you chase the next ticket.

7. Closing #

High-security, high-stakes software rewards teams that respect constraints and push flow to the edges. Read the system before you rewrite it. Prove the fix before you celebrate it. Ship boring, provable changes on a paved path. That is how you deliver outcomes when the mission cannot wait.

The Aerodynamics of Building Products vs Consulting in the Defense Innovation Ecosystem

2025-12-17T00:00:00Z

Product lift beats services drag. In defense, the teams that standardize on productized platforms compound speed, security, and learning. Services can be useful, but service-heavy delivery adds friction that kills timelines and blows budgets.

Why product delivery wins for mission outcomes #

Repeatability compounds. A platform that bakes in CI/CD, security, and compliance gives you the same clean run every time. That removes luck from delivery and turns new work into configuration, not construction.
Security is built-in, not bolted-on. When controls, scans, and attestations live in the golden path, you ship faster and with fewer surprises at accreditation. That is the only sustainable way to operate across IL4 to TS//SCI.
Cost curves flatten. Buy once, use everywhere. Product beats a rotating bench of billable hours because the platform carries the load while people focus on mission logic.
Talent scarcity is real. You will not hire your way out of DevSecOps and compliance gaps. You need leverage. Platforms are leverage.

Lessons from SmoothGlue deployments #

We built SmoothGlue to remove drag in hard places. A few patterns that matter:

Golden paths reduce cognitive load. Opinionated pipelines and environments mean teams stop rebuilding plumbing and start delivering features.
Security as a first principle. SmoothGlue runs with embedded guardrails at IL4, IL6, IL6/REL, IL6/NF, IL6 Edge, and TS//SCI, with full ATOs including a 5-year full ATO package at TS//SCI. That matters when every finding, waiver, and control can stall a deployment.
Speed where speed usually dies. Mission-ready in under 2 hours in cloud contexts, and full installation in high-impact environments in two days. That is what product lift looks like when the air is thin.
Operate where it counts. Today we support USAF and USCYBERCOM contexts across cloud and edge, with productized compliance that aligns to the DoD DevSecOps Reference Architecture.

Proof point #

By delivering on time and on budget with pre-integrated tools and security, SmoothGlue has shortened concept-to-deployment timelines from months to days in classified environments. The reason is simple: the product carries security and compliance forward so developers can carry mission logic across the line.

The services-heavy anti-pattern #

Custom everywhere = slow everywhere. Bespoke stacks produce bespoke problems. Each environment becomes a snowflake that resists change.
Security as an afterthought. If controls get added late, you pay twice: once in rework, again in schedule slip.
Bench churn beats product learning. Rotating contractors never build the muscle memory your mission needs.

A simple decision framework #

Use this when choosing between product and services for your next program:

Scope volatility: If requirements shift but the delivery path is standard, choose product. Services only where integration is truly novel.
Accreditation posture: If you need IL4+ quickly, pick a platform with existing ATOs and a body of evidence. Do not rebuild controls.
Team composition: If your teams are feature-rich and platform-light, you need a ready path. Give them rails, not a blank slate.
Time to usefulness: If stakeholders need days, not quarters, a productized platform is the only realistic path to value.

What this means for program leaders #

Fund outcomes, not scaffolding.
Standardize on a platform that already runs where you operate.
Measure cycle time, lead time to user, and mean time to confidence. If those improve quarter over quarter, you picked the right lift.

Closing #

Defense missions do not fail for lack of smart people. They fail from delivery drag. The way out is product lift: a platform that bakes in security and compliance, proves itself across impact levels, and frees your teams to deliver mission logic at speed.

If you want the short path from zero to running, we built SmoothGlue for exactly that.

The Power of Platform Constraints: Why Boundaries Make Better Builders

2025-12-10T00:00:00Z

If you’ve worked in or around modern software delivery long enough, you’ve probably seen programs that fail, not because of “bad Agile” or flawed acquisition strategies, but because the problem was too fuzzy and the tooling too limitless.

Projects can drift into ambiguity, not because the engineers weren’t smart or dedicated enough, but because they were given an unbounded canvas and a blank set of supplies and expected to just "build it better, faster, more secure."

At BrainGu, we take a different approach.

Opinionated, on Purpose #

Our platform philosophy is intentionally opinionated, not to limit innovation, but to enable it. We believe that the right constraints are not a restriction but a relief: a paved road beats a choose-your-own-adventure through the woods, guardrails don’t slow you down, they keep you moving at a safe speed, and when the foundational pieces are solved once, well, and for everyone, teams can finally focus on differentiation, not duct tape.

This is where creativity thrives: within well-designed limits that guide without smothering.

Unbounded Inputs, Murky Outcomes #

Without platform-level structure, efforts can suffer from:

Second-order effects: Decisions made upstream in architecture ripple into downstream chaos for delivery and operations.
Third-order confusion: Without a shared vocabulary or default way of working, each team reinvents the wheel or worse by building mismatched puzzle pieces.
Decision fatigue: Teams burn cycles choosing tools, writing boilerplate, and managing glue code, rather than shipping meaningful outcomes.

It’s not the Agile framework. It’s not the contracting vehicle. It’s the lack of engineered clarity.

What BrainGu Gets Right #

We build platforms that make calls. We don’t let every team reinvent identity management; we solve it at the platform layer. We set sane defaults for CI/CD pipelines and testing strategies. We bake in observability and security, not as bolt-ons, but as first-class concerns.

Why? Because we know that platforms are not just about access…they’re about alignment.

When teams know where the boundaries are, they make better decisions faster. When platforms lead with intentionality, teams deliver with confidence. When complexity is curated, creativity is unleashed.

The Paradigmatic Difference Between a Software Project and a Software Product

2025-12-02T00:00:00Z

In software, "project" and "product" aren't just different labels, they represent fundamentally different paradigms. Your choice determines whether you're building capability or delivering value.

Platforms like Kubernetes, Linux, and DevSecOps toolchains all began as open-source projects—powerful, flexible, but undeniably raw. Over time, each has been productized to unlock scalability, reliability, and ease of use:

GKE for container orchestration
RHEL for enterprise operating systems
SmoothGlue® for secure, compliant software delivery

Each of these platforms represents a shift from DIY complexity to production-ready simplicity. Let's break down what that difference looks like, and why it matters.

Packaging: From Complexity to Clarity #

The Project #

Kubernetes, Linux, and traditional DevSecOps stacks are powerful, but difficult to operationalize. Configuring infrastructure, managing upgrades, and stitching tools together takes serious expertise. You're not just adopting a project, you're inheriting an engineering burden.

The Product #

GKE made Kubernetes consumable.

RHEL made Linux enterprise-ready.

SmoothGlue completes that pattern for secure software delivery. It abstracts the complexity of CI/CD pipelines, compliance automation, and platform operations into a single, cohesive product—complete with hardened defaults, air-gapped deployment options, and mission-ready documentation.

Pricing Model: Free to Use vs. Ready to Run #

The Project #

Linux is free until you count the cost of maintaining and securing it yourself. Kubernetes is open-source until your engineers are paged at 3 AM. Most DevSecOps stacks begin as "free," but consume endless hours in integration, maintenance, and compliance rework.

The Product #

With GKE, RHEL, and SmoothGlue, you're not just paying for software, you're investing in speed, stability, and support at scale.

SmoothGlue brings the same product-first mindset to DevSecOps, offering a secure, integrated platform that's ready to run. No duct tape. No rewiring. Just a clean path to compliant delivery that lets your teams move faster without the overhead.

Production Maturity: Built Once vs. Battle-Tested #

The Project #

DIY Kubernetes, Linux distros, and custom-built DevSecOps stacks all suffer from fragmentation. Each organization builds its own flavor and supports it alone.

The Product #

GKE, RHEL, and SmoothGlue benefit from widespread, real-world usage.

Just as Google and Red Hat improve their platforms based on feedback from thousands of customers, SmoothGlue evolves with input from users across defense, finance, healthcare, and more. When one customer uncovers a bug or friction point, the fix benefits the entire community.

Documentation and Support: Tribal Knowledge vs. Guided Success #

The Project #

Open-source projects often rely on limited documentation and tribal knowledge. Kubernetes and typical DevSecOps toolchains assume deep technical fluency, leaving newer teams to navigate by trial and error.

The Product #

GKE, RHEL, and SmoothGlue flip that script.

SmoothGlue is backed by clear, actionable documentation, live support, and real-world implementation guidance. It's not just documented, it's designed to be understood, adopted, and trusted.

Expertise and Automation: For Experts Only vs. For Mission Teams #

The Project #

Projects like Kubernetes and Linux are built by experts, for experts. Running DevSecOps pipelines securely and at scale without a productized solution often means wiring together tools by hand and hoping they play nice.

The Product #

SmoothGlue brings the same automation advantage to DevSecOps that GKE and RHEL brought to their domains.

It bakes in identity and access management, hardened CI/CD pipelines, policy enforcement, and reusable infrastructure patterns. Teams don't have to be platform experts to ship securely.

The Value Proposition: Mission Over Mechanics #

For most organizations, infrastructure isn't the mission, it's the machinery. Whether you're working with Linux, Kubernetes, or DevSecOps, the real question is:

"Does managing this stack make your core mission stronger?"

GKE, RHEL, and SmoothGlue all answer that question the same way: Let the product handle the mechanics so your team can focus on what really matters.

From Project to Product and Why It Matters #

The difference between a software project and a software product isn't just about technology, it's about time, focus, and leverage.

Projects offer flexibility, but demand constant upkeep. Products offer speed, resilience, and leverage at scale.

That's why SmoothGlue exists as the productized platform for secure software delivery. It turns DevSecOps complexity into a streamlined experience. You don't need to replatform your brain, re-implement your pipelines, or re-justify every compliance gate.

With SmoothGlue, your developers can build. Your platform teams can scale. Your security teams can sleep. And your mission? It moves forward—fast!

Don't Let the Pipeline Be the Final Boss

2025-10-29T00:00:00Z

If you've worked on platform teams long enough, you start to see a pattern.

A new developer joins, eager to contribute, ready to build, ready to ship. But their first real challenge isn't in production. It's not even in sprint planning. It's in the CI/CD pipeline—the "Final Boss" of the developer experience.

The Pipeline Problem Isn't the Developers #

Every dev team wants to ship secure, reliable software. But too often, they're met with opaque errors from tools they've never heard of.

YAML files stitched together two reorgs ago, and compliance gates that fail without explanation. What should be a guardrail becomes a wall, and resentment builds—not just toward the pipeline, but toward the platform itself.

We've seen the same two questions drive most Slack threads, onboarding churn, and 1:1 frustration:

How do I deploy this thing?
Why is this pipeline failing?

It's not that the platform lacks value. It's that the interface between dev and platform is under-designed.

Documentation alone isn't enough. As platforms become more secure, policy-aware, and modular, navigation becomes the new skill—yet most developers are left without a map. If the industry doesn't evolve how it teaches, visualizes, and guides developers through platform interactions, even high-value platforms will continue to be perceived as high-friction.

How to Win the Boss Fight #

Platforms need to move beyond documentation toward frameworks designed for developer navigation.

These frameworks should show:

What the pipeline expects
Where developers can influence it
What's negotiable vs. non-negotiable
Who owns which parts of the experience
What the minimal path to value looks like

These frameworks must be:

Visual: Show the flow, not just describe it.
Context-aware: Adapt to team maturity and project type.
Feedback-driven: Evolve with real developer input.

Lower the Boss Fight #

A developer's first experience with a platform pipeline shouldn't feel like an endgame encounter. It should feel like stepping into a well-run train system—one that connects back to a clear map, predictable routes, and visible destinations.

When platforms design for navigation as much as control, they don't just unblock developers; they build trust, accelerate delivery, and keep everyone moving in the same direction.

If you're figuring out where your own trains begin, start with the map:

All Aboard: Why Building a Developer Platform Starts With Knowing Where the Trains Begin →

The Shift from Platform Engineering Glory to Developer Empowerment

2025-10-08T00:00:00Z

For a few years the industry rewarded platform teams for elegant charts and a long list of components. Pretty dashboards. Pet projects. Lots of YAML. I’ve built those stacks. They look impressive - but they don’t move the needle.

Measure what matters: mission outcomes #

Cycle time, not component count.
Lead time to the user, not how many operators we tuned.
Mean time to confidence - how quickly a dev knows a change is safe to ship.
Percent of engineering hours spent on mission needs vs platform plumbing.

If your scorecard is infrastructure complexity, you’ll optimize for the wrong thing and still miss your delivery dates.

How SmoothGlue removes friction #

I helped design SmoothGlue around one principle: remove toil so product teams can focus on faster delivery. In practice:

Golden paths out of the box. Opinionated pipelines and environments so teams stop reinventing scaffolding and get to features.
Guardrails built in. Security and compliance checks run where they should (in the path of delivery) so developers don’t play audit ping-pong later.
Operate where you need to operate. Cloud, on-prem, edge, and mixed classification footprints are now the same to the developer. Deployment footprints being configurable kills context switching and accelerates delivery.
Product over projects. Reusable, productized platform capabilities replace bespoke one-offs that rot the moment a champion leaves.

The goal is not another layer to learn. The goal is a paved road that teams trust.

Lessons from DoD and regulated industries #

We cut our teeth where failure costs more than missed profit.

Security must be default, not bolt-on. If security is optional, it will be skipped under pressure. Bake it into the pipeline and runtime.
Compliance needs automation. If evidence isn’t produced as a side effect of delivery, it becomes an expensive, blocking project. Make the Body of Evidence a build artifact.
Design with the operator and end user. Platforms that ignore real workflows die in pilots. Bring users into the loop early and keep them there.
Speed and rigor are not opposites. With the right guardrails, you can go faster and be safer at the same time. We’ve done it across IL4, IL6, and TS/SCI.

These patterns translate cleanly to finance, healthcare, and other regulated domains. The acronyms change. The friction points do not.

Proof in practice #

This is what it looks like when the platform serves developers.

Zero to production in minutes. Our golden path scaffolds a working service with pipelines, security, and observability prewired. You ship fast, then iterate with real user feedback immediately.
Classified deployment in days, not months. We bring the Body of Evidence and golden path templates that already answer standard security screening, so moving from a new production app to IL6+ is a predictable, days-scale step.

What to do next? #

If you are building software, you can use SmoothGlue right now. Spin up an account, put a small service on the paved road, and measure the difference in days, not quarters.

Start here: account.smoothglue.com

Then hold us to the only metric that matters: better outcomes, faster delivery, and higher confidence in production. If we’re not moving those numbers, we don’t deserve your attention.

How We Slashed Our CI Pipeline Costs with Developer MacBook Pros

2025-10-02T00:00:00Z

The Problem: Rising Cloud Costs and Developer Wait Times #

As our platform, SmoothGlue® Cloud, grew in adoption, we hit a familiar problem: cloud costs. The culprit? Our Continuous Integration (CI) pipelines. Running CI pipelines for multiple developer (dev) branches is essential in ensuring code quality and security, but the more devs we had, the more we saw our cloud costs skyrocket.

It didn’t stop there, though. As we tried to manage costs by limiting the number of runners, we ran into a new issue: devs were stuck waiting in line for pipelines to run. Frustrated devs waiting for an available runner was obviously not ideal.

Using Auto-Scaling to Manage Cost and Availability #

Our first step in tackling these challenges was to introduce auto-scaling groups. As demand surged during work hours, our CI runners scaled up; then, as evening rolled in and our team clocked out for family time, we scaled the runners back down. It was a solid improvement—we reduced cloud costs while keeping pipelines moving during peak hours.

But in true Change the Box fashion, we knew this wasn’t the final solution. There was still room to drive down costs and improve developer productivity. The key was sitting on our desks, right in front of us.

The Solution: Turning MacBooks into GitLab Runners #

Each of our devs is assigned a powerful MacBook Pro. In the modern software world, most devs aren’t running heavyweight local compile jobs or VMs. They’re coding in their editors and relying on cloud services for the heavy lifting. That left us with tons of idle compute power sitting on our desks while we were paying for extra cloud runners.

So why not use the machines we already have?

We set out to turn each dev’s MacBook Pro into a dedicated GitLab Runner. This would allow devs to leverage the hardware they already had for running their CI pipelines. No more waiting in line for cloud runners. No more skyrocketing cloud costs.

Here’s how we did it and how you can do it, too:

Install the GitLab Runner We ran this command on each dev’s machine to configure it as a runner:

curl -L --output /usr/local/bin/gitlab-runner https://gitlab-runner-downloads.s3.amazonaws.com/latest/binaries/gitlab-runner-darwin-amd64
chmod +x /usr/local/bin/gitlab-runner

This downloaded and installed the GitLab Runner executable.

Register the Runner After installation, we registered each MacBook as a runner in GitLab, assigning it to the dev’s projects so their pipelines would run locally when triggered.

gitlab-runner register

Note: You’ll be prompted to provide your GitLab instance URL, a registration token, and other setup details.

Configure the Runner We then assigned the runner to specific projects or branches. For example, we configured it to only handle CI pipelines for the dev’s own branches.
Automate the Setup We wrote a simple setup script to automate these steps and roll it out across our team. This ensured every dev’s machine was ready to act as a runner.
Prioritize Local Compute We configured GitLab CI to prioritize local runners over cloud-based runners, ensuring that if the dev’s machine was available, it would always be used first.
Include Fallback Logic We then set up a fallback, so if a dev’s machine wasn’t available or was offline (e.g., they were out of office), the system would automatically fall back to cloud-based runners, ensuring no pipeline went unprocessed. Note: You can adjust the priority settings for your team using GitLab's CI/CD pipeline configurations.

Now each of our devs had a dedicated pipeline resource at their fingertips.

Immediate Results #

Our pipeline wait times dropped dramatically overnight. Devs no longer had to sit around waiting for a free runner, and our cloud costs dropped as we scaled back our reliance on cloud-based CI runners.

This solution embodies our Change the Box philosophy—finding incremental improvements that drive meaningful change. We didn’t need to overhaul our entire CI pipeline infrastructure. Instead, we looked at the resources we already had and found a way to make them work harder, faster, and cheaper for us.

By turning idle MacBooks into CI pipeline runners, we reduced costs, improved developer experience, and streamlined our workflow, all without adding expensive new infrastructure.

Don’t Let Idle Resources Go to Waste #

If your cloud costs are spiraling out of control and your devs are stuck waiting for pipelines, take a hard look at the resources you already have. You might just find the solution sitting right in front of you.

By leveraging idle developer machines, you can slash your cloud costs, keep your pipelines running smoothly, and give your devs the dedicated resources they need to move fast and ship code.

Is Your App Lost in the Cloud? How to Bring Order to the Chaos

2025-09-24T00:00:00Z

In today's fast-paced digital world, deploying applications can feel like navigating a maze. Different environments, complex configurations, and security concerns can quickly turn your streamlined process into a tangled mess. What if there was a standardized "launchpad" for your applications? A process that can help where even Continuous Integration and Continuous Delivery (CI/CD) or DevSecOps falls short.

That's where the Application Deployment Instance, or as we call it, “ADI,” comes in. Think of it as a complete, repeatable package for your application, with everything it needs to run smoothly and securely in any environment.

🙏 Special thanks to Justin Bailey for his insights and support in shaping this post.

What is an ADI? #

An ADI is a standardized set of resources, configurations, and integrations that ensures your applications are provisioned and operated consistently. It's a blueprint for your application's success, no matter where it's deployed. From a development sandbox to a fleet of edge devices, the ADI provides a consistent and reliable home for your code.

Topology of a SmoothGlue ADI

The power of the ADI is unlocked when it's managed declaratively, typically through a GitOps workflow. This means the entire definition of an ADI—its structure, configuration, and security policies—lives as code in a Git repository. Instead of issuing manual commands, you simply declare the desired state in Git, and automated agents ensure your live environments match that state. This provides a complete, version-controlled audit trail for your entire application environment.

The Core Components of an ADI #

At its heart, an ADI is composed of several key elements:

Kubernetes Resources: a dedicated and isolated environment for your application to run
Cloud Services: optional but powerful additions, such as Relational Databases (RDBs) and Application Load Balancers (ALBs), that can be seamlessly integrated
Security and Identity: tools like Vault for secrets management and Keycloak for identity and access control are wired in from the start
Traffic Management: a service mesh, like Istio, handles how data flows to and from your application, ensuring reliability and security

Why Should You Care? #

Speed and Efficiency: ADIs create a repeatable process, which means faster deployments and less manual work.
Enhanced Security: With standardized security measures like secrets management and controlled access, your applications are secure from the start.
Consistency Across Environments: An ADI ensures that your application runs the same way in development, testing, and production, finally solving the "it worked on my machine" problem.
Clear Roles and Responsibilities: ADIs define who owns what, from the underlying infrastructure to the application itself, fostering better collaboration between Engineering Operations (EngOps) and Application (App) teams.

How an ADI Bridges the CI/CD Gap #

It’s helpful to think of an ADI as a supercharged "Deployment Target." This is where it shows its unique value in the fuzzy middle between CI and CD.

CI is about building and testing your code, resulting in a deployable artifact (like a container image).
CD is about taking that artifact and deploying it.

The ADI isn't part of either process; it's the standardized contract between them that defines the complete, consistent environment—the "delivery address"—that your CD pipeline will deploy to. By standardizing the "where," the ADI makes the "how" of automated delivery faster, safer, and more reliable, especially as you scale from one production environment to thousands of edge deployments.

Anticipating the Hurdles: Common Questions about ADIs #

Adopting a new concept like an ADI naturally brings up some hard questions. Let's address them head-on.

Q: "Isn't this just a new name for Infrastructure as Code (IaC)?"

A: While tools like Terraform (IaC) are used to build an ADI, they are not the ADI itself. IaC is the foundation, while an ADI is the fully furnished, move-in-ready apartment with the security system active, the utilities on, and a key waiting at the front desk. It's the complete, instantiated, and operational contract, not just the definition.

Q: "Does a standardized ADI force my teams into a rigid, 'one-size-fits-all' box?"

A: This is a valid concern. The goal isn't a single, monolithic template but a curated catalog of ADIs. Think of a car manufacturer: they offer a sedan, an SUV, and a truck chassis for different needs. Similarly, a platform team can offer an "API Service ADI," a "Data Pipeline ADI," and so on. The principle is standardization within a category, which provides freedom and flexibility on a reliable foundation.

Q: "Won't the platform team that owns the ADIs just become a new bottleneck?"

A: This is an organizational challenge that requires you to treat your platform as a product. The platform team's mission is to be an enabler, not a gatekeeper. This is achieved through self-service tooling, excellent documentation, and clear SLAs. When done right, the platform team accelerates all other teams by providing a stable, secure, and efficient "paved path" (read more about that here) for them to build on. A bottleneck is a sign of an anti-pattern, not a flaw in the ADI model itself.

Join the Conversation #

Ultimately, the ADI model is about turning your deployment target from an unpredictable variable into a reliable, managed product. By addressing the challenges of complexity and rigidity head on, it provides a powerful strategy for any organization looking to scale its operations from the cloud to the edge.

But this is just our approach. Let us know your thoughts on Linkedin—the real conversation starts with you.

How does your team manage the handoff between CI pipelines and deployment environments?
What are the biggest pain points you've found in that 'fuzzy middle'?

Let's explore how we can all bring a little more order to the chaos.

GuCon 2025: Celebrating the Past and the Future

2025-09-17T00:00:00Z

GuCon, BrainGu's annual employee gathering, took place last week in Detroit, MI. It's not just a conference, but an event for us to celebrate community and all things Gu. Over the years, GuCon has ranged from a small group of 15 or so employees to well over 100, but its focus is always the same: to bring people together, enhance company communications, and celebrate wins. This year, GuCon is focused on celebrating achievements, but first, let's look back on where we started.

The History of GuCon #

Being a remote-first company means a majority of work time is spent over video calls or Slack chats, so Guvians look forward to the in-person opportunity GuCon provides to share ideas, and strengthen the culture that makes BrainGu unique. It's a great balance of communicating company goals and next steps, participating in community programs, and getting to know each other in incredible cities.

The first-ever GuCon was hosted in Washington D.C. in 2015. While small, that event started a yearly tradition of community for the company.

GuCon came from the idea to get a break from the day to day and connect as people. Spence and I have always valued community, and to accomplish big things, it requires dedicated people,

noted Matt Shaver, BrainGu CTO.

People are more than just work machines, though. It is easy to make assumptions when someone is just a name on Slack. So to connect, understand, and build respect, people have to get together. We've always believed GuCon is where the magic happens in BrainGu—when people trust each other and move to a central goal. Not as co-workers, but as a community.

GuCon 2025: Celebrating Our Achievements #

While GuCon 2024 centered on preparing for product-led growth by aligning teams and sharpening strategy, this year in Detroit, we saw that vision realized. From live demos to hackathon projects, Guvians showcased the tools, platforms, and innovations we've been building, and how they're already driving growth.

Making the shift to product-led involves hard work from everyone: engineers, designers, operators, and leaders. A spirit of collaboration that carries into our products and our larger impact in the world…the Spirit of Gu.

On Woodward Avenue in downtown Detroit, a bronze statue sits with palms facing the sky, a sphere in one hand, and a family in the other. This "Spirit of Detroit" is a statue by artist, Marshall Fredericks, and has become a symbol of hope, the "spirit of man," and the city's identity.

Similar to the statue, the Spirit of Gu, of community and collaboration, has resulted in us building great things together. As Spence, BrainGu's CEO, puts it:

The spirit of BrainGu has been and will always be the Guvians, the employees. You put smart, kind, thoughtful people in a room together, and you get a great event.

Just like the statue's figure holding both the divine and the human, our teams balanced big ideas with practical execution—dreaming and deploying in the same day. While each Hackathon breakout group brought something different to the table, the common thread was clear: when Guvians come together with focus and trust, the results are amazing.

Tradition Matters #

GuCon 2025 reminded us why this tradition matters. It's not just about the demos, the strategy sessions, or even the hackathon—it's about the people who make BrainGu what it is. When Guvians come together, we leave with more than new ideas. We leave reassured, connected, and energized to tackle the next challenge.

Detroit gave us the perfect stage to celebrate how far we've come and to prove that the Spirit of Gu is alive and well. As we look ahead, we're excited to keep building, keep innovating, and keep showing up for each other.

Here's to the next GuCon and to the community that makes BrainGu thrive.

SmoothGlue Unveils 7.0, Featuring an Integrated Data Mesh to Power Real-Time, Mission-Critical Enterprises

2025-09-16T00:00:00Z

Grand Rapids, MI – September 16, 2025 – BrainGu, the developer of the resilient Platform-as-a-Service (PaaS) for mission-critical applications, today announced the launch of SmoothGlue 7.0. This landmark release introduces the SmoothGlue Data Mesh, a revolutionary capability that unifies data across distributed systems, empowering organizations to build intelligent, connected, and AI-driven applications with unprecedented speed and security.

The launch follows a period of exceptional performance and proven reliability for the platform, which has maintained 100% uptime with zero incidents over the past 60 days. The platform currently hosts 300+ applications over 150+ nodes and recently completed a zero-disruption, coordinated upgrade to Kubernetes v1.31 across four separate clusters, underscoring its operational excellence, all at the highest impact levels.

SmoothGlue 7.0 addresses the core challenges of modern enterprises—data silos, security, and operational complexity—by integrating the Data Mesh directly into its enterprise package. This transforms the platform into a comprehensive solution for both application delivery and real-time data strategy.

Key advancements in SmoothGlue 7.0 include: #

Integrated SmoothGlue Data Mesh: This new capability allows organizations to seamlessly connect disparate data sources—from relational databases to streaming platforms—and sync critical information across systems with no code changes. It provides real-time, audit-ready data pipelines, empowering teams to innovate faster and power new AI services with clean, dependable data.
Automated Security & Compliance: Building on its security-first foundation, version 7.0 introduces automated single sign-on configuration for core developer tools and enhanced cloud security with IAM IRSA as the new default. These updates eliminate hours of manual configuration, enforce consistent security policies, and reduce the attack surface out of the box.
Enhanced Performance and Scalability: The platform now features High-Availability configurations for critical components and underlying databases, ensuring maximum uptime. A migration to a more efficient Operatorless Istio architecture reduces operational overhead and improves overall system resilience, preparing enterprises for future scale.

Bringing Order to the Chaos: Application Deployment Instances is a standardized set of resources, configurations, and integrations that ensures your applications are provisioned and operated consistently. It's a blueprint for your application's success, no matter where it's deployed.

"Our platform's 100% uptime record is a testament to our obsession with what we call the ‘ilities’: resilient, scalable, reliable, and secure," said Jamil Jadallah, VP of Product at SmoothGlue. "With 7.0, we are bringing that same resilience to our customers' data. The introduction of our Data Mesh is a direct response to the need for a unified platform that not only automates development but also intelligently moves and secures the data they rely on for critical missions. We anticipate the Data Mesh to be a cornerstone of the critical mission applications running on SmoothGlue.”

The architecture of SmoothGlue 7.0 also lays the groundwork for the company’s future vision of further supporting the race to 2027 and the C3BM model and requirements.

SmoothGlue 7.0 is available today! To learn more or request a demo, please visit SmoothGlue.com.

The Paved Path to Production: Why a True Platform is More than a Blueprint

2025-09-10T00:00:00Z

But the reality is often a struggle against friction. They’re wrestling with complex cloud configurations, deciphering dense security requirements, navigating a disjointed collection of tools, and waiting on tickets for basic access.

This friction creates immense cognitive load—the mental energy spent on tasks other than creating value. When developers are forced to be experts in Kubernetes, Identity and Access Management (IAM) policies, Authority to Operate (ATO) compliance, and infrastructure provisioning, their ability to deliver capability to the warfighter grinds to a halt.

The solution is a true developer platform. Not just a collection of tools, but a thoughtfully constructed paved path—an opinionated, supported, and streamlined route for building and shipping software securely. This path is built on a foundation of empathy for the developer’s daily journey.

While blueprints like Platform One’s Big Bang lay the initial gravel, they leave the most difficult terrain for you to pave yourself. SmoothGlue™ is the turn-key solution that paves this path from end-to-end, creating a world-class developer experience that accelerates mission delivery.

The Challenge: Life on the Unpaved Road #

A basic DevSecOps toolchain is a great start, but it leaves your teams at the edge of a wilderness. The road to a production-ready, accredited system remains unpaved, forcing your developers to face hazards that increase cognitive load and risk:

Production-Hardening: How do you transform this foundation into a robust system that can run in high-stakes environments like AWS GovCloud, Cloud One, or AC2SP?
ATO Acceleration: How do you integrate the necessary logging, IAM, encryption (KMS), and security controls to satisfy RMF and achieve an ATO without months of rework?
Tactical Edge Deployment: How do you package and deploy this platform in disconnected, air-gapped environments at the tactical edge, ensuring all dependencies are met?
Day 2 Operations: Who handles the complex lifecycle management? When a core component, such as Istio, undergoes a major architectural change, your team is left to navigate it, disrupting development and introducing risk.

Answering these questions with internal resources is a slow, expensive proposition that diverts your best engineers from the mission. It’s like being handed an engine and being asked to build a car around it while driving.

SmoothGlue: Paving the Path to Mission Capability #

SmoothGlue is a comprehensive, production-ready platform that builds upon the Big Bang foundation and extends it with the enterprise-grade capabilities necessary for mission success. We pave the road so your developers can move at the speed of relevance.

1. Production-Ready, Multi-Environment Infrastructure as Code (IaC) #

Our production-grade IaC removes the burden of infrastructure decisions from your developers by offering automated, hardened support for AWS, EKS, and RKE2 (with CIS mode) across the full spectrum of DoD hosting locations, from commercial cloud to Top Secret/SCI, including:

AWS Commercial & GovCloud
Army AC2SP
AF Cloud One
On-premise & AWS Snowball deployments

Designed as an airgap-first distribution, every component (code, software, and documentation) is available and functional in fully disconnected environments. We automate the hardening of the entire system so your platform is secure and resilient from day one.

2. An Accelerated On-Ramp to ATO #

Instead of a labyrinth, SmoothGlue provides a secure on-ramp to achieving your ATO. These built-in "guardrails" on the paved path include:

Integrated Cloud Services: Production-ready components for Load Balancing, IAM, Security Groups, and KMS are built in.
Hardened Security Posture: SmoothGlue utilizes STIG’d AMIs and implements IAM Roles for Service Accounts by default, providing granular, auditable, pod-level security controls that assessors demand.

This frees developers from having to become compliance experts and dramatically shortens the ATO timeline.

3. Taming Day 2 Operations with Self-Service and Automation #

A paved path requires maintenance. The SmoothGlue Console provides a command center for automating complex Day 2 operations and streamlining user onboarding. We handle the difficult lifecycle management tasks that paralyze platform teams, like the automated migration from Promtail to Alloy or providing a guided, blue-green upgrade path for the operatorless Istio migration. This ensures the platform remains modern and secure without burdening your team.

A Product, Not a Wrapper: The SmoothGlue Difference #

Thinking about the DevSecOps landscape today is like looking back at the rise of Linux. In the early days, choosing a Linux distribution was a critical first step, but it was just that—a start. No one would seriously claim that Google's global infrastructure is "just a wrapper for Linux." The OS is the foundational kernel, but the product is the immense value, integration, and capability built on top of it.

This is the right way to view the relationship between SmoothGlue and Big Bang.

Big Bang provides an essential, standardized kernel for DoD DevSecOps, from which SmoothGlue builds a complete, mission-ready product. SmoothGlue is not just a wrapper; it is the comprehensive suite of enterprise services, mission-specific integrations, and dedicated support that makes the foundation powerful, productive, and ready for serious production workloads.

The SmoothGlue platform ensures your deployed systems are truly production-ready with highly available configurations, right-sized resource defaults, and seamless single sign-on integration across tools. To guarantee mission success, dedicated support options cover everything from installation and operations to the end-to-end developer experience.

The goal of a DoD Software Factory is not to become an expert in managing a technology kernel. The goal is to deliver superior capability to the warfighter at the speed of relevance, which we have proven over the last 18 months, day-in and day-out.

Stop trailblazing. Empower your teams to focus on the mission, not the plumbing. Schedule a demo today to see how SmoothGlue can accelerate your software delivery.

From AI-Generated Code to Auditable Deployment: How Pillars of Creation Secures Our Agentic Workflow

2025-09-09T00:00:00Z

AI agents can now act as powerful co-pilots, bootstrapping entire applications from templates and natural language prompts. But in the world of enterprise-grade, highly regulated software, a burst of AI-driven creativity is only the first step. How do you take AI-generated code and ensure it’s secure, compliant, and trustworthy enough for mission-critical environments?

With SmoothGlue, we’ve answered that question by pairing our use of Agentic AI with Pillars of Creation (PoC), our proprietary CI/CD framework. PoC was specifically designed to simplify and unify pipelines for highly regulated sectors, such as defense and government. It acts as the essential bedrock of trust, taking the output of our AI agents and ushering it through a gauntlet of automated checks and balances.

This is how we combine the speed of agents with the rigor of DevSecOps…

The Role of Agentic AI: A Developer's Accelerator #

First, let's clarify what we mean by "Agentic AI." In our workflow, we use Large Language Models (LLMs), such as Claude Code or Gemini, as powerful project scaffolders. An engineer can start with our core templates, like the SmoothGlue Django Core, and use an agent to rapidly generate the boilerplate for a new project.

This dramatically accelerates the initial phase of development, handling tedious setup and allowing our engineers to focus on the unique business logic of the application. The agent delivers the first draft, but for that draft to become a deployed reality, it must meet the exacting standards of our clients.

The Challenge: Compliance in High-Stakes Environments #

Our customers, including lighthouse clients like the Kessel Run Software Factory, operate in sectors where security, compliance, and traceability are not just best practices—they are contractual obligations. The entire development process must align with stringent standards, such as the DoD DevSecOps Reference Design.

This is why we built PoC. Standard CI/CD tools were not enough; we needed a framework that had compliance and security baked into its DNA.

DevSecOps Reference Design

Introducing PoC: Our DevSecOps Foundation #

PoC is our answer to these challenges. It’s a modular, extensible CI/CD framework that provides a reliable path to production. Its core strength lies in several key features, which we think of as our "pillars":

Reusable, Pre-Configured Templates: PoC provides pre-built CI/CD templates for GitLab that dramatically reduce setup time and ensure consistency. This improves the developer experience, allowing teams to focus on delivering business value instead of managing pipeline configurations.
Automated Security and Quality Assurance: This is the heart of the framework. The pipeline automatically integrates a suite of best-in-class tools for linting, code scanning, secrets detection, and vulnerability assessments. We use tools like SonarQube, Semgrep, Checkov, and Trufflehog to continuously identify and mitigate security risks.
DoD-Compliant Image Builds: For our defense sector clients, we enforce security policies during the image build process, using DoD Iron Bank container images to ensure all containers are production-ready, secure, and compliant.
Automated Body of Evidence (BOE) Generation: To meet strict audit and regulatory requirements, PoC automatically generates human-readable documentation that proves compliance. This ensures our software is always in an audit-ready state, a critical feature for government environments.
Broad Technology Support: The framework is designed for modern, multi-language environments, with comprehensive support for Java, JavaScript, Go, and Python.

The Synergy: Full Workflow from Agent to Argo CD #

The magic happens when our Agentic AI workflow meets the PoC pipeline. Here’s how it works in practice:

AI-Assisted Creation: An engineer uses an Agentic LLM to generate a new project from our core templates.
Commit and Merge: The developer commits the initial code and creates a merge request in GitLab.
The Automated Gauntlet: This is where PoC takes over. The pipeline automatically performs a series of rigorous checks: linting, unit testing, code scanning, and secrets detection.
Secure Publication: Once all checks are passed, the developer artifacts are published to the GitLab Registry.
GitOps Deployment: From the registry, Argo CD securely deploys the application to the development environment, ensuring a traceable and reliable path to production.
Auditability: As a final step, a BoE is automatically generated, creating an immutable record that the deployed application has met all security and compliance standards.

Building the Future, Responsibly #

By integrating Agentic AI with our PoC framework, we get the best of both worlds: the incredible speed and efficiency of AI-powered code generation, and the uncompromising security and compliance demanded by our customers. It proves that innovation and discipline are not opposing forces, but necessary partners.

PoC ensures that no matter how code is generated—whether by a human developer or an AI agent—it is always subject to the same high standards. This is how we build the future, not just quickly, but responsibly.

3 Laws of Vendor-Lock Safety

2025-09-04T00:00:00Z

Vendor lock-in is rarely visible at the start. It hides in the fine print, in proprietary formats, and in opaque APIs. And by the time it's clear, organizations realize their roadmap is no longer their own. Decision advantage slows, costs rise, and resilience erodes.

At BrainGu, we believe freedom from lock-in isn't optional—it's the foundation of sustainable innovation. That's why we operate by three laws of vendor lock-safe platforms.

1. Data Exportable #

Data is an organization's lifeblood. When it's trapped in proprietary systems, you lose more than flexibility…you lose accessibility. Our principle is simple: data should always be structured for complete attainability and portability.

SmoothGlue was designed with this in mind. Whether running in the cloud, on-prem, or at the tactical edge, customers retain full control of their data. In defense contexts, this means mission-planning applications can be redeployed rapidly, even across disconnected or classified environments, without fear of vendor lock.

2. Source Available #

Software should outlast the vendor that delivered it. Through open-source components, escrow agreements, and intellectual property retention, organizations should never find themselves at the mercy of a disappearing dependency.

This is more than a safeguard; it's a resilience strategy. In highly regulated industries where continuity is non-negotiable, SmoothGlue provides assurance that core capabilities won't vanish with market shifts or contract transitions.

3. Interoperable Systems #

Many vendors promise openness but deliver only interchangeability—the ability to swap one vendor for another, often at great cost. Interoperability is different. It means platforms integrate seamlessly with other systems through open APIs and shared standards, working with the ecosystem instead of walling it off.

SmoothGlue embodies this principle. It doesn't just let organizations change tools, it allows them to weave in best-of-breed technologies, from Kubernetes to DoD's Platform One ecosystem, while maintaining security and compliance. Interoperability ensures flexibility without disruption.

Why It Matters Now #

By 2030, the world faces a projected shortage of 85 million developers. In this environment, platforms must accelerate decisions, not constrain them. Lock-in amplifies scarcity by slowing teams down and limiting their options.

Vendor lock-safe platforms create the opposite effect: they amplify human talent, safeguard investments, and extend the lifespan of innovation.

At BrainGu, SmoothGlue was built on these laws, not because it was convenient, but because anything less would be unsustainable for the missions we serve. From Air Force mission planning at the edge to commercial enterprises in regulated industries, we've proven that freedom and resilience can coexist with speed and security.

The Future Belongs to the Lock-Safe #

The best technology partnerships are not about control. They are about choice, flexibility, and long-term trust. By making data exportable and source available, and systems interoperable, organizations ensure they are not just buying software...they are investing in their own freedom to innovate.

BrainGu Welcomes Rick Jack as Technical Director, Deepening Commitment to Naval Innovation

2025-09-04T00:00:00Z

Grand Rapids, Michigan – Sep 4, 2025 – BrainGu, a mission-first software company delivering secure, scalable solutions for national security, is honored to welcome Richard “Rick” Jack as Technical Director, where he will focus on driving innovation in partnership with the U.S. Navy and broader defense community.

A distinguished C4ISR software engineer and former technical lead of the Navy’s Project Overmatch, Rick brings more than two decades of hands-on experience reimagining how the Department of the Navy develops, tests, and fields operational software. As the architect behind the Overmatch Software Armory and the Application Arsenal, he helped pioneer the Navy’s first enterprise DevSecOps pipeline, replacing manual software installs with over-the-air updates across the fleet.

Rick built core technical scaffolding for the Navy while championing speed and mission-first delivery. Combined with BrainGu’s DevSecOps, product-led platform approach, he’ll help us turn those practices into repeatable, scalable outcomes for the DoD,

said John “Spence” Spencer-Taylor, CEO of BrainGu.

Operationalizing Innovation at Scale #

Throughout his career at NIWC Pacific, Rick has led high-impact efforts across cloud infrastructure, model-based engineering, DevSecOps adoption, and software delivery to disadvantaged, distributed, and intermittently connected (DDIL) environments. His work helped lay the foundation for rapid application development pipelines, enabling the fleet to download and deploy apps on-demand, drastically reducing time-to-capability for afloat systems.

At BrainGu, Rick will serve as a cross-cutting technical leader across programs, working closely with platform, delivery, and product teams to ensure alignment between emerging defense needs and BrainGu’s capabilities, particularly those powered by the SmoothGlue ecosystem and WIDOW mission apps.

Reinforcing BrainGu’s Commitment to the Navy #

Rick’s arrival strengthens BrainGu’s already deep connection to the U.S. Navy. From delivering collaborative mission planning through WIDOW to enabling secure DevSecOps pipelines in air-gapped and classified environments via SmoothGlue, BrainGu has consistently delivered outcomes that align with the Navy’s strategic priorities: speed, survivability, and interoperability.

Rick embodies what it means to build with and for the operator,

said Matt Shaver, CTO of BrainGu.

His experience aligns directly with BrainGu’s mission to shorten the distance between vision and delivery. His perspective will help us ensure that innovation stays grounded in real-world impact.

A Vision for the Future #

Rick Jack’s appointment reflects BrainGu’s continued investment in the national security ecosystem—not just as a technology vendor, but as a mission partner. By integrating engineering excellence with operational urgency, BrainGu is building the platforms, tools, and culture needed to modernize how software supports the fight.

Reliability, Engineered in Code: How SmoothGlue Delivers Enterprise Trust

2025-08-26T00:00:00Z

In high-stakes environments, "good enough" isn't an option. Downtime isn't just inconvenient—it's unacceptable. That's why our customers trust the SmoothGlue Platform: not just for features, but for a promise of reliability.

That promise isn't accidental. It's the direct outcome of our deliberately engineered architecture—built for Reliability, Security, and Scale. This blueprint, our Marketecture, separates the Build process from the Run environment, ensuring every component is developed, tested, and deployed through a secure, automated, and repeatable process.

This architecture is the engine behind our recent successes. Here's how it translates into results.

Stability by Design #

0 Downtime — By Design

Over the past 60 days, SmoothGlue delivered new instances and more than 20GB of GitLab backups while maintaining a perfect record of zero downtime across IL4 & IL6 environments.

This is powered by our GitOps-driven foundation. By treating infrastructure and application configuration as code, changes are declarative, version-controlled, and auditable. Kubernetes handles orchestration and self-healing, eliminating manual configuration errors. The result: uninterrupted service without late-night heroics.

Upgrades Codified, Not Rented #

4 Enterprise Kubernetes Clusters. 1 Cycle. 0 Disruption.

Enterprise Kubernetes upgrades are notoriously risky and resource-intensive. SmoothGlue makes them routine.

When it's time to deploy, our GitOps synchronization ensures each cluster pulls the correct version predictably and safely. That's how we flawlessly upgraded four enterprise clusters to Kubernetes 1.31 in a single coordinated cycle—with zero disruption.

Scale Without More Bodies #

300+ Applications Running Across Secure Environments.

SmoothGlue now supports 300+ applications across secure environments, handling a record number of customer requests in July.

This growth doesn't require an army of consultants. On the Build side, developers get standardized tools, supported languages, and automated security checks. On the Run side, our container platform provides service mesh, tracing, lightweight BaaS, and monitored single sign-on. The system is end-to-end, so adoption accelerates without compromising security.

That's how we scale—through product-first design, not bigger contracts.

Beyond Features: Building Trust #

The proof is in the performance: zero downtime, seamless upgrades, and accelerating adoption. But these aren't just feature callouts—they're proof that our architecture itself is engineered for trust.

With SmoothGlue 7.0, we're doubling down on this foundation. By codifying expertise into a product, we're delivering reliability, consistency, and security at enterprise scale—not by checklist, not by people, but by design.

Reliability isn't staffed. It's engineered. And with SmoothGlue 7.0, it's automated.

👏 Kudos to our engineering team for turning best practices into a world-class platform and setting a new standard for enterprise reliability.

BrainGu Appoints Rachel O'Donnell as Vice President of Mission Systems Group

2025-08-13T00:00:00Z

Grand Rapids, Michigan – Aug 13, 2025 – BrainGu, a leading software company specializing in secure, scalable solutions for the national security community, is proud to announce the promotion of Rachel O'Donnell to Vice President of the Mission Systems Group, a role she has held in an interim capacity since April 2025.

A foundational leader at BrainGu since 2020, O'Donnell has played a pivotal role in the company’s transformation from a nimble startup to a purpose-driven enterprise. Formerly Director of Labs, she brings over a decade of experience in the defense and national security sectors and has been instrumental in aligning BrainGu’s advanced engineering efforts with real-world operator needs.

Aligning Technology with Real-World Needs #

As Director of Labs, O’Donnell led cross-functional teams through high-complexity environments, translating evolving mission requirements into scalable technical solutions. Her work streamlined operations, integrated emerging technologies into production workflows, and brought clarity to ambiguous, high-stakes scenarios, turning vision into repeatable value.

Her ability to bring structure and strategic direction to complex delivery landscapes, combined with deep subject matter expertise in the national security domain, uniquely positions her to lead BrainGu’s Mission Systems Group into its next phase of growth.

Rachel’s strategic vision and relentless focus on real-world mission outcomes have transformed how BrainGu brings advanced capabilities into the hands of our users,

said John "Spence" Spencer-Taylor, CEO of BrainGu.

I’m thrilled to make her appointment permanent as VP of Mission Systems Group. Her leadership will be critical as we scale our impact and deliver on the toughest national security challenges.

Rooted in the Mission, Focused on the Future #

As Vice President, O’Donnell leads the Mission Systems Group, a core pillar of BrainGu’s delivery capability. She will be focused on scaling impact without compromising agility, and ensuring that product development remains tightly aligned with the needs of end users in operational environments.

O’Donnell is a seasoned national security and defense analyst, driving mission-critical initiatives across government and industry. She has led teams delivering frontline capabilities while also shaping strategic direction and guiding cross-functional coordination at the executive level. Her career spans analytical, programmatic, and leadership roles throughout the defense community, with particular expertise in national defense policy and acquisition and emerging technologies.

Known for bridging the gap between strategy and execution, she consistently delivers results at both the operational and enterprise levels, ensuring that innovation remains grounded in real-world relevance. Her promotion reflects BrainGu’s deep confidence in her leadership and our continued commitment to delivering meaningful, scalable solutions for the nation’s most demanding challenges.

The Control Plane Manifesto

2025-08-06T00:00:00Z

This document outlines the strategic direction for our SmoothGlue platform. It is our "why"—the core philosophy that guides our architecture, our tool choices, and our mission to provide a world-class platform that accelerates development, ensures security, and simplifies operations for everyone.

Executive Summary: From Friction to Flow #

For years, building and deploying software has involved a painful handoff between Developers, Site Reliability Engineers (SREs), and Security. Each team speaks a different language, uses different tools, and optimizes for different outcomes. This creates friction, slows down delivery, and introduces risk. Our developers want to ship features; our SREs want stability; our security team wants to ensure compliance. Today, these goals are often in conflict.

Our platform strategy is designed to solve this fundamental problem by creating a single, unified control plane built on Kubernetes. Think of it as a universal translator and a central factory for all the resources our applications need.

Instead of developers learning five different tools to request a database or configure a security policy, they make a simple, standardized request. The platform intelligently interprets this request and provisions the right resource for the right environment—be it a simple database for a test environment or a highly-available, multi-region database for production on AWS or Azure.

By choosing Crossplane as the engine for this control plane, we are adopting a community-backed, production-ready standard. This allows us to:

Increase Velocity: Developers get what they need, faster, through a simple, self-service model.
Reduce Complexity: We hide the underlying differences between clouds (AWS, Azure, etc.) and environments, presenting a single, consistent experience.
Enhance Security & Governance: All resources, from the application to the database, are managed in one place, allowing us to apply security policies, audits, and guardrails consistently.

This is a multi-year strategic investment that moves us from manually stitching together disparate systems to building a true, scalable platform-as-a-product. It is the foundation for our next phase of growth and efficiency.

The Deeper Dive: Our Platform Philosophy #

The Core Problem: A Tale of Many Languages #

The central challenge we face is impedance matching. Our developers, SREs, and security experts all have valid concerns, but their tools and workflows don't naturally align.

Developers care about their application code. They live in Git, container images, and Helm charts. They (begrudgingly) understand Kubernetes manifests for their app.
SREs care about infrastructure, reliability, and observability. They live in tools like Grafana, Terraform, SSH, and cloud-specific consoles.
Security cares about policy, identity, and compliance. They need to enforce rules across every layer of the stack.

In the past, we bridged these worlds with fragile, custom-coded scripts and complex CI/CD pipelines—stitching Terraform outputs into Helm values, managed by one central team. This model was a bottleneck. It didn't scale, was prone to errors, and created a dependency on a small group of experts.

Our Guiding Principle: The Orchestrator is the Overmind #

Our strategy is to move as much of the "heavy lifting" as possible into the one layer we can guarantee is consistent everywhere: the Kubernetes control plane.

We're not just using Kubernetes to run containers; we're leveraging its powerful, extensible API as the central point of truth for our entire platform. Why here? Because we get a massive head start:

A Universal API: Kubernetes provides a stable, extensible API server with role-based access control (RBAC), auditing, and everything else we need, for free.
A Home for Policy: With tools like Kyverno, we can enforce security policies, validate configurations, and even automatically mutate objects to inject required settings.
A Familiar Interface: Developers already work with Kubernetes manifests. Extending this to include the infrastructure their app needs is a natural, incremental step.

This is our "stable ground." Everything below this layer is cloud-specific and variable. By building here, we create an abstraction that can endure changes in the underlying infrastructure. Yes, there is work to bridge that (a ton of it, in fact), but we have to pick our battles.

The Magic Ingredient: Crossplane and True Lifecycle Management

If Kubernetes is our foundation, Crossplane is the engine we install on top. It teaches the Kubernetes API to speak the language of external services like AWS, Azure, and GCP.

This is the key that unlocks true lifecycle management, a concept that declarative, one-shot tools, like Terraform, cannot provide on their own.

Constant Reconciliation: Crossplane doesn't just create a resource; it constantly monitors it. If a configuration "drifts" from its desired state (due to manual changes or errors), Crossplane automatically corrects it. This enforces security and repeatability.
Ownership and Garbage Collection: Every resource is owned by another, creating a clear chain of custody. When you delete an application, Crossplane can automatically clean up all the databases, user accounts, and permissions associated with it, preventing orphaned resources and cost overruns.
The Power of Composition: This is the real magic. We can define our own, simplified APIs. We create a custom API called PostgreSQLInstance.
- A developer requests a PostgreSQLInstance for their app.
- Behind the scenes, Crossplane checks the environment. In dev, it might provision a simple in-cluster Postgres pod. In prod on AWS, it provisions a highly-available, multi-region RDS instance with backups and encryption enabled.
- The developer’s request remains the same. The platform handles the translation. We define the "what," and the platform figures out the "how."

This allows us to bundle an application with all its external needs into a single, manageable unit that can be deployed anywhere with a single command.

Addressing the Challenges Head-On #

No strategy is without its tradeoffs. We are clear-eyed about the challenges and are actively working to mitigate them.

"Is everything just YAML?" The underlying API is declarative YAML, but this doesn't have to be the primary user interface. This API-first approach allows us to build intuitive "clicky GUIs" in the Console on top, hiding the complexity for most users.
"Are we locked into Kubernetes?" Yes, and this is a deliberate strategic bet. The Cloud Native Computing Foundation (CNCF) ecosystem, with Kubernetes at its core, is the industry standard for building modern platforms. Planning for a world beyond it today would be premature optimization. We see this not as a lock-in, but as a commitment to a stable, vibrant, and future-proof ecosystem.
"What about dependency on an external project?" Crossplane is a graduated project within the CNCF, the same home as Kubernetes. This provides a strong guarantee of neutrality and longevity. It is no different from our reliance on other critical open-source tools, like GitLab or Zarf.
"How do we prevent accidental deletion?" This is our most critical operational challenge. A single kubectl delete command could, in theory, wipe out an application, its data, and its encryption keys. We must architect robust solutions for this, including:
- Fortifying Permissions: Implementing stricter, fine-grained RBAC to limit who can perform destructive actions.
- Architectural Safeguards: Designing our Crossplane compositions with deletion policies and backup mechanisms that are specific to each cloud and infrastructure, ensuring data is retained even if the resource definition is removed.

"Crimson Tide" Moments in Software: When Teams Just Want the Radio to Work

2025-07-13T00:00:00Z

There’s a scene in the film Crimson Tide of a tension-soaked standoff aboard a nuclear submarine, USS Alabama, where the protagonists argue about an incomplete message received mid-crisis. Alabama receives an Emergency Action Message to launch nuclear missiles, followed shortly by another message during an attack by an enemy submarine, which leaves the radio broken and the second message incomplete.

This image from the film "Crimson Tide" (1995) is used under the Fair Use doctrine (17 U.S.C. § 107) for the purpose of commentary and analysis. No copyright infringement is intended.

One officer wants to proceed with the launch orders.

The other insists they must wait for message verification.

Lives hang in the balance, but the tension isn’t from action, it’s from ambiguity.

A broken deployment or a mystery alert doesn’t compare to nuclear war, but the emotional structure of that scene is painfully familiar to modern software teams.

Slack Message. PagerDuty Alert. Unknown Impact. #

In a complex system, a single misfired Slack message or a vague Grafana spike can throw a team into uncertainty:

Is this real?
Is it critical?
Should we roll back?
Is anyone else seeing this?

Suddenly, what started as a routine deployment feels like a standoff. The team is divided between action and hesitation, not because they lack skill, but because they lack clarity.

The Broken Radio is Real #

We’ve all been there:

Trying to trace a Slack thread while parsing a noisy dashboard.
Searching for confirmation that this alert is correlated with that rollout.
Watching confidence erode, not because the system is down, but because we can’t interpret what it’s trying to say.

In those moments, what every engineer wants is simple: Make the radio work. Make the message clear so they can act, lead, and decide.

In Crimson Tide they do just that. USS Alabama is able to fix their radio, receive the signal with the updated message “Terminate Launch”, and they follow the orders, preventing nuclear war.

This image from the film "Crimson Tide" (1995) is used under the Fair Use doctrine (17 U.S.C. § 107) for the purpose of commentary and analysis. No copyright infringement is intended.

We Don't Need More Tools. We Need Translation. #

Today’s systems don’t suffer from a lack of data. They suffer from a lack of semantic alignment, a shared understanding of what a signal means, and what should happen next.

Platforms need to surface meaning, not just metrics.
Alerts need to carry context, not just urgency.
Teams need clarity under pressure, not just visibility.

Build Systems That Lead with Confidence #

The highest-performing teams aren’t those with the most tools, but those who can interpret the signal in the noise and jump into action. If we want our platforms to scale, we need to design them for confidence and certitude, because in the heat of an incident, ambiguity can sink your ship.

Breaking Changes, Zero Drama: Big Bang 3.0 with SmoothGlue

2025-06-13T00:00:00Z

Building software for high-stakes, highly regulated environments, adopting the latest advancements, all while maintaining reliability and security is a challenge. That’s why our latest update is built for teams that refuse to compromise: SmoothGlue now integrates seamlessly with Big Bang 3.0, a significant leap forward in DevSecOps for those operating at mission-critical scale.

Embracing Big Bang: A Foundation for Success #

We chose Big Bang as a core component of the SmoothGlue platform for a reason: it's a broadly adopted, integrated, and battle-tested implementation of the DevSecOps reference design. Its robust framework lays down a proven foundation for secure, compliant, and high-velocity software delivery. By building on Big Bang, SmoothGlue brings customers the stability of a trusted supply chain, plus the momentum of a continuously evolving DevSecOps ecosystem.

Change the Box: SmoothGlue Solves Your Day 2 Challenges #

While Big Bang provides a powerful starting point, we know that a "big bang" approach to your entire DevSecOps journey leaves a lot of concerns unanswered. That's where SmoothGlue shines. We go beyond the foundational elements to tackle the complexities of Infrastructure as Code (IaC) and the messy, high-stakes realities of Day 2 operations.

Think of SmoothGlue as the hardened layer that connects and powers your entire delivery stack, filling the seams between Dev, Sec, and Ops so your systems actually run the way you designed them to.

SmoothGlue tackles:

Automated IaC: Provision and manage infrastructure with repeatable precision—no more snowflake environments, no more manual drift.
Streamlined Operations: Built-in automations and smart defaults reduce operator overhead, making routine tasks effortless.
Enhanced Observability: Rich telemetry gives you visibility where it matters, so you can detect, debug, and deploy with confidence.

Smooth Sailing Through Disruptive Changes: Navigating Big Bang 3.0 #

The transition to Big Bang 3.0 brings several powerful enhancements, but it also introduces disruptive, breaking changes, particularly with the deprecation of the Istio Operator and the shift to Grafana Alloy for telemetry. But where others leave you wrestling with upstream disruption, SmoothGlue absorbs the complexity so you don’t have to.

We know platform operators already carry the weight of keeping everything running. That's why we've focused on:

Minimizing Operator Work: Through thoughtful automation and intelligent migration paths, we've significantly reduced the manual effort required from your team. For example, the default transition from Promtail to Grafana Alloy is automated within SmoothGlue. While custom logging configurations still require some attention, we provide clear guidance and leverage upstream tooling to make it as straightforward as possible.
Minimizing Downtime: We know that downtime means lost productivity and potential revenue. Our engineering teams have designed the upgrade process to minimize service interruptions, ensuring your users are not significantly affected. For example, while the Istio migration in Big Bang 3.0 inherently involves some gateway recreation and brief downtime, we provided clear pre-migration steps and guidance to help you prepare and mitigate impact.
Incremental Adoption: We're rolling out these significant updates incrementally, starting with SmoothGlue 6.16 and culminating in 6.18, scheduled for release on June 25. This allows you to test and validate changes in your staging environments before they become default behavior, providing you with greater control and confidence.

Key highlights of how SmoothGlue eases your Big Bang 3.0 journey: #

Operator-less Istio Migration: The Istio service mesh provides mutual TLS encryption, policy enforcement, and observability of network traffic, making it a critical security and operations tool. With the deprecation of the Istio Operator, the way that this system is orchestrated will change, and manually performing this migration could incur lengthy downtime and frustration. SmoothGlue automates the core migration, and provides clear guidance for any necessary custom application adjustments. You can even test this beta feature in SmoothGlue 6.16 before its full adoption in 6.18.
Grafana Alloy Integration: Logging and observability are other critical components of a software delivery platform. We're proactively transitioning from Promtail to Grafana Alloy for telemetry, aligning with future upstream development and providing a more unified observability solution. SmoothGlue leads the transition, automating the switch for most setups and giving you a cleaner, more unified telemetry pipeline out of the box.

At BrainGu, we don’t think adopting the latest tech should feel like open-heart surgery. That’s why we built SmoothGlue on top of Big Bang, fortifying its core with automation, observability, and operational guardrails that go beyond the standard playbook. The result? You ship faster, and safer.

Ready to experience a smoother DevSecOps journey? Explore the latest SmoothGlue release today!

Already a SmoothGlue customer?

Dig into the Big Bang 3.0 migration guide for all the technical details.

The Cost of "More with Less": A Reflection on Platform Scale and Hidden Complexity

2025-06-04T00:00:00Z

Since I began working on platform teams, helping developers onboard, building internal tooling, and scaling infrastructure, one thing has become increasingly clear…

The complexity didn’t disappear. It just changed shape. #

At first, it was raw and obvious, as teams struggled with provisioning, CI/CD was stitched together with scripts, and onboarding meant hours of tribal knowledge transfer.

Back then, the pain was visible. What one engineer could hold in their head a decade ago was enough to ship with confidence.

Now, the platforms are smoother, providing powerful automation, GitOps pipelines, and golden paths. It looks like magic. But underneath that polish, something else is happening.

Automation Didn’t Make It Simple…It Made It Invisible #

The rise of new modern tooling, like DevSecOps, Kubernetes, and cloud-native everything, gave us incredible leverage, as the baked-in automation, configurations as code, and infrastructure as code made things a lot easier. They’re now abstract or hidden layers working behind the scenes, enabling teams to do more with less, but it's coming at a cost:

Fewer people truly understand the full stack.
Failures are harder to diagnose because the layers are deeper.
Contracts and scopes haven’t caught up with the complexity of these ecosystems yet.

We write SOWs like we’re still delivering standalone software, but we’re not. We’re integrating into layered systems with moving parts, external dependencies, and organizational silos. And the kicker is, it’s easier than ever to assume things are aligned when they’re not.

That’s why I keep coming back to the train journey metaphor. Each team boards at a different stop. One team might still be laying tracks, while another is optimizing a high-speed junction.

If teams don’t recognize where to board or which track they’re on, they could end up designing platforms that derail.

The Illusion of Effortless Scale #

When stakeholders see a polished developer portal or a one-click deployment button, it creates the illusion of simplicity. But simplicity at the surface often means sophistication underneath that requires care, coordination, and continuous learning. That’s where SmoothGlue can help...

We’ve enabled speed. We’ve reduced toil. But we haven’t eliminated the complexity; we’ve just moved it into fewer people’s heads.

So What Now? #

Rejecting automation isn’t the answer. However, we do need to stay vigilant about its cost, and this can be achieved by requiring:

Contracts that reflect integration, not just output.
Onboarding that respects each team’s unique starting point.
Platform teams that act less like service desks and more like translators, bridging the gap between intention and implementation.

Because scaling a platform isn’t just about building tools. It’s about building shared understanding in an environment where complexity is constant, even if hidden under the surface.

All Aboard: Why Building a Developer Platform Starts with Knowing Where the Trains Begin

2025-05-13T00:00:00Z

The reality is much messier.

IDPs, like subway systems, are complex, and consist of teams (or trains) that are all operating at different levels. Some teams are old steam engines just getting warmed up. Others are already high-speed bullet trains nearing their destination. And many are stuck between stations, juggling competing priorities and technical debt. This is the real landscape we build for, and it’s why SmoothGlue™ exists.

Different Teams, Different Tracks #

At any given moment, development, platform engineering, and security teams are each on their own journey. They’re moving at different speeds, starting from different places, and often aiming for different destinations.

Development teams might just be emerging from the chaos of manual CI/CD pipelines, scattered YAML files, and inconsistent testing. Their focus is to ship faster with fewer surprises.

Platform engineering teams are usually a bit further down the road. They’re building paved paths, standing up self-service portals, and creating reusable infrastructure patterns to bring order to the chaos.

Security teams, on the other hand, often have the guardrails in place. They know what “compliant” looks like, but the real challenge is integrating into the software delivery flow without grinding it to a halt.

This divergence of maturity, context, and velocity is why it’s risky to treat every team like they’re on the same track or timetable.

Why a One-Size Platform Doesn’t Fit All #

The core mistake many platform initiatives make is assuming uniformity: that every team will adopt the same interface, follow the same pipeline, or need the same automation from day one. But when you zoom out, you realize that Internal Developer Platforms (IDPs) aren’t highways. They’re rail networks, with multiple trains moving at different speeds, carrying different cargo, and needing different kinds of support.

If you build a platform for the fastest train, the others will derail. If you build for the slowest, the fast ones look for tracks elsewhere. That’s where empathy meets architecture.

What SmoothGlue Gets Right #

With SmoothGlue, we didn’t set out to build just another IDP with a fixed set of tools. We built a routing system that adapts to where each team is starting from and helps them travel smarter, not just faster.

Instead of forcing teams into a fixed toolchain or workflow, we enable something more flexible: progressive enablement. That means you can start where you are. No need to replatform your whole brain just to get going. Maybe that’s running manual scripts or gradually moving toward full GitOps.

We’re thoughtful about how SmoothGlue shows up for different users. Context-aware interfaces give developers a streamlined experience with what they need. Platform engineers get the controls and observability they want. Security teams get audit trails, policy enforcement, and the compliance signals they need to sleep at night.

In the end, SmoothGlue doesn’t assume a single, prescriptive path. It supports many journeys, all converging toward the same outcome: faster, safer, frictionless delivery.

The Role of Platform Teams: Conductors, Not Just Enforcers #

Platform engineering isn’t about laying down rigid tracks. It’s about acting as conductors, helping teams reach their goals safely and efficiently, whether they’re on a diesel engine or a maglev. That means meeting teams where they are, guiding them to where they could be, and measuring progress in terms of outcomes, not compliance.

Where Are Your Trains? #

If you’re building a developer platform or trying to adopt one, start by establishing where each of your trains begin, looking at each of your teams individually. From there you can decide how to support them on today's minimum viable journey.

“Where is each team starting from, and what’s the minimum viable journey I can support for them today?”

The best platforms don’t move teams the same way. They move them forward, each at their own pace, on tracks that converge over time. SmoothGlue was built with this reality in mind. If you're tired of platforms that assume uniformity and punish variance, maybe it's time to board a new kind of train.

BrainGu Promotes Jamil Jadallah to Vice President of Product

2025-05-07T00:00:00Z

Austin, TX – May 7, 2025 – BrainGu, a leading innovator in dual-use software platforms for highly regulated industries, today announced the promotion of Jamil Jadallah to Vice President, Product. This milestone marks a major step forward in BrainGu’s strategic journey from consultancy to product-enabled organization (2020–2025), and sets the foundation for its 2025–2030 vision as a fully product-led company.

Since joining BrainGu, Jamil has demonstrated exceptional leadership in platform development and a deep empathy for the developer experience—two pillars critical to BrainGu’s future. His focus on enabling builders through seamless platforms aligns directly with BrainGu’s mission to simplify complexity and deliver tangible, high-quality, production outcomes at scale.

“Jamil’s promotion is not only a recognition of his talent and impact, it’s a signal of where we’re headed,” said John "Spence" Spencer-Taylor, CEO of BrainGu. “His experience in building scalable platforms, combined with his clear focus on the developer journey, makes him the perfect leader to drive our next era of growth. As we consolidate key platform capabilities into a single powerhouse offering under SmoothGlue, Jamil’s leadership will ensure we can deliver exceptional experiences for our users and expand our impact in both commercial and defense innovation ecosystems.”

Jamil will oversee all aspects of BrainGu’s product portfolio, with a special focus on the continued evolution of SmoothGlue, the company’s Kubernetes-based flagship DevSecOps platform – as it integrates multiple related capabilities into one cohesive and mission-ready solution.

BrainGu’s move reflects a broader trend within the technology sector: success isn’t about consulting hours or customization alone, it’s about delivering repeatable, scalable products that empower users to achieve more, faster, and with greater security.

“I'm honored to step into this role at such a pivotal moment for BrainGu, and at a time when secure, resilient software delivery has never been more critical," said Jadallah. "Our team has built an incredible foundation, and our mission is clear: to empower commercial and defense organizations with platforms that aren’t just innovative, but repeatable, scalable, and built to meet the realities of modern operations. I’m excited to continue building alongside a team that knows how to turn complexity into clarity—and vision into velocity.”

Docs-as-Code: Automating Documentation for User-Centric Experiences

2024-12-23T00:00:00Z

Executive Summary

Our documentation framework is rooted in the Diátaxis methodology, not just for its organizational clarity, but because it creates a more user-centric experience. Dividing content into tutorials, how-to guides, reference documentation, and explanations ensures that users, whether developers or stakeholders, can find exactly what they need without digging through extraneous information. This separation helps maintain focus and relevance, which are crucial when users need fast, actionable answers.

We’ve also automated much of the documentation process using tools like MkDocs and Docusaurus, ensuring that changes to code or configurations trigger immediate updates to documentation. This approach aligns with a key principle in automation: documentation should evolve alongside the system, not lag behind. For architecture documentation, we apply the C4 Model, chosen for its simplicity and accessibility. By avoiding complex tools like UML, we empower all team members—not just architects—to contribute and understand. The diagrams are automatically updated via CI pipelines, keeping everything in sync with the current architecture.

For release documentation, we use Semantic Versioning, Semantic Release, and Conventional Commits to automate changelog creation, ensuring that every release is traceable and communicated efficiently across all channels. This practice not only enhances transparency but also provides a single source of truth for changes, making it easier for both technical and non-technical stakeholders to track progress.

User-Centric Documentation and Automation

Our Docs-as-Code initiative is built on a simple principle: treat documentation as a living, breathing part of the development process. By applying a GitOps approach, where documentation is stored and managed as Markdown in GitLab, we ensure that every piece of documentation is version-controlled, reviewed, and updated in sync with the code itself. When should this be adopted? Whenever your documentation is critical to compliance, security, or frequent iteration cycles. For highly regulated environments like the DoD, this practice guarantees that all documentation is not only accurate but also auditable, supporting strict compliance needs.

By using static site generators like MkDocs or Docusaurus, we can transform Markdown files into user-friendly interfaces, ensuring that whenever there’s a significant change in code or configuration, the documentation automatically reflects those changes. Why is this important? It prevents the common issue of out-of-date documentation, which can mislead users and undermine the trustworthiness of the platform. In a fast-moving DevSecOps environment, automation here ensures that documentation evolves with the platform, rather than becoming an afterthought.

The Diátaxis methodology structures content across four dimensions: tutorials, how-to guides, reference docs, and explanations. Why this structure? Because each type of content serves a different purpose for users, ranging from hands-on guidance to deep technical explanations. When should you use it? When your documentation needs to serve multiple audiences with different needs—in our case, developers, security teams, and non-technical end users.

User-Centric Focus

At its core, documentation should reflect who it’s for. We’ve adopted a user-first approach because different groups—whether they’re security stakeholders, developers, or end users like warfighters—need different kinds of information, and they need to find it quickly. Why this focus? Tailoring documentation for your audience ensures efficiency, improving the user experience by cutting down on time spent searching for relevant content.

For example, security teams are primarily concerned with how our platform adheres to RMF processes, while developers need quick-start guides and technical references for deploying on SmoothGlue. By focusing on the when and why of what each audience needs, we make sure the right information is accessible to the right people at the right time. When should you think about audience segmentation in documentation? From day one. Tailored documentation isn’t just a nice-to-have—it’s an operational necessity when dealing with complex, multi-faceted platforms.

Automated Architecture Documentation

One of the biggest challenges in DevSecOps is keeping architecture documentation up to date. By adopting the C4 Model, we solve the problem of complexity without sacrificing clarity. Why C4? Because it enables even non-architects to contribute to and understand architecture diagrams. These diagrams evolve with the system, ensuring that when there’s a change in architecture, the documentation reflects it immediately, not weeks later.

The diagrams are automatically generated via CI pipelines, ensuring that each time new code is committed or infrastructure is updated, the architecture is documented and version-controlled. Why automate architecture documentation? To reduce the risk of human error and ensure that documentation stays aligned with system changes. When should you automate this? As soon as your system starts evolving rapidly. Manual architecture documentation may work early on, but as complexity grows, it’s too easy for it to fall out of sync.

Automated Release Documentation

For release documentation, we leverage Semantic Versioning, Semantic Release, andConventional Commits. Why this trio? They provide a standardized way to automatically generate release notes and changelogs, ensuring traceability from feature requirements to code commits to final releases. This becomes especially important when your platform is mission-critical and every release needs to be tracked, validated, and communicated.

By automating release documentation, we ensure that every change, from minor bug fixes to major feature updates, is properly documented. When does this become critical? When transparency and accountability are non-negotiable—for example, when working with government clients or regulated industries. Automated changelogs reduce the manual workload on developers and ensure that no change slips through the cracks.

Conclusion: The Why and When of Best Practices for Automated Documentation

Automating documentation isn’t just about making life easier—it’s about ensuring accuracy, compliance, and efficiency. Why should you automate? Because manual processes break down at scale. When should you automate? As soon as your documentation becomes mission-critical to your operations, whether for internal teams or external stakeholders. By combining automation with user-centric content organization (via Diátaxis) and standardized release documentation (via Semantic tools), we ensure that our documentation is not only always up to date but also clear, accessible, and compliant with the strictest industry standards.

SmoothGlue 6.0 is available today!

2024-11-12T00:00:00Z

Grand Rapids, Michigan - November 12, 2024. SmoothGlue 6.0, is available today!

First, we want to announce that we’ve changed the name of our flagship Internal Developer Platform from Structsure to SmoothGlue. SmoothGlue better aligns with our design and engineering philosophy, and with the release of 6.0 which brings an enormous amount of new features and capabilities to our customers and users, it was the right time to change the name.

"Our shift from Structsure to SmoothGlue isn't just a product enhancement—it's a culmination of over a decade of dedication to secure software development, long before terms like DevSecOps and Zero Trust became industry buzzwords. Structsure and SmoothGlue have a shared history of tackling complexity with purpose, delivering solutions that allow developers in regulated environments to build with the same ease and sophistication as those in Silicon Valley. This consolidation reflects our deep confidence in what we've built and in our vision for the future. The fusion of 'Smooth' and 'Glue' isn't just about seamless integration—it represents our belief in simplifying the most demanding challenges, while achieving high-quality, tangible outcomes for our customers."

Spence

CEO of BrainGu

Unlike brittle software delivery tools, clumsy coordination tools, or frustrating security and compliance tooling, SmoothGlue is a complete and cohesive platform that helps teams through the entire software development, delivery, and management process, from laptop to production and beyond. We built the most robust, secure, and compliant software delivery platform to help teams in every industry thrive, no matter how complex or regulated their environment becomes.

Here’s a quick look at the top features SmoothGlue users can experience when they update to SmoothGlue 6.0.

SmoothGlue Console

SmoothGlue Console is BrainGu's proprietary management solution, designed to enable Mission-Critical Application teams, using SmoothGlue as their DevSecOps Platform, to deliver on their missions without requiring in-depth mastery of SmoothGlue tools.

Learn about Console

SmoothGlue Benefits

Improvements to the platform administrator experience include:

A dedicated admin user experience that allows teams to self-administer themselves without having to rely on an admin intervention increasing productivity and reducing bottlenecks.
A permissions-based user experience that allows platform admins to delegate administration to organization admins.
Quicker management of users’ collaboration applications (e.g., Keycloak, GitLab, MatterMost, and Argo CD) from one location, saving time on everything from minor application permission changes to onboarding entire teams in seconds to freeing up all application licenses in just a few clicks.

Control and monitor your deployed applications across many tools with SmoothGlue Console Deployments:

Deployments capture the health and status of applications across many technologies and instances, allowing users to dig into a specific tool or area, all in one self- service launch location.

Improved installation and initialization:

SmoothGlue Console works directly with applications and the Kubernetes API to gather real time data to install itself with minimal inputs.
Console initializes with an accurate state of platform applications and quickly allows users to start administering them.

Check out our recent post, "Empowering Our Users with More Tools at Their Disposal", to learn more about our newly incorporated capabilities that support our users’ ever-expanding mission set.

Nov 8, 2024 in Platform Engineering

Empowering our users with more tools at their disposal...

Our customer’s missions are growing in complexity each day, and we continuously evaluate and add new tools to our platform to meet those customer’s needs.

An Unparalleled Developer Experience

We believe the Developer Experience extends beyond CI/CD pipelines and have made significant improvements to the end-to-end process. We’ve introduced the following features and enhancements to ease not only the building but the deployment of code, as well:

Implemented automatic SSO connectivity, using Crossplane, with Keycloak and platform services. This is extensible to developer apps using the same patterns of configuration.
Built a “compatibility mode” to allow our platform to function on high-classification environments with limited or restricted AWS Cloud Services.
Focused on increasing the self-service capability for platform administrators.
Created an Amazon Machine Image (AMI) called “SmoothGlue Run Basic,” which enables developers to quickly spin up a single-instance node with the platform and start developing software the same day.

With SmoothGlue, we believe mission-critical enterprises will benefit from having the complete platform to build and ship quickly.

Empowering our users with more tools at their disposal...

2024-11-08T00:00:00Z

We are pleased to share that we've added the following tools to SmoothGlue's baseline:

Nexus Repository Manager

An alternative to GitLab to serve as a code repository.

Nexus IQ Server

An application vulnerability analysis tool to secure your software supply chain.

Vault

A solution to securing secrets, certificates, API keys, and tokens on the platform.

Metrics Server

Offers platform operators the ability to collect metrics from the platform.

Kiali

Enables platform users to visually interact with the Service Mesh provided by Istio.

Tempo

Allows platform operators to search for traces, generate metrics from spans, and link their tracing data with logs and metrics.

Expanding Crossplane Providers

Increasing our utilization of Crossplane Providers reduces the reliance on manual configurations or custom configuration-as-code to enable key capabilities, such as single sign-on (SSO) integration with Keycloak.

Additional Security and Compliance Support

To deepen and widen our security and compliance support, we’ve implemented and configured IAM Roles for Service Accounts for Velero (EKS distributions of Kubernetes only). This also allows applications to run with a restricted set of permissions to cloud services.

An Unparalleled Developer Experience

Implemented automatic SSO connectivity, using Crossplane, with Keycloak and platform services. This is extensible to developer apps using the same patterns of configuration.
Built a “compatibility mode” to allow our platform to function on high-classification environments with limited or restricted AWS Cloud Services.
Focused on increasing the self-service capability for platform administrators.
Created an Amazon Machine Image called “SmoothGlue Run Basic,” which enables developers to quickly spin up a single-instance node with the platform and start developing software the same day.

With SmoothGlue, we believe mission-critical enterprises will benefit from having the complete platform to build and ship quickly.

BrainGu Announces Strategic Restructuring to Increase Investment in Engineering and Product Staff

2024-09-03T00:00:00Z

Grand Rapids, Michigan - September 6, 2024. BrainGu, a pioneer in secure software development platforms, today announced a strategic restructuring to realign its resources and focus on strengthening customer-facing investments in product development and engineering. As part of this initiative, the company has made the difficult decision to part ways with a significant portion of its business operations team.

This decision, though challenging, reflects our commitment to balancing priorities in a bootstrapped company. As a bootstrapped organization, BrainGu has the unique flexibility and freedom to aggressively pursue and invest in innovation without the constraints that often come with external funding. However, this independence also brings with it the challenge of making difficult financial tradeoffs. Every investment must be carefully weighed, and we must prioritize initiatives that will have the most significant impact on our customers and our long-term success. This restructuring reflects our commitment to making those tough choices in the best interests of our customers and the future of our company.

"We recognize the impact this restructuring has on our team members, and we are deeply grateful for their contributions to the company’s success," said John Spencer-Taylor, CEO of BrainGu. "This decision was not made lightly, and we wish the best for everyone who's moving on. As we move forward, our focus remains on driving value for our customers by investing in the areas that matter most to them: product excellence and engineering innovation."

The restructuring is part of BrainGu's broader strategy to enhance agility, optimize resources, and position the company for sustained growth in a rapidly evolving market. By streamlining operations, we can better allocate resources to product and engineering, ensuring that our customers continue to receive exceptional service and support, and that we remain at the forefront of innovation in our industry.

BrainGu Appoints Matt Shaver as Chief Technology Officer

2024-08-23T00:00:00Z

Grand Rapids, Michigan - August 23, 2024. BrainGu, a pioneer in software development solutions, today announced the appointment of Matt Shaver as its new Chief Technology Officer. In addition to co-founding the company, Shaver has served in many roles, including most recently as an Engineering Fellow supporting software development efforts across the company's most challenging projects.

This strategic move comes as CEO and co-founder, John "Spence" Spencer-Taylor, steps down as CTO and transitions to fully focus on his duties as CEO, driving BrainGu towards its next phase of product-led growth and innovation.

With over two decades of software engineering experience, Matt Shaver has been a key architect at BrainGu since its inception. His expertise in software development, cybersecurity, and systems engineering has been instrumental in shaping their flagship platform, SmoothGlue. This revolutionary platform has transformed development processes in some of the most highly regulated industries including the U.S. Department of Defense, ensuring faster, smoother, and more secure operations.

In his new role, Matt will continue to leverage his extensive experience to provide the technical oversight required for the company’s rapidly expanding business. "At BrainGu, we don't just provide technology; we align with your mission," says Matt. "Our goal is to empower development teams bogged down by regulatory complexity, allowing them to focus on creating outstanding software."

As CTO, Shaver will steer the technical roadmap, lead a powerhouse team of engineers, and drive the company's technical vision.

Prior to serving as an Engineering Fellow, Shaver acted as BrainGu’s Vice President of Missions Systems Group where he spearheaded the development of a portfolio of mission planning, decision support, and data analysis applications like WIDOW, LIFTT, Nighthawk, Achilles, and more. His leadership across these initiatives has been instrumental in developing applications that are not just tools but mission-enablers, supporting critical missions from national security to enterprise operations.

John "Spence" Spencer-Taylor shared his enthusiasm about the transition: "As I prepare to evolve my role and dive deeper into building the business, I am thrilled to pass the baton to a lifelong friend and esteemed colleague. Together, we've journeyed through challenges and triumphs, and there's no one I trust more to lead our charge as we aim to use our technology to impact thousands of missions going underserved today. This change isn't just about growth; it's about preparing us to make that larger impact, ensuring that our next steps are as bold and transformative as our vision. Here's to the next five years of innovation, dedication, and mission success!"

With Matt Shaver stepping into his new role as CTO, BrainGu looks forward to delivering groundbreaking solutions that not only exceed the expectations of our customers but set a new standard for excellence in the industry.

DevSecOps at the Tactical Edge

2024-07-12T00:00:00Z

During my presentation, I broke down how DevSecOps is revolutionizing warfare by enhancing security and operational speed. By sharing real-world examples like SpaceX's rapid updates and drone use in Ukraine, I demonstrated how agile, secure software is a game-changer. Don't miss out—watch the video to see how we at BrainGu are leading the charge in global security with innovative software solutions.

Check out the video from Eurosatory

The Goal is Not the Platform

2024-07-10T00:00:00Z

In my talk, I emphasized the importance of viewing platforms as enablers that should seamlessly integrate into the background, rather than being the focal point. I explored how to shift the conversation from platform features to the broader value they bring to business processes and stakeholder satisfaction. Dive into my full talk to discover how rethinking platform roles can drive greater organizational success and agility.

Check out the video from PlatformCon

BrainGu Announces SmoothGlue Run Basic in AWS Marketplace

2024-07-03T00:00:00Z

Grand Rapids, MI (July 3, 2024) – BrainGu is excited to launch SmoothGlue Run Basic on the AWS Marketplace as an easily deployable Amazon Machine Image (AMI), significantly enhancing the accessibility and rapid deployment of this advanced dual-use software. This strategic launch ensures that mission-focused organizations can more quickly benefit from the swift acquisition and utilization of this powerful platform.

SmoothGlue Run Basic: Simplifying DevSecOps

One of the biggest challenges for cloud-native developers is getting applications to production and in the hands of end users. Smoothglue Run Basic addresses this by offering a streamlined path to deployment, minimizing time and effort spent on resolving security and compliance issues. Building on the foundation of SmoothGlue Run, introduced in March, SmoothGlue Run Basic offers an accessible entry point for organizations and individuals to adopt robust DevSecOps practices without the complexity.

SmoothGlue Run Basic provides organizations a slimmed down version of the SmoothGlue Run platform which is designed to streamline the DevSecOps process with a focus on resilience, scalability, and security. It equips developers with tools to deploy, operate, and monitor applications seamlessly, using industry-leading technologies like Kubernetes and Crossplane for a compliant and effective software delivery environment, meeting high-security mission requirements.

John “Spence” Spencer-Taylor, CEO of BrainGu, commented:

“The launch of SmoothGlue Run Basic in the AWS Marketplace is a game-changer. We're giving operators and mission owners the power to deploy secure, high-quality software rapidly, without the headaches. It's all about simplifying DevSecOps and accelerating innovation. This is our commitment to transforming how software gets delivered."

Targeted at Technology Leaders

SmoothGlue Run Basic is designed for CTOs, CIOs, application development leads, and entrepreneurs; ensuring compliance with rigorous standards and catering to organizations with high security and operational efficiency needs. It integrates with existing development tools, offering a robust solution for modern software development challenges.

Explore the SmoothGlue Run Basic AMI in the AWS Marketplace at smoothglue.com/aws. For more information about SmoothGlue Run Basic and the complete suite of products, visit braingu.com.

Mattermost Partners with BrainGu and goTenna to Enable Tactical ChatOps

2024-06-26T00:00:00Z

Source: Mattermost

Palo Alto, Calif., June 24, 2024 – Mattermost, Inc., a leader in secure collaboration for mission-critical work in complex environments, today announced that it has completed its $1.25 million Small Business Innovation Research (SBIR) Phase II contract, delivering mission-critical ChatOps capabilities for the Air Force Research Laboratory’s (AFRL) Tactical Assault Kit (TAK) and ATAK operating systems.

Built in collaboration with the development team at BrainGu, a leader in mission software solutions, the Mattermost integration for TAK improves distributed collaboration and enhances warfighter efficiency, safety and accuracy. Developed to improve TAK’s tactical chat function by providing secure, enterprise-grade ChatOps capabilities, the plugin also leverages the Mattermost open-source secure collaboration platform’s self-hosting capabilities, enabling teams to retain full data ownership and meet communications security (COMSEC) requirements. Additionally, with support from BrainGu, the Mattermost integration creates an extension for TAK capabilities, laying the foundation for future capabilities such as AI-enabled decision support tools.

“We’re pleased to address a demonstrated capability gap with the delivery of the Mattermost integration for TAK, enabling our operators to leverage streamlined ChatOps functionality that facilitates the mission-critical transmission of intelligence,” said Corey Hulen, co-founder and CTO of Mattermost. “In partnership with BrainGu and goTenna, we’ve developed this integration to satisfy the Department of Defense’s need for primary, alternate, contingent and emergency communications protocol.”

In addition to the secure ChatOps plugin, Mattermost and BrainGu also worked closely with goTenna, the world’s leading mobile mesh networking platform, to develop and deliver transmission-layer integrations for TAK on goTenna’s mesh radios, addressing challenges associated with low-bandwidth communications and providing resilient, decentralized connectivity. The goTenna plugin also offers support for ATAK systems, enabling seamless connectivity with TAK servers and ensuring scalability and reliability in diverse operational environments.

With new collaboration features now available, 350,000 civilian, DoD and partner TAK users can leverage the secure chat integration and low-bandwidth capabilities to effectively communicate mission-critical information between operational teams at the tactical edge and their forward operating bases (FOB) in near-real-time. The completion of this contract marks Mattermost’s second completed SBIR Phase II this year, just two months after the company announced the completion of its first contract with delivery of its message acknowledgment and urgency capabilities for the 618th AOC.

To learn more about how Mattermost enables mission-critical collaboration for government customers, visit https://mattermost.com/solutions/industries/government/.

Supporting Quotes

“Resilient communications is key to mission success,” said Tim Gast, Vice President, Labs, at BrainGu. “We’re proud to join Mattermost and goTenna in putting innovative software in the hands of warfighters to enhance decision quality and drive positive outcomes, and we’re looking forward to continuing our pursuit of what’s next.”

“We’re pleased to support tactical ChatOps and aid in the transmission of mission-critical intelligence across distributed environments, enabling support to operators working in low-bandwidth conditions via goTenna’s mesh capabilities,” said goTenna CEO Ari Schuler. “The goTenna and Mattermost partnership brings together two operator-focused companies seeking to support hundreds of thousands of airmen and TAK users with the secure communication they need to be successful in their mission.”

About Mattermost

Mattermost is the leading collaboration platform for mission-critical work. We serve government, defense, aerospace and critical infrastructure in their support of the national security strategy. We accelerate decision advantage through self-sovereign collaboration, critical incident management and DevSecOps workflows to bolster the focus, adaptability and resilience of the world's most important organizations.

Our enterprise software and single-tenant SaaS platforms are built to meet the custom needs of rigorous and complex environments while offering a secure and unrivaled collaboration experience across web, desktop and mobile with channel-based messaging, file sharing, audio calling and screen share, with integrated tooling, workflow automation and AI assistance.

Mattermost is developed on an open core platform vetted by the world’s leading security organizations and co-built with over 4,000 open source project contributors who’ve provided over 30,000 code improvements towards our shared vision of accelerating the world’s mission critical work.

For more information, visit mattermost.com.

About AFRL

The Air Force Research Laboratory (AFRL) is the primary scientific research and development center for the Department of the Air Force. AFRL plays an integral role in leading the discovery, development and integration of affordable warfighting technologies for our air, space and cyberspace force. With a workforce of more than 12,500 across nine technology areas and 40 other operations across the globe, AFRL provides a diverse portfolio of science and technology ranging from fundamental to advanced research and technology development.

For more information, visit afresearchlab.com.

About goTenna

goTenna is advancing universal access to connectivity by building the world’s most intelligent and scalable mobile mesh networks. goTenna is the world’s leading mobile mesh networking company, providing off-grid connectivity solutions for smartphones and other devices, as well as augmenting traditional communications networks. This technology enables mobile, long-range connectivity without cell, wifi, or satellite connectivity. goTenna’s drive to create resilient connectivity began during Hurricane Sandy in 2012 when approximately a third of cell towers and power stations in affected areas failed. goTenna’s products are currently used by over 300 law enforcement, military, and public safety agencies worldwide. Based in Brooklyn, goTenna is backed by investors including Founders Fund, Union Square Ventures, Comcast Ventures, Collaborative Fund, and Bloomberg Beta.

For more information, visit gotenna.com.

Unveiling SmoothGlue Run

2024-03-19T00:00:00Z

Grand Rapids, MI – BrainGu, a pioneer in software development solutions, today announced the launch of SmoothGlue Run, an innovative addition to the growing cloud-native landscape. SmoothGlue Run, the latest addition to SmoothGlue, BrainGu’s suite of tools for developers, reframes and reconsiders the traditional paradigm of ‘Deploy’, ‘Operate’ and ‘Monitor.’

We believe that the complexity of the cloud-native landscape is quickly moving beyond platforms to requiring distributed operating systems that run at a lower layer and remove cognitive complexity while providing context to meet the growing demands of the communities our products support. “With SmoothGlue Run, we didn’t want to put out just another opinionated DevSecOps platform in an already crowded CNCF landscape. We aimed for a thorough reevaluation of Internal Developer Platforms and DevSecOps practices. Instead, we address the evolving challenges and business needs in both the cloud-native and edge-native space” said Jamil Jadallah, BrainGu’s Vice President of Solutions Management.

SmoothGlue Run, is designed to be (rs)² –resilient, scalable, reliable, and secure– out of the box. A distributed operating system, it is tailored for delivering and distributing applications securely to both cloud and edge computing. Built on industry-leading tools like Kubernetes and Crossplane, SmoothGlue Run includes additional tooling that ensures a compliant and effective software delivery environment that will stand up to the needs of even the most critical and high security missions.

Central to SmoothGlue Run is the SmoothGlue Console, providing users with a comprehensive view of their infrastructure, software, and data across their environment. Console offers this essential functionality for free, and is the gateway to a range of advanced features, paving the way for easily integrating and activating future capabilities. It represents BrainGu's commitment to creating accessible yet powerful technology solutions.

John “Spence” Spencer-Taylor, CEO of BrainGu, stated, "With SmoothGlue Run, we're not just launching another product; we're fundamentally simplifying lifecycle management for platforms and the software that runs on them. It's designed to meet the evolving needs of today's tech leaders and mission-focused organizations, ensuring a future-proof way to deliver high quality software at speed and scale.”

Aimed at CTOs, CIOs, and application development leaders, SmoothGlue Run aligns with some of the most rigorous compliance and information protection regimes and standards, catering to organizations with high security and operational efficiency needs.

The introduction of SmoothGlue Run sets the stage for BrainGu's comprehensive suite of developer experience capabilities. The upcoming release of SmoothGlue Run add-ons will deliver even more operational capability and the future release of SmoothGlue Build will further enhance the 'Plan' and 'Code' stages of the DevSecOps lifecycle.

Jadallah further expressed his enthusiasm, saying, “The unveiling of SmoothGlue Run marks a significant milestone for BrainGu. Born out of our own internal challenges, this solution has not only been a testament to our problem-solving capabilities but is also a reflection of our commitment to the broader community. We are thrilled to extend the benefits of our innovation to others, showcasing our belief in collaborative growth and shared success.”

With SmoothGlue Run, BrainGu reinforces its commitment to innovation and support within the DevSecOps community, continuously adapting to the evolving digital landscape.

BrainGu will preview this new product offering at KubeCon + CloudNativeCon Europe, booth #H-16, from March 19 - 22, 2024, in Paris, France. For more details about SmoothGlue Run and the full product suite, visit smoothglue.com.

Hardened Kubernetes and Edge Computing for Field-Deployable Applications

2024-01-29T00:00:00Z

In the realm of software development, particularly when we’re talking about DevSecOps—which blends development, security, and operations—theoretical concepts can often seem abstract and intangible.

This is where our prototype field-deployable compute cluster comes into play. It serves as a physical manifestation of BrainGu’s Structsure™ DevSecOps platform, effectively demonstrating DevSecOps and Internal Developer Platform capabilities in a real-world setting. This prototype was developed to be fully compliant with the DoD DevSecOps Reference Design, and not only adheres to the highest standards of security and efficiency but also brings the sophistication of the Structsure platform. It is accessible, understandable, and demonstrates how integrating robust security practices from the outset can lead to powerful, efficient, and secure software solutions.

The Core: Demonstrating Structsure's Principles through the Prototype

This field-deployable cluster prototype is a living embodiment of the principles that drive Structsure. Each element of the prototype illustrates what we refer to as the “(rs)^2 principles” (Resiliency, Scalability, Reliability, and Security), which are central to DevSecOps and align with the stringent standards of the DoD.

Resiliency

The cluster’s design allows hot swapping of compute nodes, which ensures that operations continue running smoothly, even in the event of hardware malfunctions. This capability reflects our deep understanding that resilience is essential in dynamic computing environments.

Scalability

The modular nature of this prototype exemplifies Structsure's adaptability and how systems can evolve in response to changing demands, easily scaling up or down, not only based on workload requirements, but also based on physical constraints, such as size, weight, power consumption (SWaP), and portability considerations, a hallmark of agile and responsive technology.

Reliability

From earlier versions to the current iteration, the prototype reflects Structsure's commitment to reliability, evolving through real-world testing and enhancements to ensure performance and reliability in a variety of conditions.

Security

Compliant with the DoD DevSecOps Reference Design, the prototype is a testament to Structsure's emphasis on security. Its architecture showcases how Structsure protects data and operations, crucial in both defense and commercial applications.

Evolution: From Concept to Perfection

V1: The Foundation Phase

Our journey commenced in November 2022 with the first iteration of the field-deployable compute cluster, a pioneering step in portable edge computing. This initial prototype, featuring three Lattepanda 864s boards as worker nodes and a Dell Optiplex 7050 Micro workstation as the control plane, laid the groundwork for our revolutionary approach in demonstrating DevSecOps. Encased in a Pelican Storm IM2300, complemented by 3D printed and laser-cut acrylic components, this prototype was our first foray into blending functionality with feasibility, setting the stage for the innovations that Structsure would embody.

A crude mockup.

Core components installed.

Acrylic top panel cut out and engraved.

Top panel mocked up and test fitted.

Final components mounted and tested.

Test fire!

On display at AFCEA West 2023.

We quickly recognized that we needed to improve the design before the next show, KubeCon + CloudNativeCon EU 2023.

V2: Refinement and Evolution

Leveraging insights from our initial model, the second-generation prototype marked a significant design evolution. We maintained the robust Pelican Storm IM2300 housing but introduced critical changes: replacing the Dell workstation with three additional Lattepanda 864s boards, bringing the total to six. This not only allowed for the creation of a highly available control plane but also optimized resource distribution, reflecting Structsure's principle of a balanced and efficient system architecture. The physical design underwent a comprehensive overhaul, enhancing precision and durability—a testament to our commitment to continuous improvement in our DevSecOps journey.

Added a 6-node compute dock.

Added a Surface tablet for observability of the cluster.

Discovered thermal issues in the new configuration.

Switched to an aluminum enclosure.

Added fans to exhaust the heat.

Got temps down to a manageable level.

Showcased at KubeCon + CloudNativeCon Europe 2023 in Amsterdam: The v2 prototype featuring two Valve Steam Decks integrated as additional worker nodes.

On the cluster, we were running the chaos engineering game, Kubedoom, where in-game actions would dynamically impact Kubernetes pods and resources, displaying Structsure's resilience and reliability through seamless recovery.

On the way back to America—it survived the trip just fine! #reliability.

Attempted to fix the thermal warping of the individual cases. 😑

v2 on display again at DSEI 2023 in London.

Spence 11:11

We’re going to need something better for KubeCon North America.

Tim 11:22

I’ve got just the thing!

V3: A Technological Marvel

The third-generation prototype brings us to the zenith of our innovation. This version showcases a paradigm shift not only in design but materials, as well.

The cluster is now composed of six identical Lattepanda SIGMA 32GB compute nodes and features a skeleton composed of aluminum extrusion—an aerospace-grade material known for its strength and lightness. The structural components, laser-cut from 1/4" thick acrylic, provide a perfect balance of stability and weight. Introducing polycarbonate 3D printed parts adds a touch of resilience, ensuring durability in demanding scenarios. The entire ensemble is now elegantly enclosed within a sleek and durable Pelican Air 1535 case.

Lattepanda SIGMA has entered the chat.

A working prototype dock has emerged.

We needed something with a little more space, and WHEELS!

SIGMA worker node populated with coral.ai accelerator, and 1.5t of NVMe storage.

v2 of the box cannibalized for some parts reuse. 😢 Hopefully, v3 works!

Test fitting the Sigma nodes in the AIR case with the aluminum skeleton. Looking promising!

Freshly printed polycarbonate docks for assembly.

All six nodes in the dock test fit in the case.

Skeleton complete - Power supply and network mounted and wired in.

Display and Raspberry Pi mounted into the lid for observability of the cluster.

v3.0 on display at KubeCon + CloudNativeCon NA 2023.

Discovered a design flaw that wasn’t apparent until we put the box under some real-world stress.

The new power supply arrangement required a complete refactor.

During this redesign, the corner of my office became a warzone!

New AC inlet configuration.

New MS Surface tablet mounted in a custom cut acrylic frame.

A Symphony of Innovation: Merging Hardware with Structsure's Software

The evolution from our initial prototype to the current state is not just a tale of technological advancements, it's a narrative of pushing boundaries in design and materials, intertwined with the sophisticated orchestration of Structsure's software capabilities.

The synergy between the hardware's robust composition and Structsure’s resilient architecture creates a harmonious blend. Each aspect of the hardware—from its aluminum framework to its computational power—is meticulously aligned with Structsure's core principles of resilience, scalability, reliability, and security.

Resilience in Integration: The hardware’s durable design complements Structsure’s resilient architecture, ensuring uninterrupted service delivery and maintaining system integrity in the face of hardware challenges.
Scalability through Synergy: The system’s modularity and computational resources, paired with Structsure's dynamic scaling capabilities, offer an adaptable environment that can scale up, or down, to efficiently handle virtually any workload.
Reliability by Partnership: The combination of the cluster’s reliable hardware and Structsure’s consistent runtime environment results in an established infrastructure for seamless operation of critical applications.
Security from the Foundation: Both hardware and software share a commitment to security. The cluster’s compliance with the DoD DevSecOps Reference Design, coupled with Structsure’s Zero Trust Architecture and continuous security protocols, forms a comprehensive defense strategy, vital in both commercial and defense applications.

The Intersection of Innovation and Practical Deployment with Structsure

The fusion of the field-deployable edge computing cluster and Structsure’s DevSecOps platform symbolizes the union of innovative technology with practical deployment considerations.

Structsure's focus on creating a developer-friendly, scalable, and secure environment ensures that our prototype functions not only with computational efficiency, but also with the intelligent and strategic application that modern DevSecOps necessitates. As we continue to evolve and redefine the landscape of edge computing, our prototype stands as a testament to the successful integration of cutting-edge technology and thoughtful design, embodying the core values and capabilities of Structsure.

Stay connected to keep up on our latest innovations and experience Structsure's dynamic capabilities firsthand. If you’re lucky, you can grab a hands-on demo of this edge-deployable prototype, and who knows, you might even catch us throwing it out of an airplane!

Follow BrainGu on LinkedIn or explore Our Events to find out where we'll be in 2024. Join us on this exciting journey into the future of DevSecOps!

BrainGu Named to the 2023 Deloitte Technology Fast 500

2023-11-08T00:00:00Z

GRAND RAPIDS, Mich., November 8, 2023 (Newswire.com) - BrainGu, a leading innovator in software development platforms, has been named to the 2023 Deloitte Technology Fast 500™ list. The 29th year of this list ranks North America's fastest-growing technology, media, telecommunications, life sciences, and fintech companies based on fiscal year revenue growth from 2019 to 2022. Making its first list appearance, BrainGu secured the 173rd position with an impressive 818% growth rate during this period.

"We are honored to be named to the 2023 Deloitte Technology Fast 500 list,” said BrainGu CEO, CTO and co-founder John “Spence” Spencer-Taylor. “This recognition directly reflects our unyielding commitment to delivering robust, scalable software solutions that meet the critical needs of both the federal and commercial sectors. Our impressive growth rate is not just a metric; it is an affirmation of our team's relentless drive for innovation, the loyalty and trust we have earned from our customers, and the industry's growing recognition of the necessity for platforms, such as our Structsure® offering, that are (rs)2: resilient, scalable, reliable, and secure.”

As technology continues to evolve, BrainGu is at the forefront with its leading-edge DevSecOps platform suite: Structsure®. Trusted by a diverse base of federal and commercial customers, Structsure applies DevSecOps principles at all levels to ensure platform stability and comprehensive security while fostering innovation and developer autonomy.

This Deloitte recognition adds to the company's growing list of accomplishments including ranking 19th on the Washington Technology Fast 50 List, recognizing the fastest-growing small businesses in the government market. As BrainGu continues to expand its reach and capabilities, it remains committed to delivering software solutions that meet the evolving needs of companies across industries.

Announcing Structsure® 5.0 BrainGu showcases the latest release of its DevSecOps Platform Suite at KubeCon + CloudNativeCon North America 2023

2023-11-01T00:00:00Z

Chicago, IL (November 6, 2023) - Fueled by a passion for innovative software platforms that are (rs)² : Resilient, Scalable, Reliable, and Secure, the BrainGu crew is headed to Chicago to commune with adopters and technologists from the world’s leading open-source and cloud-native communities at KubeCon + CloudNativeCon North America 2023.

As a proud Silver Sponsor, BrainGu has carved out its own corner of McCormick Place West at Booth D27. But the BrainGu crew isn’t only in the Windy City to sample deep-dish—we’re also showcasing the ever-expanding capabilities of Structsure 5.0, the latest release of BrainGu’s DevSecOps Platform Suite.

Structsure enables resilient, scalable, reliable, and secure automated DevSecOps software delivery for any project regardless of size, industry or regulatory roadblock—in weeks, not months. Our team of DevSecOps Platform Engineers don’t believe in reinventing the wheel. Instead, they carefully curate, integrate, and secure a widely expanding array of technologies from the Cloud Native Computing Foundation (CNCF) Landscape and beyond. Structsure is built on top of Kubernetes, Crossplane, and Big Bang–an open-source and Curated, yet extensible, development platform toolkit built for highly secure use cases.

With Structsure, the age-old dilemma of "build vs. buy" is rendered obsolete. Structsure provides a serious head start right out of the box, allowing engineers to get right down to developing applications—instead of spending months or years researching, designing, building, and securing a custom platform from scratch. Platform and Application developers can focus on coding, and not managing tooling chaos.

In the ever-changing tech world, it's easy to get lost in buzzwords that often don't deliver on their promises. With Structsure, our goal has always been to demystify these technologies and make them accessible, practical, and beneficial for developer teams. Some of the key technologies Structsure empowers you with include:

Containerization: Structsure is built from hardened OCI containers, ensuring applications and their dependencies are efficiently packaged, and their attack surface minimized.
CI/CD: Structsure's integration with GitLab, ArgoCD, and a fortified DevSecOps pipeline means your code changes are seamlessly transformed into secure, tested, and deployed applications.
Orchestration & Application Definition: We harness the power of Kubernetes and Crossplane, ensuring your applications and their infrastructure components are orchestrated without the fuss.
Observability & Analysis: Whether it's monitoring with Prometheus and Grafana, logging with ElasticSearch or Loki, or tracing with Jaeger or Tempo, you have a 360-degree view of your platform and applications.
Service Proxy, Discovery, & Mesh: With Istio's service mesh and Kiali's network observability, you get enhanced routing, load balancing, and airtight security with mutual TLS.
Networking, Policy, & Security: Structsure doesn't just talk about security; it enforces it. With Kyverno's policy-as-code and the choice between Twistlock or Neuvector for container security, we've got you covered.
Single-Point of Entry: Structsure streamlines access with its Console, a unified dashboard that integrates and manages all of your teams and their tools. Paired with Keycloak, it ensures secure Single Sign-On (SSO), simplifying user authentication and enhancing productivity.

At BrainGu, we're not just adding features for the sake of it. Each component of Structsure is meticulously chosen and integrated to empower developers. With us, you're not just catching up with the tech curve; you're ahead of it.

BrainGu Co-Founder, John Spencer-Taylor, Structsure CTO, Taylor Mitchell, and a group of BrainGu technical experts will be on hand to discuss how BrainGu’s modular and extensible architecture adapts to the changing needs and requirements of any customer. Explore how (rs)² provides the necessary context and tooling to foster innovation through developer autonomy, all while improving platform stability and security.

While visiting BrainGu at KubeCon + CloudNativeCon North America 2023, you can also expect to:

Learn how Structsure 5.0 helps both Platform Engineers and Application Developers unlock innovation for their organizations or projects.
Score some rad burrito stickers and other pieces of highly coveted BrainGu swag!
Terminate Kubernetes pods with extreme prejudice in BrainGu’s hands-on chaos-engineering KubeDoom demo running on Steam Deck and powered by Structsure Edge.

Kelsey Hightower said ‘Rolling your own platform has never been easier. All you gotta do is pick 200 items from [the CNCF landscape] and you're good to go.’ We took that challenge head-on, curating the finest open-source solutions to craft a comprehensive DevSecOps Platform Suite that includes a single point of entry, a Data-Layer/Data Mesh Platform, an Internal Developer Platform, and App Operations Platform. As proud sponsors of KubeCon + CloudNativeCon North America, we’re eager to connect and collaborate with some of the industry's best. - John Spencer, CEO & Co-Founder

Can’t make it to Chicago? Visit our KubeCon North America Event Page for more information and video content.

BrainGu Ranks 19th on Washington Technology Fast 50 List, Showcasing Exponential Growth and Technical Prowess

2023-10-31T00:00:00Z

TYSONS CORNER, Va., October 31, 2023 (Newswire.com) - BrainGu, the pioneering force behind cutting-edge DevSecOps Platforms, is thrilled to announce its ranking as the 19th fastest-growing small business in the government market on the Washington Technology Fast 50 List.

The Washington Technology Fast 50 List evaluates nominees based on their compound annual growth rate from 2018 to 2022, during which we’ve been proud to boast a 65.2% compound annual growth rate, reflecting our continued dedication to delivering mission-critical solutions and exceptional technical capabilities. This recognition underscores BrainGu's unique offering to the government technology sector as a Non-Traditional Defense Contractor and further solidifies the power of dual-use commercial technologies in the defense and intelligence space.

“The BrainGu team's drive over the last five years has made an incredible impact not only on our growth as a company, but more importantly on the quality of the mission outcomes we’ve enabled for our customers,” said John ‘Spence’ Spencer-Taylor, CEO, CTO & Co-Founder. “Being recognized by Washington Technology is a sign to me that we’re making the right choices in creating positive disruption for highly-regulated industry through developer platforms.”

BrainGu takes pride in its commitment to providing world-class technology solutions. Foremost of these is Structsure®: a robust DevSecOps Developer Platform Suite built on Kubernetes, Crossplane, and Big Bang. Structsure empowers software development teams to deliver mission-critical applications securely, with the agility to scale and adapt to challenges—whether in the cloud, on-premises, or at the edge.

In the age of software defined warfare, every combat domain is rapidly evolving into a seamlessly connected digital landscape. This transformation is at the core of BrainGu’s Data Mesh Platform, SmoothGlue™, which merges data, analytics, and visualizations into 3-tier, n-dimensional applications. SmoothGlue bridges the gap between operational and tactical levels, revolutionizing planning, execution, and debriefing applications. SmoothGlue is more than software—it’s cutting-edge JADC2 capability.

For more information about BrainGu and its innovative offerings, please visit our solutions page.

Review the Fast 50 list here: https://washingtontechnology.com/rankings/fast-50/2023

Continuous Problem Solving

2023-09-19T00:00:00Z

The team starts. Depending on the contracting cycle, you’ve been anticipating this day for weeks or even months. You know each other, are familiar with work patterns, and have each been successful on different projects. As you start, you review the contracts for things you have to do and match that with the massive list of customer needs to be solved. Now the question is, where do we start?

One useful adjustment suggests deciding which tasks are more complicated than others and require more resources. And with those more complicated tasks, you can break them into smaller tasks that can be completed sooner, meeting a Minimum Viable Product approach and letting the whole team feel successful. This continuous problem-solving (CPS) approach (framework below) provides a useful starting point to make those decisions.

Teams in modern software development face a wide variety of problems on a daily basis. These teams are smart, motivated, and possess a wide range of personal experience. While these teams eventually solve problems effectively, the time to coordinate and plan for these problems can use cycles better spent in actually solving problems rather than merely creating a new process for each iteration. Problems to be solved include management and software development, personal conflicts, and business development.

BrainGu uses the (rs)² format to assess quality through resilient, scalable, repeatable, and secure functions. CPS supports these concepts, has worked across BrainGu contracts, and draws heavily on proven Agile and DevOps concepts. The concept is scalable as different problems can occur at different levels based on the team concept and the typical problems. Resilience occurs through having a stable approach that one can move backward and forward along the iterations. Security is not identified as an individual ask, but will built into the approach for software. This means the epics, stories, and tasks will have security guidance as part of the acceptance criteria. A contracting task might include protecting PII while software development could include various scans or approvals.

CPS divides problems into four tiers, simple, complicated, complex, and strategic. If we compare these to yarn, tier 1 is untying a knot from a single piece of yarn; one can clearly visualize where to go. Tier 2 is several pieces of yarn tied together; it can still be unraveled but takes more time. Tier 3 works the same, unraveling an entire ball of yarn, and Tier 4, strategic issues, asks where the yarn came from in the first place and why it is that color. An example problem might be that a user approaches and wants to build a new API gateway to manage their customer access. The entire problem is a Tier 3 as multiple solutions need to be leveraged together. This might break into Tier 2 issues for designing a gateway, connecting to existing databases and tools, identifying user access strategy, and building a web access point. At Tier 1, we have issues for a single individual, deploying a completed system, identifying users, building a new user account request, and other similar issues.

That provides an engineering example, but you ask, “how does that apply to other work, such as business operations?” From a business perspective, if the problem is integrating a new customer, that becomes a Tier 3 issue. The Tier 2 issues might be completing the contract, understanding customer needs, and identifying the right individuals. Tier 1 issues might be ensuring the payments occur correctly, hiring the right people to fill the contract, and getting bodies on-site at the right time and place.

Overall, this CPS approach is not a firm set of rules but a framework. The framework helps by reducing the time one spends on deciding how to approach the problem to time actually spent solving the problem. It assists with traditional Agile in limiting context switches. It also helps identify resources through the tiers to manage capacity and velocity better. Using this CPS won’t solve your problems for you, but it will make the process less painful and more expedient for everyone involved.

BrainGu is headed to KubeCon + CloudNativeCon Europe 2023

2023-04-14T00:00:00Z

Grand Rapids, MI: The containerization crew at BrainGu is headed to Amsterdam! Fueled by a passion for innovative software platforms that deliver (rs) 2 : Resiliency, Scalability, Reliability, and Security, BrainGu is crossing the Atlantic to commune and commiserate with adopters and technologists from the world’s leading open-source and cloud-native communities.

As Silver Sponsors of KubeCon + CloudNativeCon Europe, BrainGu has carved out its own corner of the RAI Convention Center corner at booth S51! But the BrainGu crew isn’t only in Amsterdam to sample Hollandse Nieuwe and practice their Dutch -- they’re showcasing the ever-expanding capabilities of Structsure TM , BrainGu’s leading-edge internal developer platform (IDP).

One may wonder if then all computing is not edge because all functions inherently start at the user and move forward. The distinction occurs during the second part of the distinction, stated as processing data closer to generation to enable processing at higher speeds and leading to improved results in real-time. The actual edge difference might be better stated as the difference between where the data is collected and processed is significantly different than the location of the end-user of the data.

While visiting BrainGu at KubeCon + CloudNativeCon Europe, you can expect to:

Learn how BrainGu’s cloud-native technologies are building IDPs that apply DevSecOps principles to all levels of ANY company, regardless of size, industry, or regulatory roadblock.
Explore how (rs) 2 is helping BrainGu’s partners foster innovation and developer autonomy, all while improving platform stability and security.
Score some rad burrito stickers and other pieces of highly coveted BrainGu swag!
Terminate Kubernetes pods with extreme prejudice on BrainGu’s chaos-engineered two-player version of KubeDoom – now on Steam Deck and powered by Structsure® Edge.

BrainGu Co-Founder, John (Spence) Spencer, will be on hand to discuss how leading-edge platforms, like Structsure TM , must be resilient enough to support any product development effort, regardless of unexpected challenges, outages, and emerging threats. He’s also eager to share how BrainGu’s modular and extensible architecture adapts to the changing needs and requirements of any customer while also providing the necessary context and tooling to foster innovation through developer autonomy. He’s also keen for opportunities to practice his conversational Dutch.

If you want to find the heart of cloud-native innovation and ground-breaking ideas, you come to KubeCon. This is why we are thrilled to sponsor this year’s KubeCon + CloudNativeCon Europe. The BrainGu team is eager to connect and collaborate with the great minds working at the forefront of cloud-native computing and introduce them to our IDP, Structsure TM . We know KubeCon will be a chance to help even more developers and companies deliver (rs) 2 platforms – regardless of industry or barrier. - John Spencer, CEO & Co-Founder

Can’t make it to Amsterdam? Visit our KubeCon Europe Event Page for more information and video content.

View From The Edge

2023-04-13T00:00:00Z

Today, everyone wants to run to the edge, and hopefully not fall.

The buzzwords last year involved AI, ML, and some variation of combining various technical aspects. Today, the current push seeks to drive all developers to the edge. This article explores when stepping to the edge, what should be the primary considerations. Edge deployments provide increased freedom to develop for latency-sensitive applications, reduce cloud costs by offloading processing, and help reduce operational overhead. When a customer tells someone, they require development on the edge, with edge nodes, edge operations, and multiple other nouns associated with edge, one should ask the persistent question, what are the development and operations requirements on the edge?

This question leads into several good underlying thoughts, first,what makes operating at the edge different from the local environment. Next, how do I start in a safe manner and ensure my deployments are reliable and secure? Third, how do I integrate my existing operations to maintain stability, and finally, how do I get the right data back from the edge to guarantee my operations remain resilient. Examining each question will allow shaping the structure to effectively guide to resilient, scalable, repeatable and secure edge deployments. After all those questions, one should also consider the best platform to support multiple edge deployments as well as centralized management.

Edge computing appears as a paradigm where the range of networks and devices is characterized by proximity to the user.

That approach throws a couple of wrenches in the standard approach.

The first being that disconnection requires more capability for things to work independently at a distance. Using Kubernetes and containers helped reach this goal as these functions are intended to be distributed, immutable and ephemeral. Edge locations can be either a single difficult location or the thousands of locations often needed for business environments to manage daily functions. Traditional practices involved sending engineers to those sites regularly to guarantee operations but stacking centrally managed containers through the cloud can eliminate that expense. Rather than integrating an on-site engineer, edge operations can use central orchestration with containers at the edge as engineers rather than sending a person. Building multiple control planes for localized edge functions provide even more flexibility.

Each control plane can optimize for functions within their domain while remaining connected to the master plan with the immutable and known-good container set. As they functions constantly move out to the edge, the customer site maintains consistency while maintenance can be managed from that user location, distributed from the edge location. Each of these sites can be rebuilt, reloaded, or repaired from a distance rather than moving to engineers on site. The next challenge then becomes how to move data from those distributed locations to best conduct central management for the distributed edge.

One key to implementing edge technology occurs in processing data as close to the edge as possible and moving smaller data sets back to central management. Actions closer to the edge as opposed to a centralized remote data center help to reduce bandwidth and latency for various functions. A common example of edge processing could be selling through distributed stores when recording prices, inventories, and timesheets locally but aggregating data back to a central site to manage composite revenues, insurance payments, and money movement for the branches. Moving up from the initial example, one can envision edge processing to help with smart cities, military intelligence applications, autonomous vehicle fleets or any operations coordinated across a wide geography.

In many instances, raw data at the edge makes sense. In the store, one wants access to what aisle items are being purchased from, where they are stocked, and perhaps a customer membership that tracks purchases. Containers at the edge frequently look similar to central ones. Many of the functions remain the same but only the consolidated data returns to the center. As mentioned, edge containers help with low latency, load balancing, and scalability. Containers developed centrally can be launched simultaneously across multiple different edge nodes.

There are some negatives to using containers at the edge. Central management can be a key, but managing updates and deployment across multiple regions can increase complexity. At the initial stage, deployment must be carefully managed. Deploying to multiple edge locations can also increase the attack surface so security must always be a factor. Included in that security is that edge containers are going to require more network changes in both the edge location and back to central areas. One should include guarding those containers and providing tools to signal hostile intent within the edge networks.

Several ways to improve data at the edge include analyzing the right data, investigating data before storage, preparing models for response, and strengthening security. One way to make sure all these things are accomplished is to choose a platform. Edge computing frequently occurs as a way to use all different code and architectural applications before mashing the set together. While this can work, one should think about using a common platform. The platform from where one starts development provides the standard for moving forward. Implementing a Thinnest Viable Platform (TVP) mindset allows a thicker platform at central locations and the more appropriate tool where less processing is available. Correlating those platforms can be done through using a slightly thicker platform to enable more substantial development and test activities at the core while only allowing minimal test and development at the edge. Too many organizations try to shortcut by using one design architecture centrally, than expand into the Wild West for their edge solutions.

One suggestion for everyone seeking to maximize containers in managing edge deployments, use the same platform at every location. Multiple types of platforms exist but in edge computing, one should generally start with computing, utility, and data harvesting. For the refresher, a computing platform allows interactions between platform users and third party developers, a utility platform is generally a free service, and data harvesting offers a useful service that generates data. In the edge scenario, computing provides the initial development and deployment of cutting edge tools, utility provides the edge users an ability to do more with the nodes, and the data harvesting ensures information is processed and distributed. Some organizations use multiple platforms for each but the minimal processing available at the edge returns one to the TVP solution.

This becomes where the complexity at the center manages against the scalability on the edge. Consolidating multiple functions into a single platform allows analyzing one set of data at the center while consolidating and managing different data at the edge. The different data focus while using the same platform helps reduce complexity, improve reliability and function more effectively. A common platform also helps scaling containers developed at the center when deployed to multiple edge locations. Perhaps platform architecture should be the first step in developing at the edge but most customers prefer to start with the edge and move to center.

Overall, when building an edge architecture, one should start with a common platform and expand to multiple locations. This philosophy allows using containers to repeatedly and rapidly deploy to any geographic location while retaining centralized control. The second part of this architecture deals with which data should be processed at the edge, and which data then returns to the center. Managing data, and consolidating platforms creates the edge architecture, preferably using containers, that can then succeed at a wide scope of distributed tasks.

The Firsts Book of BrainGu

2023-04-03T00:00:00Z

Chances are you did a double take upon hearing it, and that experience is likely repeated whenever you tell your friends or family about both the work you do and where you do it.

It makes an impact. It leaves a mark.

And with that distinctive name comes an equally distinctive logo, presented in three parts:

Our Brain Explained

BrainGu's iconic logo depicts our identity as one that merges human ingenuity with new and established technologies to transform the way our customers accomplish their missions.

The logo consists of two different, yet connected halves.

The Right Half

This half of our brain logo symbolizes BrainGu's deep connection to the ever-evolving technology at the core of our company's mission.

The Left Half

This half represents the human-centric approach we take to develop solutions - software driven by creative engineers and designers, making our end-users lives easier.

The Drip of Gu

The Gu of BrainGu - this signifies the singular and lasting impact we have on all our customers, employoees, and partners.

But when you consider the logo as a whole, it says a lot about who BrainGu is and who we hope you’re becoming.

Across BrainGu, you’ll find experts and specialists from a myriad of fields. This legion of Gu, across seemingly disparate fields and specialties, all connect and work together seamlessly to deliver technology that is (rs)2: resilient, scalable, repeatable, and secure. A networked collective of individual neurons and synapses, all firing in unison, towards a common goal, not unlike…a brain!

And just as neurons in a brain work together to process information and make decisions, so do Gu collaborate to tackle complex challenges and drive BrainGu forward. As a collective, we constantly learn and adapt to new technologies and methodologies, just like a neural network continually updates and improves its connections.

And if the past decade has shown us anything, it's that those new, vital connections only form or function if cultivated within a culture of creativity, innovation, and collaboration.

But great company culture doesn’t happen by accident. We maintain that BrainGu’s culture is its greatest resource. The cerebrospinal fluid pumping through our positronic brain and a living, breathing thing must be actively defined and nourished. Without a clear definition and intentional effort to enrich it, a company’s culture can rapidly deteriorate, making way for a toxic environment where innovation and growth are stifled. At the same time, a positive, thriving culture can profoundly impact nearly every corner of a company, transforming it. We’ve seen and lived that transformation here at BrainGu, and we choose to defend it!

Our responsibility as Gu is to continuously invest energy and attention into shaping and strengthening our company culture. This requires ongoing communication, active listening, and a commitment to creating an inclusive, supportive, and challenging work environment where all employees feel valued and empowered to succeed. The power of a strong culture should never be underestimated, and we must remain vigilant in our efforts to cultivate and sustain it at BrainGu.

So, what do we want that culture to look like? BrainGu strives to cultivate a dynamic, adaptable, and always learning culture. Just like a neural network, our organization is constantly growing and evolving. You are the neurons that make up this network, and your diverse perspectives and experiences drive us forward. We believe in providing a supportive and inclusive environment where everyone is encouraged to share their ideas, take calculated risks, and continuously expand their skills and knowledge. As we continue to grow and expand, we remain dedicated to fostering a culture of growth, development, and collaboration.

Sure, that sounds great, but how do we support “a dynamic, adaptable, and always learning culture?”

We have to start somewhere, right? That's where our FIRSTS come in.

Think of these as the preamble to the BrainGu constitution, and these firsts empower all the other efforts and initiatives we drive at BrainGu. They’re the foundation that lets us be the BrainGu we want to be, the BrainGu we think you deserve.

First, but not only. In all things, balance results in the highest outcomes. Any value taken to the extreme or implemented overzealously can lead to undesired outcomes. Our firsts are as follows:

Trust First

At BrainGu, we understand that trust is not a given. It’s something that must be earned through consistent actions and behaviors. For Gu, this starts with transparency and respect. Transparency is key to earning the trust of our colleagues and customers. It means being open and honest about our intentions, decisions, and actions and allowing our teammates to participate in and understand our work. Participating in our colleagues' work means showing a genuine interest in their success and supporting them in their endeavors.

Respect, too, is critical to building trust and a positive work environment. We respect the opinions and perspectives of others and value the diversity of ideas and experiences they bring to the table. By treating all Gu with dignity and respect, we actively foster a culture of trust and collaboration where everyone feels valued and empowered to contribute their best work. By promoting transparency, respect, and a commitment to one another, we are building a foundation of trust that will drive BrainGu’s continued success.

Experimentation First

At BrainGu, we believe that embracing experimentation fosters a culture of innovation. A culture that encourages calculated risk-taking and drives advancement. By first prioritizing experimentation, BrainGu creates an environment where creativity and new ideas are celebrated, and failure is seen as a valuable learning opportunity. Our team members are empowered to try new things, challenge the status quo, and push the boundaries of what is possible – to challenge the impossible.

Experimentation is the pursuit of truth and gives us a pathway to improvement. It is as much about gaining the permission and resources to proceed as it is about blue sky ideation. In supporting our peers to innovate, all Gu approach new ideas in a spirit of "getting to yes," which emphasizes discussion and scoping of a controlled iteration upon which we can build. "No," "Impossible," and "Too Difficult," among other roadblocking language, are not in our vocabulary. "Yes, if" is the tool that opens new doors and gives our colleagues a clear insight into what it will take for clearance to proceed. It also puts an onus on us to think critically about our satisfaction criteria rather than letting our discomfort lead potentially great ideas to a dead end. Where two ideas would be better together, we use "Yes, and" to acknowledge our peers while adding our own layer of value to the collaboration.

Remote First

BrainGu's company culture values flexibility, trust, and collaboration, so we embrace remote work as an integral part of our working style. Where and when our employees work should not limit their ability to be productive and achieve their best work. We trust our employees to work independently and manage their own time, and we provide the tools and resources necessary to support this. By allowing remote work, we foster a diverse and inclusive environment accommodating different working styles and personal needs. We are committed to creating a supportive and flexible company culture that empowers our employees to work from anywhere and achieve their best work.

With this said, Gu as a community is not truly complete without shared in-person experiences. In each of our major geographies, we host Outposts, which are spaces where Gu can gather to share ideas and meals, and better know one another. We believe in regularly fostering opportunities to see our colleagues in the real world creates a connection that cannot be achieved from behind a screen.

Conscientious Participation First

At BrainGu, we believe in the power of active participation to effect change. Rather than relying on protest alone, we believe that a combination of awareness, inventory of those affected, and a well-planned action strategy is the surest path to meaningful change. Just as a bug in a line of code cannot be fixed by simply observing and commenting on it, we must take direct and intentional action to address the issues we wish to change.

BrainGu was founded to enable and empower change from within historically slow-moving and highly regulated institutions. This same approach should be applied within our own ecosystem. Our greatest strength lies in our members' willingness to be present, engaged, and vocal within the areas they wish to see change, speaking truth to power, advocating for their positions, and holding everyone accountable.

As leaders, we understand that it is not enough to talk about change; we must be willing to take action in both our micro and macrocosmic environments. We must also be open to listening to our customers and our own teams and objectively address the problems they bring to our attention. At BrainGu, we strive to create a culture of proactive participation and impactful change driven by our commitment to improving the world.

And those Firsts have since evolved into our Cultural Pillars.

Execution

At BrainGu, we understand that great ideas are only as valuable as their execution. Our company culture values the ability to turn plans into action and bring concepts to life. We believe in setting clear goals, creating plans, and executing them with discipline and determination. We encourage taking calculated risks and learning from both success and failure. We recognize that execution is critical to delivering results and achieving our objectives, and we are committed to building a culture that values and rewards it.

Small Teams, Big Impact

BrainGu believes in the power of small, agile teams to tackle big challenges and drive meaningful progress. Small teams allow for more collaboration, creativity, and focused execution. We value open communication, teamwork, and a willingness to experiment and take risks to succeed. By fostering a close-knit and supportive team environment, we can adapt quickly to change, prioritize the most impactful initiatives, and make fast and informed decisions. By empowering small teams, we can solve big challenges and drive meaningful progress together.

Collective Power vs. Individual Success

BrainGu values the power of the collective over individual accomplishments. Coming together as a team and supporting each other leads to greater success and a more fulfilling workplace. While individual contributions are important and recognized, we prioritize collaboration and communication to achieve our common goals. We strive to create a supportive and inclusive environment where everyone feels valued and heard and where everyone's unique strengths can be leveraged for the benefit of the whole.

Diplomacy

BrainGu recognizes the importance of diplomacy in all aspects of our work. Approaching challenges and conflicts with tact, empathy, and a solution-focused mindset leads to better outcomes for everyone involved. Whether working with colleagues, clients, or partners, we prioritize clear and respectful communication, active listening, and a willingness to compromise. By fostering a culture of diplomacy, we aim to create a harmonious and productive workplace where everyone feels heard and valued.

Community and Citizenship

BrainGu values building a strong community inside and outside our organization (The Shell) and fostering a supportive and inclusive environment where every member feels like they belong and can make a positive impact. Beyond our workplace, we also recognize the importance of being good citizens in the wider community. Whether through volunteer work, charitable giving, or sustainable business practices, we strive to make a positive difference in the world. By building a sense of community and acting as responsible citizens, we aim to create a fulfilling and meaningful workplace for all.

Challenge the Impossible

BrainGu’s DNA is built around the idea that any progress made against an impossible challenge is meaningful. We embrace the challenge and thrill of working towards solving seemingly impossible problems. We believe that pushing beyond boundaries and finding innovative solutions to complex challenges drives progress and makes our work meaningful. Gu are encouraged to take risks and embrace failure as a learning opportunity. The greatest fulfillment comes from tackling complex problems and seeing our solutions make a real-world impact. By embracing the challenge of solving impossible problems, we aim to create a workplace where everyone is inspired, motivated, and fulfilled.

Make a Dent

BrainGu believes in the importance of positively impacting humanity and the universe. We are driven by a greater purpose and strive to create solutions that benefit not just ourselves but the world around us. Whether through developing innovative technologies, advancing scientific research, or creating more sustainable business practices, we aim to make a lasting impact that improves lives. We recognize that our work has the potential to shape the future and believe that it is our responsibility to use it for the greater good. We aim to create a fulfilling and meaningful workplace for all by focusing on making a difference in the world.

As Gu, how do you impact BrainGu’s culture to ensure its continued growth?

Focus on Community

“Community” can mean different things, depending on the context. The scope can be as narrow as your project team or as wide as the world around you. Gu dedicate the time, abilities, and resources needed to focus on their chosen communities, changing them for the better through intention and execution.

But what can one Gu do? A lot, actually, but a collective of mission-focused Gu can change the world. Start with checking in on a teammate, or join one of the many Special Interest Groups(SIG) at BrainGu, or volunteer to help a cause you care about.

Change the Box

You can do things the way they’ve always been done. You can try to implement change for the sake of it. Or, you can take a more measured approach. The adage “think outside the box” assumes that all previous attempts at solving a problem that weren’t 100% successful are useless and that wholesale change is the only answer.

At BrainGu, we believe that every bit of progress toward a solution is valuable. Our approach is to thoroughly evaluate the situation, identify its strengths and weaknesses, and then optimize those strengths to create a path forward. We don’t believe in abandoning what has been done before but rather in using it as a starting point to create a better solution. By leveraging the current approach's strengths, we can create a more effective, innovative solution to build on for a greater positive impact.

Live with Passion

All Gu deserve to be their whole selves at all times. We try to hire passionate people and understand that passionate people are driven by their love for what they do and have a natural inclination to face challenges head-on. Their work represents something meaningful and impactful, both personally and professionally.

We believe that separating work from life limits our potential for growth and self-expression. That's why we strive to create an environment that fosters self-actualization and encourages creativity and talent. By embracing the whole person, we enable each individual to bring their unique skills, passions, and perspectives to the workplace, creating a dynamic and inclusive culture.

BrainGu Wins $15 Million US Air Force Contract

2022-11-29T00:00:00Z

PRESS RELEASE: November 29, 2022

Grand Rapids, MI (November 29, 2022) - BrainGu, a software development company focused on empowering innovation and rapid software prototyping for customers in highly regulated industries, announced today that it has been awarded a $15 million contract by the US Air Force's Strategic Funding Increase (STRATFI) program. The $15 million contract was awarded through AFWERX, the Air Force's innovation hub, as part of USAF efforts to accelerate the development of mission-critical technology with the assistance of highly innovative companies like BrainGu.

The STRATFI contract awarded to BrainGu signals the Air Force's commitment to invest in the future of BrainGu and our Structsure products. Together we will further the mission of empowering operators to get directly involved in the development of software tools that benefit them and support their mission. The demand for integrated software solutions that enable or enhance Air Force operational and business systems has never been greater. At BrainGu, we are committed to supporting our warfighters with our DevSecOps platform, Structsure. With Structsure, we are creating a sustainable common environment that enables operator-driven mission application development from concept to combat. - Tim Gast, VP BrainGu Labs

AF Ventures opportunities have given BrainGu an on-ramp to bring software and unique capabilities to the DoD and engage with stakeholders across the DoD to optimize the DevSecOps Platform to support the DoD operational environment. STRATFI funding will accelerate BrainGu's custom platform development efforts in support of the US Air Force's strategic mission, as well as other key mission partners across the US Department of Defense - including the US Navy and Army. With Structsure, BrainGu continues to bring modern, DevSecOps approaches to support high-quality software delivery to military and intelligence missions.

BrainGu Named NVTC Tech 100 Honoree

2022-11-16T00:00:00Z

PRESS RELEASE: November 16, 2022

Mclean, Va. (November 15, 2022) - BrainGu, a software company specializing in delivering DevSecOps Platforms to customers in highly regulated markets such as healthcare, fintech, federal civilian, and the defense sector, is humbled to announce that we’re being recognized by the Northern Virginia Technology Council (NVTC) as a 2022 NVTC Tech 100 honoree. The NVTC Tech 100 list honors the top innovative companies and leaders in the region’s technology community. This awards program highlights the cutting-edge companies, executives, and NextGen leaders who are driving innovation, implementing new solutions for their customers, and contributing to the region’s economic growth.

2022 has been a year of tremendous growth for our region’s technology hub, thanks to the dynamic companies and individuals who are innovating and making a positive impact in the world. Their contributions are the reason our region is one of the nation’s most vibrant and collaborative technology communities. NVTC congratulates BrainGu for going above and beyond within their company and in their respective industries. - Jennifer Taylor, President & CEO of NVTC

2022 has been a banner year for BrainGu; we have experienced a 28% growth in employee count and 35% growth in revenue, including a $15 MM STRATFI Award to support the commercialization of our proprietary DevSecOps Platform, Structsure.

I’m extremely honored and excited that BrainGu is being recognized by NVTC this year on their Tech 100 list! It's a privilege to be recognized for the impact that we're making through bringing platform thinking and technology to our growing customer base. This is yet another reflection of the amazing team of Guvians we're building to blend the best of the Silicon Valley startup mindset and the Northern Virginia mission ethos. - John Spencer, CEO & Co-Founder of BrainGu.

BrainGu Welcomes New Director of Events Marketing to Its Revenue Operations Team

2022-11-01T00:00:00Z

PRESS RELEASE: November 1, 2022

WASHINGTON D.C., November 1, 2022 - BrainGu, a software development company focused on empowering innovation and rapid prototyping for customers in highly regulated industries welcomes strategic hire Jenny Martin (Coppedge) as the company's new Director of Events Marketing.

Martin has planned and executed hundreds of events ranging from conferences and symposiums, trade shows, televised productions, political forums, and special events. She has also led high-profile events involving political dignitaries such as President Obama and U.S. Senators, C-level executives the likes of Steve Case and David Rubenstein, and television personalities such as Hoda Kotb, Chuck Todd, and Chris Matthews.

For me, the main appeal of joining BrainGu was its unique positioning in the DevSecOps and secure software space. I look forward to helping evangelize our mission and capabilities as BrainGu enters its next exciting chapter. - Jenny Martin, Director of Events Marketing

Martin founded Heritage Event Management in 2014 serving corporation, association, and non-profit clients in the Washington, D.C. metro area. Prior to founding Heritage, she served as Vice President of Events and New Initiatives for the Northern Virginia Chamber of Commerce. Under her charge, the events department organized and executed over 80 events annually with an accompanying 10,000 attendees per year.

Having known Jenny for years both at The Chamber and at Heritage, I've had the privilege of witnessing her talents and excellent work first-hand. We're thrilled and fortunate to make a strategic hire such as Jenny, and I have no doubt she will help take BrainGu to the next level. - Carl Rosenblatt, VP of Revenue Operations, BrainGu.

Martin is a graduate of James Madison University and holds a Certified Meeting Professional (CMP) designation.

BrainGu Founder Named as Washington Exec Pinnacle Award Finalist

2022-10-25T00:00:00Z

PRESS RELEASE: October 25, 2022

BrainGu Founder and Engineering Fellow, Matt Shaver, has been named a finalist for Washington Exec's Pinnacle Awards in the Cloud Executive of the Year (Private Company) category.

WASHINGTON, October 25, 2022 - BrainGu Founder and Engineering Fellow, Matt Shaver, has been named a finalist for Washington Exec's Pinnacle Awards in the Cloud Executive of the Year (Private Company) category. The Pinnacle Awards recognize mission-focused industry executives and government officials working to put the technological needs of the nation first, while fostering innovation for federal clients across the Capitol region. Shaver is one of only three finalists nominated in the Cloud Executive of the Year category.

Increasingly, teams are realizing how important high-quality software is in deploying products that benefit the end user. We're seeing intense demand for better tooling, reduced downtime, and improved time-to-market, and we've engineered our DevSecOps platform, Structsure, to deliver that, and so much more for our customers. BrainGu is committed to working through key partners to reach software development teams in organizations of all shapes and sizes. - John Spencer, CEO & Co-Founder

At the heart of its explosive growth is BrainGu's mission to empower software development teams that are traditionally constrained by complex regulatory requirements, regardless of size or industry. With the introduction of their secure software development environment, Structsure, customers are leveraging BrainGu's DevSecOps platform to accelerate software development and delivery like never before.

It is an honor to be named a Pinnacle Award Finalist by WashingtonExec. BrainGu's work applying cloud-based solutions to pressing national security challenges is as rewarding as it is challenging. Our development of WIDOW, a cloud-based distributed planning application for the DoD, continues to demonstrate the power of DevSecOps methodologies in positively shaping experiences and outcomes for our nation's warfighters. BrainGu is honored that the federal government continues to turn to BrainGu for an innovative approach to new and existing missions, and I'm especially grateful to my colleagues for their efforts to make each of those unique and challenging missions a success. - Matt Shaver, Founder & Engineering Fellow

BrainGu Appears on Inc. 5000 List for Second Straight Year

2022-08-29T00:00:00Z

PRESS RELEASE: August 29, 2022

BrainGu Appears on the Inc. 5000 With Three-Year Revenue Growth of 460% Percent.

For the second year, BrainGu ranks among the top 1% of privately held companies in the nation at No. 1,398.

GRAND RAPIDS, Mich., August 29, 2022 - BrainGu, a software development company focused on empowering innovation and rapid prototyping for customers in highly regulated industries, such as healthcare, finance, defense and intelligence, aerospace, hospitality, retail, and critical infrastructure, today announced it was again selected for the Inc. 5000, a list of the fastest-growing private companies in America, with a ranking of 1,398. This is BrainGu's second year on this nationally recognized ranking of the top 1% of privately held companies in the nation.

Increasingly, teams are realizing how important high-quality software is in deploying products that benefit the end user. We're seeing intense demand for better tooling, reduced downtime, and improved time-to-market, and we've engineered our DevSecOps platform, Structsure, to deliver that, and so much more for our customers. BrainGu is committed to working through key partners to reach software development teams in organizations of all shapes and sizes. - John Spencer, CEO & Co-Founder

The accomplishment of building one of the fastest-growing companies in the U.S., in light of recent economic roadblocks, cannot be overstated. Inc. is thrilled to honor the companies that have established themselves through innovation, hard work, and rising to the challenges of today. - Scott Omelianuk, editor-in-chief of Inc..

React Rendering for Rapidly Changing UIs

2022-05-26T00:00:00Z

React developers are very familiar with the typical method of updating the UI; update state either via props or internal component state, and React takes care of updating the UI based on that state update. This declarative tech works well and is the standard in post-React frontend frameworks. This article presents situations where imperative programming can be used to improve performance when updating multiple UI components.

Background

There are a couple of downsides to standard methods for React UI updates. First, rendering a component is computationally expensive. When a component's state is updated (via useState or a prop change), React goes through a process called “Reconciliation” to determine the updated UI. Avoiding unnecessary Reconciliation is a standard optimization technique that avoids unnecessary renders and keeps applications snappy.

However, some applications seem to require constant rendering. For example, a dashboard consisting of UI components displaying constantly updating data could be built on a foundation of periodic and almost constant state change based on data updates. This is a perfectly valid technique that may be adequate for the task. On the other hand, another technique is commonly used in game design and works just as well in React.

Game Loops and the React UI

Imagine an application where the state can change almost arbitrarily. It doesn’t matter what is changing the state, what does matter is that any change can happen at almost any time. Additionally, the UI shown to the user must update continuously and as smoothly as possible. This situation is similar to what happens in most video games. The player(s), AI, etc change the state of the game constantly and the game environment (aka the UI) continuously updates based on the UI using a game loop. The following image from gameprogrammingpatterns.com shows a simple game loop.

A simple game loop (https://gameprogrammingpatterns.com/game-loop)

First, avoid render-inducing state changes as much as possible by minimizing changes to props and useState variables. Fortunately, React provides the useRef to maintain and update the component's state without causing a component to render. Note, that this does not mean useState and changing props can’t be used, just be aware of any potential consequences that will come from the extra component rendering.
Another requirement is a way to update the UI periodically. JavaScript’s requestAnimationFrame exists for exactly that purpose. requestAnimationFrame attempts to run a callback function at 60 times per second. This value can vary depending on the speed of the computer, but the function also provides the information needed to throttle the callback frequency. In React, requestAnimationFrame functionality can be added via a custom hook.
Finally, the element that we want to alter needs to have a way of imperatively altering its state.

Now, let’s modify the “game” loop to be more React-specific and discuss what can be done in each step.

A simple UI loop

	Process Input	Doing work to retrieve and or update state can be done here. This includes calling APIs, receiving keyboard events, querying and updating a global store such as Redux using the `getState` and `useDispatch` functions, etc. The received input can then be processed so that it is eventually saved to state. On the other hand it may be saved to state directly.
	Update State	It is possible that this will be done as part of the Process Input step; after-all the results of an API call may be directly saved to state. However, that’s not always the case. An example of updating state would be changing values created using a `useRef` hook or updating global state. A global state manager such as Redux could be updated here
	Render UI	At this point, we do what is required to render the UI. How this is done will depend on the item being rendered, and a couple of different techniques are described in the next section. Additionally, this step may require accessing values created using `useRef` or pulling values from a global store using a “vanilla JS” method if it’s available. For example, in Redux the `getState` function could be used to imperatively get data from a store in a way that does not cause the component to update.

Implementation

There are several ways to implement the UI loop. One method is to update a component state variable (one created with useState instead of useRef) triggering the component to render. The frequency of the update can be controlled using requestAnimationFrame. The rendered component displays content based on the state held in any number of variables created with useRef. Doing this creates a component that will render at a specified interval and displays a UI based on what is contained in any number of useRef variables instead of rendering whenever each of any number of typically useState created variables (or passed props) changes.

Another way that may be available if the UI element that needs to be updated supports it is to update the element directly. For example, updating data displayed in an ApexCharts chart by using the exec function. The imperative exec function could be called via a custom hook that wraps requestAnimationFrame. This results in a chart that periodically updates data without rendering the entire component.

This technique is also frequently used to animate 2D and 3D animations and is frequently demonstrated when working with three.js and the react-three-fiber library which “Reactify”s three.js and includes a useFrame hook to encapsulate requestAnimationFrame. First, note that coding in three.js is imperative; if an object should change rotation or position, we mutate a rotation or position value as seen in the code for this example. Since react-three-fiber wraps three.js inside a React “shell” it could be assumed that the correct way to update components would just be to update the component's state. However, the react-three-fiber recommends against doing that for performance reasons.

Conclusion

Most React developers are familiar and comfortable with the fact that changes to state and prop trigger component renders. However, sometimes, this is not the only way to update the UI. Furthermore, in some cases, it’s not the best or only way to update the UI. JavaScript’s requestAnimationFrame and React-specific derivatives provide an alternative that can be worth trying.

Scaling Design Systems

2022-04-26T00:00:00Z

At BrainGu, we incubate web applications that meet operators’ needs and the secure infrastructure they run on. To mediate design and development, each of our applications has its own design system.

A set of standards to manage design at scale by reducing redundancy while creating a shared language and visual consistency across different pages and channels. - Nielsen Norman

In parallel, we are building a platform to increase the speed at which we incubate apps, and a platform-wide design system is central to that evolution. While many companies have one design system platform-wide, and agencies often deliver a one-shot design system as part of their client handoff, BrainGu is in a unique position in that we need both to accelerate individual app development and scale frontend development across the company so we can incubate more apps and impact more operators. In other words, BrainGu needs a system of design systems.

What does a system of design systems look like in practice?

First, we need the right tools and processes. Enter Storybook and Chromatic. Storybook is a tool to develop, test, and document design systems and component libraries. It allows us to prototype live presentational code, putting it right at the intersection of design and development. Implementing Storybook within each of BrainGu’s applications will give the design and development teams the sandbox they need to prototype components and make changes quickly.

Once a component is prototyped in Storybook, how will developers know when a component is ready for development on the behavioral side?

That’s where Chromatic comes in. Chromatic is built on top of Storybook, and it effectively serves as visual source control for UI components. Whenever code is pushed to a repo with Storybook and Chromatic built-in, Chromatic will run visual tests to see how the design system differs. Any changes are flagged so stakeholders can provide feedback and sign-off before merging those changes. This way, we can minimize back and forth by knowing when a component is ready for further development.

For example, when a new component design needs to be translated into code, a developer will create a new branch in that app, prototype live presentational code in Storybook, push that new branch, and open a PR. That PR will create a Chromatic UI review check so designers and other stakeholders can provide feedback and sign-off. After sign-off, that presentational code will be merged into the main branch for developers to begin building out the behavioral code for that component. Building applications component-by-component using Storybook and Chromatic is how we maintain elegant design systems within each application, ensure visual consistency, and accelerate both designer and developer velocity.

The BrainGu-wide design system, aka mission-components, is intended to be our quiver of components and features that any current and future application can pull from. It will also be the single source-of-truth for Material UI themes. Material UI is the set of components BrainGu has adapted to take care of basic UI elements like buttons, freeing us up to build more complex components. One powerful feature of Material UI is theming which allows us to customize the look and feel of the entire suite of Material UI components. The currency for that theming is the theme file. We can customize everything from color palettes to hover behavior – any CSS selector. By building out the necessary UI states in Storybook, we can quickly prototype new theme files in Storybook, test those changes in Chromatic, and publish them for any BrainGu application to use. This same workflow applies to components and features incubated in a BrainGu application that could be reused across our entire platform. As individual components within an application are developed using Storybook and Chromatic, those components that the team deems to be reusable can be easily extracted into mission-components for any application to use in the future.

This is the flywheel by which BrainGu scales frontend development: develop components as needed within each application’s design system, and when reusable, pull those components into the BrainGu-wide design system, thus making it faster for future apps to get up and running.

A major consumer of this BrainGu-wide design system will be our frontend app generator, mission-nextjs. When we need to incubate a new application, we will use mission-nextjs which will always have the most up-to-date version of mission-components as well as Storybook and Chromatic. Components will be developed in that new app cloned from mission-nextjs, and when new components are deemed reusable, the mission-components team will work with that development team to extract that component into mission-components for future re-use in new applications through mission-nextjs.

While the primary benefactor of this approach is each new application BrainGu incubates, existing apps can also take advantage of mission-components. Any BrainGu app can import mission-components, and if they build out platform-wide reusable components they can work with the mission-components team to lift that component up for future re-use. Individual apps are free to use whichever version of mission-components suits their needs, and like any package, there may be breaking changes. The mission-components team is dedicated to providing long-term support and communicating changes coming to future versions so developers can prepare before upgrading.

And while this effort is itself a prototype, after initial success with using Storybook and Chromatic to create a custom theme file and set up our initial shelf (mission-components) and frontend app template (mission-nextjs), we’re ready to start rolling out Storybook and Chromatic within our future applications to further accelerate the design-to-code process and bring added value to operators.

Brands We Stan New Holland Brewery

2022-03-21T00:00:00Z

New Holland Brewing Company is a local West Michigan brewery and distillery that we at BrainGu absolutely love.

Whether it's their great craft beers, delicious food, or excellent service, New Holland is a favorite of both local and visiting Guvians. But the reason we truly stan New Holland is because of their bourbon.

The BrainGu x Bourbon Tradition

Every holiday we send our employees gift boxes, thanks to the tireless efforts of Facility & Security Manager, April Johnson. One gift that has gotten the best reviews the last few years is the selected bourbon of the year, courtesy of New Holland Brewing Co. New Holland provided a private tasting for BrainGu’s founders. In 2020 we purchased our first barrel of Beer Barrel Bourbon [https://www.newhollandbrew.com/spirits/#beer-barrel-bourbon/]. A unique, first-of-its-kind bourbon. Beer Barrel Bourbon is aged in new American oak barrels before finishing in our legendary Dragon’s Milk barrels. The Dragon’s Milk barrels provide a softer, more rounded flavor with notes of vanilla and smooth dark malts.

This past year, the Founders also invited three other individuals who exemplify our core values, to the private tasting at New Holland, and we once again decided to go with the Beer Barrel Bourbon. We’ve doubled in size since December of 2020, so this was the first opportunity for about half the company to experience New Holland’s bourbon [disclaimer: participating in receiving the bourbon is optional, and limited to those employees over 21 years of age].

Change the Box - Rachel O'Donnell

Rachel came into BrainGu and has demonstrated a fantastic ability to assess a situation and maximize the resources available to achieve results. She builds on the knowledge of those around her to improve what is in place if possible, and is never afraid to start from scratch. Rachel brings a unique perspective to the BrainGu ecosystem and adapts BrainGu’s boxes’ to improve the company and our results.

Live with Passion - Tim Gast

Tim is a prime examplar of the Live with Passion value. His high quality delivery is on the front lines of BrainGu’s growth. His passion is apparent in his BrainGu work, and his homelife. Finding the balance and methods to incorporate his enthusiasm for learning and technology between his work and personal life is beneficial to all of those around him.

Focus on Community - Aaron Marco

Aaron is exemplary for focusing on community. He helped with the BrainBudget ADR, and demonstrated daily a firm belief in the BrainGU strategy and approach. He continuously reaches out and pushes others to better themselves, both inside the shell or outside.

Custom Logo

About New Holland Brewing Co.

It all started for us in 1997 when Brett VanderKamp believed that his hometown and the brewing industry were due for a shakeup. And so, New Holland Brewing Company was born in Holland, Michigan near the shores of Lake Michigan.

Today, New Holland is recognized as one of the leading innovators in the revolution of craft brewing and distilling. With nearly 500 team members, New Holland’s craft beer and spirits are sold across the country, and around the globe. Our retail presence continues to grow with two full-service restaurants, a spirits tasting room, two brick-and-mortar stores, and an online store.

New Holland Spirits

At the heart of our distillery is a story of rebirth, restoration, and exploration. Using an old prohibition-era pot still and our knowledge of brewing, we began exploring the flavors and complexities of spirits in 2005. From then onwards, we have been on a mission to create unique spirits made with care and expertise, from the grain to your glass.

BrainGu's Remote First Workplace Philosophy - Distributed Talent Network

2022-03-01T00:00:00Z

We pair on-site, cleared staff who serve as integrators, and provide technical leadership to off-site staff. Unlike some companies, ‘off-site’ does not mean ‘off-shore’. All BrainGu employees are U.S. based, and U.S. citizens. These off-site staff serve as the workhorse development groups being remote-first.

What does this mean for our customers?

Government customers require the capability to scale agile solutions to meet their growing cyber threats, intelligence analysis, and knowledge management concerns. Traditionally, this has been limited to: hiring on-site, cleared personnel to satisfy tool development and integration needs. However, the federal government’s continually growing need for qualified, cleared talent concentrated in the metro DC area has outstripped the market’s ability to provide staff with the requisite skill and experience. This has led to operationally unacceptable wait times, costs, and lackluster performance.

Enter, BrainGu. To alleviate this issue we paired on-site technical leadership with off-site development groups in order to realize the potential of a larger talent pool without sacrificing the cohesion provided by on-site staff familiar with the needs of the mission. Benefits of this approach include reduced lead time on qualified staffing and potential cost savings. We help our customers tap into the benefits of a broader, technically diverse talent pool and develop advanced solutions to address complex problems.

What does this mean for our employees?

It means a lot of different things for a lot of different people.

Job Creation

As a small business with its roots in Grand Rapids, MI without a remote-first approach our ability to impact the job market would’ve been limited to our wonderful city. We also would be limited in reaching customers. However, by being remote-first, our community can be nationwide as we hire from and create jobs across the entire United States. We have the freedom to operate out of an untapped tech hub here in Grand Rapids, MI while still treating the entire United States as our community. Meaning, new hires don’t have to move and leave the comforts of wherever they call home just to come work with us.

Job Flexibility

Long before the pandemic, BrainGu saw the benefits of providing our employees with job flexibility. We’ve had the technology, and resources to collaborate with our customers, and co-workers, no matter where they live or in which timezone. So why should we limit ourselves to a small geographic area to pool talent from?

Employees are welcome to work wherever they prefer. This could be in one of our collaborative WeWork locations, our building in Grand Rapids, their homes, a favorite coffee shop, or the beach. We value our employees feeling comfortable and safe.

Personal Flexibility

One of the great benefits of remote work is it becomes far easier to achieve a work-life balance. We understand that you need to make lunch for your kids, run a quick errand, or go to a doctor's appointment, and you shouldn’t have to take PTO to do any of those things. PTO is for vacation, not because you need to go to your annual physical. Our remote-first philosophy removes the added stress of trying to manage all of your personal life appointments after hours only.

Cos DiMaggio New President of BrainGu

2022-02-15T00:00:00Z

PRESS RELEASE: February 15, 2022

WASHINGTON D.C. – BrainGu, a DevSecOps innovation lab currently focused on delivering secure platforms and mission-critical software to highly regulated industries, announced this week that Cos DiMaggio has been appointed to the position of President. Past President and company founder John Spencer will retain the position of Chief Executive Officer.

Cos has provided a massive lift to the BrainGu leadership team for the last year and a half in an advisory capacity. His experience leading highly technical organizations in the defense innovation space will prove invaluable as BrainGu continues to navigate this period of hypergrowth. The innovative software we originate at BrainGu is at the heart of that growth, and moving forward its development and successful deployment will be job number one. As President, Cos will help ensure that BrainGu continues to grow and scale responsibly. A key goal will be to shift focus to a partner channel-driven sales strategy, driving the value of our technology through key relationships with new and existing partners to expose BrainGu to wider audiences. - John Spencer, CEO & Co-Founder

Cos is an expert in organizational development and transformation. He has established and led private-sector and nonprofit organizations for close to 35 years. Prior to joining BrainGu, he was a co-founder and CEO of The Tauri Group, and led national security teams at DynCorp, Futron, System Planning Corporation, and SRA, providing analytical and advisory support to arms control, intelligence, emergency preparedness, and missile defense programs. This experience will prove essential as BrainGu continues to expand its partner reach by marketing its comprehensive suite of data security platforms to new channel partners currently struggling to meet stringent and evolving security requirements.

After advising the leadership team for over a year, I could feel the excitement surrounding BrainGu’s novel approach to cyber-secure software solutions, and I wanted to play a bigger role in bringing those products to market. The expertise and expediency driving their high-touch services have placed BrainGu on the verge of explosive growth and I look forward to helping the company navigate those challenges. - Cos DiMaggio, President of BrainGu.

Leadership Manifesto Part 2 To be a true leader, you need to communicate

2022-02-01T00:00:00Z

Communication

Humans, and by extension businesses, are not rational. Human relationships are about feeling safe. That is why communication and empathy are critical to a leader’s success.

Listening

Effective communication starts with active listening. Modern American conversation patterns often have people formulating their response or next statement while the other party is talking. This gives the perception that conversation is moving quickly and minimizes the “downtime” in a conversation to give us control over the conversation. Listening, true listening with the genuine intent to understand, is the key to controlling a conversation and driving to a successful outcome. When you listen, you come to know twice as much as the other party in the conversation; you know what you already know, plus you know what the other person knows as well.

Time

Human beings put a premium on time, whether subconsciously or consciously because it is an equal and non-redeemable commodity. For instance, if you spend money, you can make more money, but if you spend time, you’ll never get it back. Because of this, a leader’s time is one of the most essential relational tools in your inventory. However, leaders are often getting pulled in a dozen different directions at once, which makes the time expenditure of the leader in an intentional and focused manner all the more significant.

When thinking about communication, there are two extreme ends of the spectrum: Rational and Emotional.

Credit: Tim Gast, based on the works of Simon Sinek

Rational communication tends to be transactional and driven by logic. An example of rational communication would be: “If X is true, then Y is also true, and therefore Z is false.” Most business communication tends to take place near the rational end of the spectrum. At this end of the spectrum, communication is much more analytical, and personal empathy is low.

Emotional communication is the far opposite end of the spectrum. This type of communication is not driven by logic but by emotions, feelings, and perceptions. In times of crisis, emotions rise, and people naturally swing towards the emotional end of the spectrum. When operating on this end of the spectrum, listening and empathy are crucial.

Emotional Intelligence

The capacity to be aware of, control, and express one's emotions and handle interpersonal relationships judiciously and empathetically.

As a leader, you need to be introspective and aware of where you are on the emotional spectrum. You must exercise emotional intelligence to know where other parties are on the emotional spectrum and engage them appropriately. Often we have the perception that when engaging with highly emotional people, you should take as much emotion out of the interaction as possible, when in fact, the opposite is true. If you take emotion out of your responses, that causes you to appear cold and uninterested, further escalating the other person. When you are engaged in a highly emotional interaction, you should mirror some of that emotion, albeit at a slightly lower level, to cause a natural de-escalation of the situation.

When mirroring emotion, it is critical that you don’t direct it back at the other person; that will cause a fight and escalate tensions.

Practically, when working with others in your organization, you should continue the continuum of rationality in parallel with the emotional spectrum when communicating.

Credit: Tim Gast, based on the works of Simon Sinek

Example: An email is a rational tool. Don’t answer emotional questions through rational tools. Pick up the phone, jump on a VC, or walk over if possible and speak in person.

Regardless of the tool used, effective and direct communication must be

Clear — the intent of your message needs to be clear and easily understood.
Concise — use the minimum words necessary for a clear message.
Accurate — leaders must maintain ultimate integrity.
Confident — the message should be strong. The leader must be communicating from a place of belief in the message.

Leading up and down the chain of command

One of the most important jobs of any leader is to support your boss. Leadership must always present a united front to the employees. A public display of discontent or disagreement with the chain of command undermines the authority of leaders at all levels. This is catastrophic to the performance of any organization.

As a leader, if you don’t understand why decisions are being made, requests denied, or support allocated elsewhere, you must ask those questions up the chain. Then, once understood, you can pass that understanding down to your team. Leaders in any chain of command will not always agree. But at the end of the day, once the debate on a particular course of action is over and the boss has made a decision — even if that decision is one you argued against — you must execute the plan as if it were your own.

The major factors to be aware of when leading up and down the chain of command are these:

Take responsibility for leading everyone in your world, subordinates and superiors alike.
If someone isn’t doing what you want or need them to do, look in the mirror first and determine what you can do to enable this better.
Don’t ask your leader what you should do: tell them what you are going to do.

How do you win with people you don't like?

When you lead within an organization, you will inevitably have to work with people you simply don’t like. It is crucial to building (productive) relationships with people so that you can have more influence across your team, organization, and company.

There are a couple of practical things to keep in mind when you’re interacting with people you don’t like

Don’t be a jerk; you’ll make things worse.
Don’t undermine; carry yourself with humility. Try and build a relationship instead of being antagonistic.
Most of the time, when you “don’t like” someone, it’s because your ego is getting in the way.

To quickly check your ego, ask yourself, “If I am so smart, why am I not winning?” If you are answering that question honestly, you will put your ego in check.
Ask yourself, “Is this going to help the relationship or hurt it?”

What about dealing with people that lack common sense?

Common sense is the blanket term we use that covers a person’s natural ability to make good decisions.

To help improve someone’s decision making, you need to teach them how to

Step back and detach. You cannot understand a complex and dynamic landscape when you are deep in the weeds and focusing on the ground level.
Analyze and determine courses of action and understand the consequences of action (including second and third-order effects). Nobody wants to make bad decisions on purpose. However, when poor decision-making is observed, it usually stems from a reasonable decision being made on the ground without understanding or considering the downstream effects.
Mitigate risk. Understand your assets and resources and where they can be applied to minimize the threat surface and unintended downstream effects.

Good decision-making isn’t something that can be learned through reading or observation alone. It is developed through doing. Therefore, if you have someone that doesn’t seem to exhibit a lot of common sense, the best thing you can do is to put them in charge of something that is just outside of their competency. As you give these people a little bit of space to make decisions, you need to gently correct their mistakes and help them understand the decision-making process rather than smacking them for making a wrong decision.

Some behavioral patterns of a leader

The phrase “not my job” doesn’t exist in our vocabulary.
We individually accept responsibility for outcomes, both successful and unsuccessful.
When things go wrong, the only place we look to point the finger is at ourselves, individually.

Perfection

There is no such thing as perfection. It’s a lesson all elite organizations understand. Perfect execution cannot be achieved. Instead of searching for it, they define perfection as finding and fixing every mistake. Perfection is setting your ego aside and explaining to your team what you did wrong. Perfection is building a culture where your team is willing to expose every error, even those that could be hidden or ignored. Perfection is creating a team that competes over whose fault it is when a project fails or when goals aren’t reached.

It’s time to redefine perfection. Perfection is about mistakes. You must teach your mistakes to others, so they learn them in the classroom, the boardroom, and the debrief. You must teach your mistakes to others, so they don’t make them in combat, on a sales call, during a negotiation, or when fighting a fire, running a business, or leading a team.

Sources and Resources

Much of the content of this document has been borrowed from these resources:

Extreme Ownership - Jocko Willink

Leaders Eat Last - Simon Sinek

Personal Authority vs. Positional Authority — Michael M. Ndlovu

https://www.linkedin.com/pulse/personal-authority-vs-positional-michael-m-ndlovu/

I Spent 3 Years Training Fighter Pilots At The Real Top Gun — And It Taught Me A Lesson All Elite Organizations Understand

https://www.efoverwatch.com/i-spent-3-years-training-fighter-pilots-at-the-real-top-gun-and-it-taught-me-a-lesson-all-elite-organizations-understand/

In the GuLight Laurence Marrin

2022-01-17T00:00:00Z

Laurence Marrin

Data Engineer

Always experiment, follow your curiosities, venture down rabbit holes and go an extra mile or two. It keeps things interesting and once in a while, it alters the course of your entire life.

How long have you been working at BrainGu, and what do you do here?

1 year.

I'm a Data Engineer on BrainGu's rapid prototyping team. Data Engineers have much overlap with Software Engineers but focus more on the underlying data and how software interacts with it. For BrainGu prototyping, I take data from many different sources and convert it into something usable. Our MVPs have involved interesting data like flight radar data, aggregated social media data, and soldier health metrics. It boils down to a two-prong process: First, we have to understand the data we are looking at and write scripts to harness it. Second, we model everything in a database in a way that reflects what the information means in real life. From there we can send it off to web applications where it is displayed meaningfully to the world.

What was your first position at BrainGu, and describe your journey to your current position?

I have been a Data Engineer the whole time at BrainGu, but I think it would be interesting to become the resident blockchain expert if that technology ever becomes relevant to our work.

What’s your favorite thing about working at BrainGu?

The big picture. The U.S. DOD has a lot of catching up to do with the advances made in big tech, and keeping up is increasingly important as warfare expands into 4G and 5G paradigms and is fought with computers, information, and in our minds. BrainGu has the brainpower to bring the DOD to the forefront of what’s possible tech-wise, and the ambition to overcome what has blocked that from happening thus far. If we scale well, we can be an integral part of a necessary flippening wherein technology drives and defines the entire sector instead of getting form-fitted to the current model.

What’s been your favorite project that you’ve worked on so far?

Maize (mah-eez) was the most interesting. It would ingest media data from Twitter, other social media platforms, and various news sites to identify coordinated information campaigns. We got to experiment on a plethora of raw sample data using Elastic Search and Python scripts, so it was fun to see what stories seemed to be trending. One story that floated to the top was an article about a Taiwanese Pineapple trade embargo. We thought it was a failure of the algorithm but it turned out the commanders who saw the prototype were impressed by the pineapple story because it was actually relevant to what they were dealing with.

Tell us about one of your passions, outside of work.

I have a secret alias selling pngs and gifs as a generative NFT-artist. NFTs are blockchain tokens with extensive digital ownership use cases but are most famous for proving ownership of jpegs and gifs (Cryptopunks). In my spare time, I write algorithms that generate the art. It’s a great creative outlet that connects visual stimulation to coding structures like TreeMaps and Recursive formulas. For color schemas, I analyze pixel frequencies of 70’s sci-fi novels to give everything a retro vibe. The output files are listed as NFTs using platforms like OpenSea and Artblocks (Ethereum) and Hicetnunc (Tezos) where NFT collectors buy them with cryptocurrency. I’m also learning how to code Ethereum to write my own smart contracts. It’s a very nerdy rabbit hole that I never meant to go down, but making a point to explore weird paths is usually worth it one way or the other..

Leadership Manifesto Part 1 Be more than a Manager, be a Leader

2022-01-03T00:00:00Z

Introduction

The art of being a good leader is equally craved by individuals and organizations. True leaders build healthy, highly cohesive, highly functional teams. Well led teams are motivated to work harder, accomplish more, and enjoy greater levels of happiness and satisfaction across all aspects of their lives, than those simply serving under a “manager.”

There is an often misunderstood distinction between “managers” and “leaders,” which I hope to address here. Simply put: Managers tell while Leaders inspire. In this document, I will walk through some of the patterns and anti-patterns of leadership.

This document is by no means a canonical listing of behaviors or characteristics that make up a good leader. Instead, it should serve as a starting place for junior leaders or those wishing to become leaders to begin their journey. It will also serve as a calibration point for intermediate and senior leaders responsible for larger parts of the organization or those who have been leaders for a long time and may have fallen out of practice in certain vital areas.

Leadership is a journey. An iterative process that continually changes and evolves. A good leader is always learning and evolving; they never “arrive.”

Leaders are not born; they are made

Leadership is not a title or a position. Leadership is the conscious decision to look after the person to your right and the person to the left of you.

There are leaders at all levels of an organization, and leaders come in all shapes and sizes. There are many biological and anthropological reasons why people naturally gravitate to leaders, but the bottom line is that leadership is a choice.

A tribe is defined as “a social division in a traditional society consisting of families or communities linked by social, economic, religious, or blood ties, with a common culture and dialect, typically having a recognized leader.” In other words, a tribe is a circle of trust and belonging that unifies a group to provide protection from danger.

Credit: Simon Sinek

Evolutionarily speaking, a leader has three primary roles

To determine who gets in and who doesn’t.
To determine how big to make the circle of belonging.
To win, elevating the tribe’s status.

Being a leader can come with many perks. Groups naturally elevate and give deference to their leaders. Evolutionarily speaking, this comes from early human history when the leaders, the alphas of the group, were given the first choice of food after a hunt and the best shelter for rest. The idea being that if the biggest and strongest of the group were given the best food and were taken care of by the tribe, they would continue to be the biggest and strongest and thus be best able to protect the tribe from danger. Able to win.

However, leadership comes with a steep personal cost and brings with it a heavy burden.

The cost of leadership is self-interest. If you are not willing to give up your perks when it matters, then you probably shouldn’t be promoted — you might be an authority, but you will never be a leader.

Similarly, you don’t get to do less work when you become a leader. You have to do more work. That “more work” you have to do is putting yourself at risk of looking after others. In history, you see this as alphas, the leaders of a tribe, running towards danger in defense of the tribe.

In business, we often get this backward.

For example, the military gives medals to people who are willing to sacrifice themselves so that others may gain. Whereas in business, we give bonuses to people who are willing to sacrifice others so that we may gain…

The DevOps Research and Assessment (DORA) State of DevOps research program, which is an independent, academically rigorous investigation into the practices and capabilities that drive high performance, concluded that “organizational culture that is high-trust and emphasizes information flow is predictive of software delivery performance and organizational performance in technology.¹” In layman's terms, wouldn’t you like to work in an organization where you have the absolute confidence and absolute knowledge that other people who work in the same organization as you would be willing to “sacrifice” themselves so that you may survive?

That is the difference that leadership makes.

Leaders remove individual ego and personal agenda. It’s all about the mission. How can we best get our team to most effectively execute the plan to accomplish the mission?

Managers vs. Leaders

There is a strong but often misunderstood distinction between “Managers” and “Leaders.” In its most simple form; Managers tell, while Leaders inspire. Leaders exemplify integrity and inspire trust and respect in their subordinates as well as their bosses.
True leaders are able to build highly cohesive, highly functional teams that work harder, accomplish more, and enjoy greater job satisfaction, with far lower rates of burnout, than those that are simply ‘managed.’
Good leadership is contagious. Everyone wants to work under good leadership, and peer managers will often see the successes of good leaders as something to emulate. A leader is never above doing the most minor or menial tasks supporting the mission and the team.
Leaders, you have a profound responsibility to care for the subordinates entrusted to you. You hold people’s livelihoods and sometimes lives in your hands. You are trusted with a significant amount of influence over the lives of your subordinates, a great burden that should be carried with the utmost reverence and humility.

Ownership

The bear of a team's success falls on the quality of the leader. Highly capable teams may be able to overcome poor leadership, but even the best teams will not be able to excel without good leadership. The leader’s attitude sets the tone for the entire team. The leader drives performance — or doesn’t. And this applies not just to the most senior leader of an overall team but to the junior leaders of teams within the team.

There are no bad teams, only bad leaders

And the right leader for each team may be a different person at different times based on the type of challenges faced.

James Kouzes & Barry Posner² The Leadership Challenge (2007)

When leaders drive their teams to achieve a higher standard of performance, they must recognize that when it comes to standards, it’s not what you preach; it’s what you tolerate when setting expectations, no matter what has been said or written, if substandard performance is accepted and no one is held accountable — if there are no consequences — that poor performance becomes the new standard. Consequences for failing need not be immediately severe, but leaders must ensure that tasks are repeated until the higher expected standard is achieved.

Ultimately, sound leadership requires knowing when to cut someone loose that can’t perform in a team. One of the more famous practical applications of this principle is Netflix’s “Keeper Test” and formal “360” evaluation tool³.

We must constantly be evaluating our team’s performance. If we aren’t winning, then we aren’t making the right decisions. And the fault for this lies with the leader, as does the responsibility for course correction.

Sources

BrainGu Selected as a Department of Defense PlatformOne Authorized Reseller

2021-11-15T00:00:00Z

GRAND RAPIDS, MI - BrainGu is excited to announce that they have been approved as a DoD PlatformOne Authorized Reseller available through the PlatformOne Basic Ordering Agreement. This partnership will continue to build on the leadership role BrainGu has already undertaken in the PlatformOne DevSecOps software and platform development community. This opportunity enables BrainGu to commercialize PlatformOne capabilities throughout the private sector. It also allows BrainGu to expand the usage of PlatformOne capabilities within the U.S. government.

BrainGu’s recent and continued growth is in no small part due to our partnership with PlatformOne. Having a partner in PlatformOne that also values the Agile process is invaluable. We’re very proud to continue this mission, bringing the Silicon Valley approach to software development for the U.S. government. PlatformOne’s capabilities combined with our operator-first process means the delivery of solutions at speeds our customers have never experienced before. - John Spencer CEO & Co-Founder of BrainGu.

When we were founded, we focused on creating the best, custom-developed tools for our clients. Over time, we realized that many of our clients were fighting similar battles. They were moving from legacy technology solutions to cloud-native ones; or they were large, federated organizations needing to develop applications quickly, reliably, and on the same tech stack. We realized that this was a problem that we’d already solved multiple times and that we should develop that solution for the commercial market. This idea became Structsure.

BrainGu has a long list of notable deliveries of DevSecOps software and platform solutions based on the DoD’s Design Reference Architecture. BrainGu’s biggest success story is WIDOW (Web-based Information DOminant Warfare). WIDOW is a modern cloud-based distributed planning application that is designed in partnership with tactical-level operators, the people that use it every day. WIDOW and all BrainGu solutions that utilize DoD PlatformOne’s capabilities are designed by working side-by-side with end-user operators and have user and developer experience as a core focal point.

About BrainGu

BrainGu develops custom DevSecOps software that enables mission success and boasts exceptional user and developer experience by working directly with end-users to solve their real-life problems and continuously improve capabilities. By automating pinch points, BrainGu innovates new ways to solve mission problems.

BrainGu’s vision is to solve complex national security challenges for the United States and its allies by incubating and scaling technology solutions that emphasize fielded, meaningful military capability in the hands of operators and mission owners.

BrainGu is setting the standard for rapid deployment and scalability of mission applications. As part of our Mission App as a Service solution offering, BrainGu offers subscription and packaged app timeline products that are aligned to BrainGu’s overall mission to provide the best, cutting-edge technology to the warfighter at the tactical edge.

Disclaimer: The views expressed are those of the contractor and do not reflect the official policy or position of the U.S. Air Force, Department of Defense, or the U.S. Government. Further, PlatformOne does not endorse nor validate the accuracy of the information provided.

BrainGu From a cybersecurity start-up to a SaaS scale-up

2021-11-01T00:00:00Z

So, you would think that developing Structsure, a software product, would catapult us right into a Growth phase, going from a boutique cybersecurity consulting startup and turning us into a Cloud Native SaaS scale-up...but it wasn’t that easy.

As a brand new company, we knew that we had great tools and that we made really awesome products that our clients loved and that we wanted to scale that awesomeness. However, we had trouble 1. understanding the market and 2. reaching customers who were early adopters of security automation in the course of software development and infrastructure operations before cloud-native and DevSecOps became "household" terms. At times we felt like we were speaking a different language when we were demoing our tech to potential customers who we knew could benefit from “going” Cloud Native and Structsure.

So, Let’s Talk about How We Got to Scale-up from Start-up.

Starting in 2018, we spent the next two years pursuing clients for Structsure. We explored use cases, and business cases within the Federal Civilian Agencies, State and Local government, commercial entities, and generally fell flat. This was due to a combination of agencies not wanting to commit to Cloud-Native, not understanding DevSecOps, financial hurdles, or other challenges.

In 2019, we found our way towards working with the USAF via AFWERX and the opportunities attached to SBIR/STTR contracts. AFWERX is an innovative acquisitions program, based on a model used by Special Operations Command, created to open doors to highly innovative problem-solving startups and small companies via small amounts of money in ways that strip out traditional DoD acquisitions bureaucracy. We thought that we’d be a great fit.

BrainGu first pitched Structsure to AFWERX in 2018 -- and while we initially weren’t chosen, we got great feedback that we were able to roll into Structsure to make it better and for BrainGu to understand the problem space better. Working with AFWERX gave us access to potential customers with defined mission needs and a pipeline of continuous feedback. 2019 showed us that BrainGu and Structures immediate product/market fit was squarely in the DevSecOps space, supporting software factories across the DoD. We would need to scale our business and our technology to take advantage of this market opportunity.

Over that very first year, the mission then was, optimizing Structsure and BrainGu for product/market fit.

Starting in 2020, we did the following to optimize scale and begin the transition from a cybersecurity consulting start-up to a SaaS scale-up:

Scaled up our hires to support the high touch nature of defense clients;
Created a culture of evolution -- evolving our culture to keep the best while adopting/adapting new ideas as we grow;
Emphasized project-oriented and solution-oriented teams; and
Developed a new process for incorporating employee feedback to run the company more effectively.

WIDOW Enabling Warfighters through Direct Access to Developers

2021-10-12T00:00:00Z

Presented by USAF Maj. Brad "Ralphie" Short, and BrainGu Sr. UX/UI Designer Justin Trout. This presentation was delivered at AFITC 2021 and focuses on how a process that focuses on User Experience can lead to developing modern and secure software that helps warfighters achieve their mission objectives.

Introduction to Being Agile - Part 2

2021-10-04T00:00:00Z

We're Agile now

You have heard that agile is more than standing up and burning down. It’s a complex system. I challenge you to describe SAFe in a few words (spoilers, it can’t be done). My guiding advice when approaching the topic is to start with the basics, the values of the Agile Manifesto.

Four value statements:

Individual and interactions over processes and tools
Working software over comprehensive documentation
Customer collaboration over contract negotiation
Responding to change over following a plan

They’re simple, elegant, and a great start. Then what? Conveniently on the same site, there are 12 principles. And then? The Six Rules of Kanban, or 29 rules on the Extreme side. Wait, not what I signed up for! Is there a tool to simplify all these things? There are plenty. I won’t even attempt to enumerate them. But which one makes me agile? Do any of them?

Using a multimeter does not make you an electrician.

Chris Antonio, BrainGu’s Learning + Development Manager, asked “What is Agile'' and addressed the distillation of “Agile Methodology '' from the four values through the 12 principles. You can read that post here. To expand on a point in Chris’s post, frameworks and tools are not themselves agile, and just using agile tools does not make you agile. It is a disappointing realization in an industry defined by what you produce as much as what you use to do it. Yes, they are useful tools. Yes, they can correlate to higher measures of agile practice (or agility). But using these tools will not change your mind or culture. As anyone who’s hit their hand using a hammer can tell you, it’s the hammer’s fault, and your fingers just get bigger as your organization grows.

So how do we Agile?

A more precise measure would be to trace the same mapping of values → principles → frameworks → tools in reverse. How are we using this tool to execute this framework? Which principle does it observe? How are we aligning our values? How are we undermining them? Perhaps the best advice for strategic direction is the 12th principle:

At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.

To pull it all the way back, let’s take a look at the first value:

Individuals and interactions over processes and tools.

You may be surprised that it is the first value by the time you’ve steeped in the multitude of rules and tools available. Admittedly I was surprised when reaching for the reference.

Tools are a great first step, but picking an agile tool does not make you agile. The critical shift to agile transformation is to use it while it works and switch when it doesn’t. It is easy to forget that it is not the tool that defines you, they express your actions, and your actions define you. As you exercise the 12th principle and experience an agile transformation, do not neglect the evaluation of an easily overlooked fundamental.

Tool choice does not need to be a uniform prescription for every problem, either. At BrainGu, we generally use Jira but are quick to whiteboard novel issues as lists of tasks, with priorities, dependencies, and whatever is germain to drill into the problem, discuss and assign action items, all without translating to Jira.

If your team is using a tool “because it’s agile,” but it is not enabling your team to be effective, or it just feels onerous, consider a new tool and continue your agile transformation.

BrainGu Delivers Remarks Regarding the Importance of DevSecOps to NATO Audience

2021-09-24T00:00:00Z

Mitch Rubinstein, Marine Veteran and BrainGu Director, brings cyberwarfare and DevSecOps expertise to the NATO audience at TechNet International.

Brussels, Belgium — BrainGu delivered remarks on the importance of DevSecOps in the emerging security environment at AFCEA’s annual TechNet International Expo & Forum. As a technology company and innovation lab successfully bringing bleeding-edge tech to the U.S. Government and Department of Defense, BrainGu was competitively selected to present.

The TechNet International audience included senior members from NATO Headquarters, NATO’s Emerging Security Challenges Division, Defence Investment Division, and Communications and Information Agency, the Allied Command Operations (ACO), the European Union (EU) Directorate-General for Defence Industry and Space, the EU Directorate-General for Communications Networks, Content and Technology, the European Defence Agency, and the U.S. Defense Information Systems Agency (DISA).

In his remarks, Mitch Rubinstein, BrainGu’s Director of Mission Systems Group, contextualized cyberwarfare with patterns of conflict throughout history, described the DevSecOps approach to security, and provided examples illustrating DevSecOps as a critical factor in the time-competitive cybersecurity environment of today. Notably for this audience, Mitch demystified how NATO can utilize the U.S. DoD DevSecOps Reference Design to easily and quickly adopt DevSecOps for platform environments and mission applications. You can watch Mitch’s entire talk, along with the presentations of all the distinguished AFCEA speakers here. Mitch’s speech begins at the 45:27 mark.

DevSecOps is not just a continuous integration / continuous deployment pipeline, nor is it just software as a service. DevSecOps brings the “Silicon Valley” approach to mission critical problems. It is the disposition of cyber talent and tooling to enable secure cloud-native application development at the speed of relevance. Cybersecurity is baked in and enforced from the first line of code. The U.S. DoD DevSecOps Reference Design is now open source. Automated tools allow NATO organizations to quickly deploy their own DevSecOps platforms and develop secure cloud-native applications in days, not years.

BrainGu presented its Mission App as a Service solution offering as an example of rapid deployment and scalability to mission application development. Successful case studies include our WIDOW and MAIZE apps.

For the latest news, follow us: LinkedIn, Twitter, Facebook.

Sharing Logic Between Components in Different React Renderers

2021-09-15T00:00:00Z

Background #

Several years ago, I wrote the article Sharing Code Between React Web and React Native Applications. That article demonstrated how to use render props to share component logic in a way that a React JS application and a React Native application could use the same business logic while rendering separate React JS and React Native views.

Since that article was published, there have been enough changes in the React community and the tools available to justify a re-write. Some of these changes include the shift from class-based to functional components, the introduction and growing importance of hooks, and the growing number of renderers that allow React developers to output to platforms other than the web and mobile.

The bottom line is that there are more targets for React and it may still be necessary to reuse logic across multiple renderers for different platforms. Fortunately, building a custom hook provides an easier path to share component logic than the original render props technique did.

This article discusses how to use a custom hook to share logic between two components; one component targeting react-dom to render HTML and another component that uses the react-pdf renderer primitives for use in creating a larger PDF component.

This article is focused on sharing component logic and does not include a deep dive into React nor the react-pdf renderer so you should refer to those packages’ documentation if you need familiarization with them.

Extracting Functionality to A Custom React Hook #

Let’s start by using vitejs to quickly scaffold a simple React project that includes a component suitable for a small demonstration on how to extract logic into a custom hook.

Initial folder structure for the app.

The initial UI for the new project

The component includes a counter that uses the useState hook to track and update the number of times the button is pressed.

function App() {
  const [count, setCount] = useState(0)

All of the logic in the initial component

If we want to use the same logic in another component we can start by extracting any logic that component requires into a hook in a separate file. The purpose of this hook is to provide any state and the functions a component requires to interact with that state.

import React, { useState } from "react";

const useApp = () =>; {
 const [count, setCount] = useState(0);

 return { count, setCount };
};

export default useApp;

Our new hook containing all of the component logic.

Now, instead of using useState directly, the App component pulls logic and state from the useApp hook as shown below.

function App() {
const { count, setCount } = useApp();

App now gets its state from the custom useApp hook.

At this point, any component we make can make use of the useApp hook. This is especially useful for a React Native View that includes the same button pressing logic. Since the user can still interact with the button and expects to see the count changed.

Using a Custom Hook to in Components Targeting Different Renderers #

Now that we have a demonstration of how to extract and build a custom hook, let's look at how this technique is useful to simplify creating a PDF component to use with react-pdf renderer.

The chatPostThreadInfo component below has multiple pieces of state and several useEffect to build the JSX that renders HTML.

const ChatPostThreadInfo = ({ post }: { post: Post }) =>; {
  // component state
  // ...

  const dispatch = useDispatch()

  // state items needed by the JSX and useEffects
  const [parentPost, setParentPost] = useState<post>()
  const [parentPoster, setParentPoster] = useState<bot |="" userprofile="">()
  const [parentPostBlurb, setParentPostBlurb] = useState<string>('')
  const [isMounted, setIsMounted] = useState(false)

  useEffect(() =>; { … }, [])
  useEffect(() =>; { … }, [post.parent_id, posts])
  useEffect(() =>; { … }, [parentPost?.message])
  useEffect(() =>; { … }, [bots, myUserProfile, parentPost, userProfiles])

  const onClickBlurb = async () =>; {...  }

  return (
      <div>
        Commented on <span>{parentPoster.username}</span>'s message:&nbsp;
          <span onclick="{onClickBlurb}">
            {parentPostBlurb}
          </span>
      </div>
    )
  }

Original component that renders HTML and includes state logic.

In order to use the same state logic to build a PDF component, all the stateful logic can be extracted to a custom hook that updates and provides state that the presentational components need.

const useChatPostThreadInfo = ({ post }: Props) =>; {
  // other internal state state
  // ...

  const dispatch = useDispatch()

  // state items needed by the JSX and useEffects
  const [parentPost, setParentPost] = useState<post>()
  const [parentPoster, setParentPoster] = useState<bot |="" userprofile="">()
  const [parentPostBlurb, setParentPostBlurb] = useState<string>('')
  const [isMounted, setIsMounted] = useState(false)

  useEffect(() =>; { … }, [])
  useEffect(() =>; { … }, [post.parent_id, posts])
  useEffect(() =>; { … }, [parentPost?.message])
  useEffect(() =>; { … }, [bots, myUserProfile, parentPost, userProfiles])

  // return the state that the presentational components need
  return { parentPost, parentPoster, parentPostBlurb }
}

export default useChatPostThreadInfo

Custom useChatThreadInfo hook to provide state to presentational components.

After the extraction, the original component that renders HTML can be updated to retrieve the necessary state from the custom hook.

const ChatPostThreadInfo = ({ post }: { post: Post }) =>; {
	// other state items…

	// obtain state from the new custom hook
	const { parentPost, parentPoster, parentPostBlurb } = useChatPostThreadInfo({ post })

	// note that this function remains in this HTML component since the PDF component will not need it
	const onClickBlurb = async () =>; { ... }

	return (
	  <div>
    	Commented on <span>{parentPoster.username}</span>'s message:&nbsp;
	    <span onclick="{onClickBlurb}">{parentPostBlurb}</span>
	  </div>
	)
}

export default ChatPostThreadInfo

Updated HTML component that now uses the useChatThreadInfo hook.

Next, the custom hook can be used to provide the same data to the component that will render the PDF version of the component.

const ChatPostThreadInfoPdf = ({ post }: { post: Post }) =>; {

	// obtain state from the new custom hook
	const { parentPost, parentPoster, parentPostBlurb } = useChatPostThreadInfo({ post })

	return (
	  <view data-testid="chat-post-thread-info">
	    <text style="{parentPostMessage}">{`Commented on ${parentPoster.username}'s message: ${parentPostBlurb}`}</text>
	  </view>
	)
}

export default ChatPostThreadInfoPdf

PDF component that uses the useChatThreadInfo hook.

Conclusion #

In the end, we can see that extracting the component logic that needs to be shared into a custom hook provides a simpler method for sharing logic and state between components than the original render props technique. This results in logic that can be shared across multiple renderers.

2021 Internship Program and Philosophy

2021-09-01T00:00:00Z

BrainGu puts an immense emphasis on the quality of our internship program. For the second year of our official Summer Internship Program, our focus has been on providing a stimulating and rewarding internship experience. As the organization grows and matures, so does our collective ability to provide an impactful internship experience. I’m confident that we have succeeded in making the 2021 internship program richer and more organized than last year.

BrainGu Internship Philosophy

BrainGu is highly committed to recruiting a diverse and well-rounded cohort of interns and providing them with an immersive and educational employment experience. We want our Gu-interns to share a similar experience to that of our full-time engineers and developers. Therefore, we strive to give them logic and technology problems to solve, teach them principles of product and project management like SAFe and Agile, and give them opportunities to self-actualize, be creative, and bring their personalities and hard work to a supportive and collaborative environment.

The 2021 Intern Cohort had two primary goals in addition to the mission of the internship program itself:

Have the interns create, test, and deliver a fully functional Swag Store for the company.
Accept more applications than 2020 and make the Internship a nation-wide opportunity.

I am happy to report that we have been successful in all three of these primary goals. We concluded the 2021 Summer Cohort with a full walk through demo of the swag store. The interns conducted a survey in Slack and the company voted to call it BrainGear. I thought it was an impressive demonstration that showcased the skills and talents of our awesome interns perfectly. They were able to get an app designed, built, tested, polished and brought to the edge of full deployment by utilizing industry best practices and leveraging team collaboration.

I think the interns certainly walked away having learned a lot, but I also believe this cohort taught us a lot about ourselves as BrainGu. One of the most important things that observing our interns this year reinforced for me was the importance of process in getting lots of work done quickly. By utilizing SCRUM and Agile principles, Chris Antonio, our Learning + Development Manager and other BrainGu leaders were able to coach the cohort to a successful product while gaining momentum, and staying on course with each new sprint. I look forward to the work that future intern generations will be able to accomplish on the foundation of the 2020 and 2021 cohorts’ cumulative progress.

This year, we recruited the most diverse group of interns yet. Our amazing cohort this year is 50% women, and we have interns from many different ethnic and national backgrounds. We will continue prioritizing our DE&I mission for all of our recruitment practices, and the work continues. Lastly, we went from processing ten qualified applications to the 2020 cohort to processing almost 200 applications to the 2021 cohort. This huge transversal of scale was made possible by our awesome recruiting team, our new applicant tracking system, Greenhouse, and our newly adopted pre-employment tech testing tool, Codility.

Codility, Greenhouse and the selection process

Last year it would have been impossible to imagine that we’d be able to get ~200 applications processed while making the process more data-driven and objective within a tight two-month time window. Greenhouse made the team lift feasible and enjoyable. Greenhouse shares a full integration with Codility. That means that we were able to send out take-home evaluations to over 150 candidates, invite the most qualified candidates to a technical interview with a panel of our engineers, and send out offers to eight extraordinarily talented and engaging interns without adding any personnel or overwhelming our current recruitment team process. Our use of Codility and Greenhouse at scale for the 2021 Internship Recruitment Sprint taught us a lot of skills and tips that we have already begun employing in our company-wide recruitment practices, things like:

Using pre-employment testing to mitigate unconscious bias.
Sticking to workflow SOPs to ensure low variation in the recruitment system, and fast, reliable results.
Analyzing and extrapolating from exported candidate data and evaluator feedback to narrow applicant pools to only the most qualified with the best cultural fit. This makes selection rounds a breeze without compromising fairness and equity.

We used a nearly identical recruitment flow for our internship recruitment as we do for our full-time positions. These are the steps that we followed in processing each application we received this year and some details about each stage:

Application Review: The recruiting team reviews each cover letter and resume, looking for the correct experience and tech stack. Unqualified applicants are rejected and encouraged to apply for a future opportunity.
Phone Screen: Qualified applicants are invited to sit for a 15-minute phone screen with a member of our recruitment team. Our team asks a series of questions from our standard question block and gets to know each qualified candidate. We answer any questions they might have about the next steps in the process, and we prepare them for a Codility test, giving them the option of which test they’d like to take. This year we offered a take-home test in either the Django Framework or the React Library.
Take-Home Codility Test: We received a completed exam for >75% of the exams we sent out invites for, which is pretty cool! Codility scores allowed us to make objective decisions for advancing candidates.
Technical Interview: The top scorers in the Codility testing rounds were invited for 30-minute technical Interviews with a panel of our incredible technologists. We used a bank of questions and problem-solving exercises that evaluated technical skill fit and took an opportunity to get a sense of each candidate’s culture fit in BrainGu with the luxury of face-to-face time.
Offer: We extended and received back 8 signed offers, with a week to spare before the start date! We made sure to be ready ahead of time with the computers, and all of our interns started their internships with a BrainGu company laptop on day 1! Thanks, April Johnson, Project Manager and Luke Reichel, ITM Manager!

The Project and the Immersion Experience

As I mentioned above, the mission of the annual internship program is to provide an educational and fully immersive simulation of employment in a technology company. This year our intern cohort is developing a fully functional and styled swag store app, called “BrainGear,” from Day 0 → Day 1, following the same SAFe Agile principles that BrainGu uses to bring solutions to our satisfied customers. The internship is self-driven, so we do our best to enable and encourage our interns to be vocal and assertive in going after the work that interests them and improving their skills in a team environment. In the 2021 cohort, we have interns gaining valuable professional experience in UI/UX design, Project and Team Management, Front and Back-End Engineering, cybersecurity, automated testing, quality control best practices, and more.

At BrainGu, we hire and evaluate by values. Therefore, we filter the work and the teamwork associated with completing the work through the lens of our three values pillars: Execution, Diplomacy, and Citizenship. Every two weeks, the intern team presents their most recent development sprint results with a demo, Q&A, and new sprint planning session. Team Members from across the company are invited to attend these Friday demos to ask questions and provide feedback. We hope that this gives all interns opportunities to get valuable business experience explaining technical and functional concepts to customers or associated stakeholders, taking their questions, and incorporating customer feedback into team iteration on end-product delivery.

Cohort 2022 and Beyond

As we look ahead to next year, we have begun to identify goals, improvements, and expansions to the Internship Program. Firstly we must continue the never-ending work on our DE&I mission. We hope to build on the diversity and equity wins of the 2021 program by partnering even closer with diversity-focused non-profit groups like Girls Who Code and STEM organizations like the North Carolina Space Grant. Second, we will continue the ongoing work of the cohorts -- developing more and better tools for BrainGu to use to drive company culture and positive employee experience. Lastly, we will continue to expand on the quality and depth of the Internship Program offered by defining SOPs for curriculum and project management and designing improved learning and development supports by leveraging Pluralsight and many more improvements (stay tuned).

After everything is stripped away, the driving force in our motivation to continue providing internship opportunities is hearing from our interns that they had a positive, memorable experience that helped and changed them and opened up doors for their futures. That makes all of this worth it.

One on One Meeting Best Practices

2021-08-16T00:00:00Z

One-on-One meetings are crucial for building a robust and professional relationship based on empathy and trust between managers and direct reports. They are even more critical at a remote-first company like BrainGu, where proverbial watercooler conversations and check-ins aren’t possible.

We expect a lot of our people and put them into high-pressure situations. So it’s key to establish a solid and consistent line of communication with each member. Team members value the time and opportunity to offer thoughts, ask questions, and connect in a non-tasking way.

Well executed One-on-One meetings also provide invaluable telemetry from the field on how people feel about their projects, technology, company, and life in general.

One-on-One meetings should be dedicated to the performance, career development, and well-being of the employee.

Performance

The objectives are to ensure that the employee fulfills their expectations with their current assignments while tracking, monitoring, and potentially making any adjustments to their SMART (Specific, Measurable, Achievable, Relevant, Time-based) development goals.

Career Development

The objective is for the employee to communicate directly with their manager what their career ambitions are and for the manager to set clear and realistic expectations and guidelines for how the employee can achieve these goals.

Employee Well-being

The objective is for the employee and manager to communicate directly about how the employee is doing. How they’re handling their current workload, and what their work-life balance is like. This also allows the manager to support their team members in managing their workload and establishing a more sustainable work-life balance.

Preparation

For a One-on-One meeting to be considered successful, both the employee and the manager should come prepared to maximize the effectiveness and efficiency of every One-on-One meeting. At BrainGu, we use Lattice to establish an agenda, share notes, and develop action items. However, it’s also crucial that the manager not lose sight of the importance of One-on-One meetings.

One-on-Ones should be treated as sacred time. Although it is very easy for managers to get busy and skip or move the One-on-Ones, cancelations should be avoided as it erodes the importance of the One-on-One and shows the employee you do not value their time.

Avoid moving/canceling One-on-Ones whenever possible.
If either person misses a One-on-One, seek to add a new event on a subsequent day as a "make-up One-on-One" to ensure that they get their time.
Every once in a while, someone will ask to skip one (rarely) for one reason or another, a response of "It’s your time if you want it. You tell me if you want to reschedule or cancel." ensures that the employee understands that they are a priority, and deserving of a portion of the manager's time.

Preparation recommendations

Employee's responsibilities:

Current assignments – During the past week, the employee should assess their contributions and whether they are meeting or exceeding their short-term goals.

You may read other articles that recommend eliminating the assignment status check from the weekly One-on-One meeting. However, we believe that is just not a realistic expectation. Instead, a weekly meeting where both parties are required to think critically about tasks and their value to the company’s mission and the individual’s goals is a good practice to exercise. It forces you and your manager to think about the importance of your daily tasks and pivot where necessary.

SMART Development goals – The employee needs to also assess the progress they have made with their development goals:

In terms of skills training (mentoring; books; certifications; classes; seminars), are they progressing according to plan?
Should any adjustments be made to the plan?
Is the employee getting opportunities to apply what they have been learning via their skills training?

Employee needs – The employee also needs to come prepared with a list of their needs. This can include tools like a new computer or software, resources like training, or conferences, help managing priorities if too many tasks are on their plate, etc.

Generally speaking, managers have teams larger than one that they are responsible for, not to mention their own tasks and deliverables. So while it’s a manager’s duty to support their direct reports and provide them with the resources they need to achieve their goals, it’s the employee’s duty to be open and honest with their managers about what those needs are.

Politics – Employees often struggle with navigating the corporate politics of any organization and specifically identifying their own strengths and weaknesses in a safe environment alongside their manager. We have a process for this we call Saving Throws, which will be discussed in more depth in a future post. This will help their manager identify roadblocks that they can help breakdown, and connect the employee with correct coworkers to help them achieve their goals.

Health and Wellness – Be prepared to discuss your health and wellness with your manager without sharing any details you aren’t comfortable sharing. However, if you’re having physical or mental health issues that are impacting both your personal and work life, your manager should be in a position to provide the support you need to achieve a balance.

Manager responsibilities:

Organize your thoughts regarding your observations of the employee concerning their current assignments and their SMART development goals.

If the employee is receiving mentoring, consult with the mentor(s) for a quick update.

Consider inviting them to the first part of the upcoming One-on-One to provide feedback directly to the employee. By taking this approach, the manager/leader does not have to perform the go-between role and instead can observe the interaction and discussions between both parties.
When the manager/leader has not been involved much in the employee’s daily activities, periodically consult with their assigned projects’ leader(s).
Ensure that the leader(s) of their employee’s assigned projects have reviewed the employee’s SMART development goals and are seeking opportunities to apply skills learning accordingly.
Depending upon the project leader’s feedback, consider inviting them to the first part of the upcoming One-on-One.

Based upon the progress made in the current phase of their career development life cycle, is the employee truly on track to fulfill their SMART development goals within the timeframes specified? If not, percolate on options involving updates to their development plans to position them for success better.

Health and Wellness – Prepare yourself to engage your employee in discussions regarding their health and well-being. Not everyone is comfortable being open about physical or mental health difficulties, especially not with their superiors or co-workers. Your responsibility as the manager is to create an environment where your direct reports can speak with you openly, without fear of retribution. Your duty in this situation is to listen and provide the support they need to achieve a balance.

Sometimes it takes two or three rounds of "how's everything else" before people loosen up. Be patient and persistent, getting them to talk rather than filling the void. Then, week over week, as the guard comes down, the work-related topics become more personal. This is where you get down to the real talk about how people are doing if they’re happy at work and outside of work.

Conclusion

Typically schedule 30m every other week, but be open to exceptions based on the employee and their preference. For example, some may want to meet weekly or for a longer time window.

End every One-on-One meeting by reviewing what was discussed and ensuring that both parties have action items and deadlines. This can include new assignments for the employee and resource gathering for the manager.

In the GuLight April Johnson

2021-08-02T00:00:00Z

April Johnson

Project Manager

My family is my top priority and I love that BrainGu encourages a great work-life balance.

How long have you been working at BrainGu, and what do you do here?

Started in June of 2020.

Project Management is my primary responsibility here at BrainGu. My background is in real estate due diligence, commercial property management, customer relations, and logistical support. My first assignment here at BrainGu was to locate and purchase a building in Grand Rapids, Michigan. Our first building purchase hit the books in January 2021. I am currently overseeing the construction, demolition, and improvements to the building. Our BrainGu building is my number one priority, but I have the privilege of participating in our company’s FedSec team, internship program, and recruitment process.

What’s your favorite thing about working at BrainGu?

Hands down - the culture. I enjoy coming to work every day, but I also enjoy getting to know everyone I work with here at BrainGu. BrainGu gives a special light on the word “community.” The passion and the drive you can see within the people who work around you encourage you to be the best at what you do. Finding new strengths along my journey here at BrainGu has given me additional motivation. I love that my leadership listens to my thoughts and truly appreciates the hard work and dedication I strive to give. And the icing on the cake is the friendships I have established here at BrainGu that will last a lifetime.

What’s been your favorite project that you’ve worked on so far?

I can’t say that I have had one favorite project. However, I have enjoyed expanding my knowledge in the security industry. This has given me the knowledge to assist me with my current role, but it has allowed me to grow as an individual to expand my career. I look forward to applying my FSO training in the near future.

Tell us about one of your passions, outside of work.

My family is my top priority, and I love that BrainGu encourages a great work-life balance. I am happily married and have three very energetic sons who bring so much joy to my life. Being a mom is a special passion, but I participate in a bowling league, softball league, coaching soccer, camping, spending time with extended family, cooking and baking.

Personas and Scenarios in UX

2021-07-01T00:00:00Z

Persona definition: A persona is a fictional but realistic description of a typical or target user of the product. A persona is an archetype instead of an actual living human, but personas should be described as real people.

A key to BrainGu's product designs is that we design products around people rather than teach people how to use our products. To do so, we understand our customers - their behaviors, attitudes, needs, and goals. We get to know the end-users/operators to create a design that will satisfy their needs.

Personas allow us to understand our primary users and create a product that works for them.

Scenario-based Design: A scenario describes a specific target user trying to achieve a particular goal or perform a specific task in one particular context.

Simply put: Scenario = user + task + context

Two pitfalls designers typically fall into are taking a feature-based or task-based approach to design. In short, the feature-based design's problem is that users don't understand features singularly or think of them like the team building them. The user is trying to accomplish a task, reach a goal, and a feature without context in the whole flow doesn't make sense most of the time. Features aren't in isolation; they almost always have an entry and exit point.

The task-based design recognizes the problem with feature-based design since the user is trying to complete a task. However, the task-based design does not always take into account users, their goals, or context.

Take the example of changing a light. That's a simple task, and assumptions about the user and task can be made. It is almost guaranteed that you thought of screwing a lightbulb into a socket as you read that task. That's the assumption. Let's step back a minute and look at the context and why the user wants to change the light. In this context, the task said light, not a lightbulb. In this example, the user is remodeling their kitchen and wants to change the light fixture. It is essential to understand the context of the task and the actual goal (the why) of the user. If we had gone ahead with our assumptions and designed and developed a feature that changed a lightbulb, that would be entirely useless for our users and waste resources.

The light example above illustrates a few crucial areas of UX design.

You are not the user. (more on this later)
Users don't say what they want. (In the example, the user just said "light" but in context meant light fixture)
Don't go with your initial thought and instead dive down into the why. Keep trying to understand the why the user is not saying.

In a scenario-based design process with personas, all of these issues would have been caught and avoided. We know the user, their goals/their why, who they are, and what they are doing. We see the context of what they are trying to do. We know the task they are trying to complete. Together, we create a scenario flow or interaction model that strings all the necessary pieces together to create an experience that delights the user.

You are not the user.

Understanding that you are not the user is the key to giving and getting feedback to create an impactful user experience. When you assume to be the user, you will unconsciously insert your assumptions and biases into the solutions you create. The biggest one being you know the product like the back of your hand. You helped build it. A user won't have an understanding even close to what you possess. Something seemingly trivial and effortless to you could trip up a user and cause a lost sale/user/mission. Always try to look at things with "fresh eyes" and from a new user's perspective.

Best Practices

While making assumptions regarding specific users and their needs can lead you down the wrong path. Assumptions based on best practices and industry standards are often the correct thing to rely on as they are tried and true.

The key is to combine industry-standard best practices with a scenario-based approach. Combining tried and tested methods with a use-case-specific context is the key to a superior user experience.

Introduction to Being Agile

2021-06-21T00:00:00Z

“We’re an agile shop now.” Have you heard this from an executive or leader in your organization? If so, were you underwhelmed with the impact of this statement? Becoming a truly agile organization takes more than a top-down statement or even a few teams implementing agile frameworks. True success comes from being an organization that exhibits agile values.

First, let’s define some things. Agile is not Scrum (or XP, or Kanban). Agile is not JIRA (or Rally, or VersionOne). Scrum is a framework for teams that want an agile way of working. JIRA is a tool that agile teams use to track their work. Neither of these is a complete agile transformation in and of itself, nor are they complete as a combination. Becoming agile requires these things, but more importantly, it requires the organization to change how it thinks and acts.

So, if an agile transformation is an impactful, and therefore likely expensive, change, why do organizations embark upon them? I see five significant benefits to a successful agile transformation, although these are not the only ones that exist:

Agile methods enable fast feedback from customers and stakeholders. Traditional methods like waterfall have a very long time gap between when a feature is requested and when it can be in the customer’s hands. In a framework like Scrum, this time gap might be as little as two weeks.
Related to fast feedback is enabling teams to do the right work, not necessarily more work. When you get feedback from customers and stakeholders more quickly, your teams can re-prioritize more rapidly and focus on the work that has the most value to your customer.
Good agile teams focus on outcomes, not just on outputs. This tends to be a difficult mindset shift for even the most mature organizations. While objective measures like velocity and say/do ratios are important, it’s far more critical to measure the impact a team’s work has on the customer. A good agile team can use OKRs (Objectives and Key Results) or business value scoring methods to measure themselves against their planned outcomes in addition to their objective metrics. For example, a team delivering ten features per quarter might seem high-achieving, but if 6 of those features are not valuable to any customer or stakeholder, are they high-achieving?
In a well-managed agile organization, Agile teams can more readily give feedback on vision & priorities up to leadership. Whether via events like big room planning or team-of-teams retrospectives, an organization that is agile from top to bottom makes time for listening to those at the lowest level of the organization. Often, these people have some of the most direct contact with the customers or the product’s inner workings and can have insights that will be lost unless space and time are provided to capture them.
Agile teams focus on sustainable development pace and avoid the release “death march.” I spent over ten years as a program and project manager for various software teams before I learned about agile. Almost every project I was involved in had a similar lifecycle: kick off the project, work on lots of code, realize we’re behind schedule, work harder, cut back on testing, realize we’ll need nights and weekends to hit our newest release date, work even harder, finally release something. After several months, the team would usually need some kind of break before getting on the hamster wheel again. Agile teams don’t do this. A fundamental principle underlying the agile manifesto is that teams should work at a pace that can maintain indefinitely. Heroics to meet release dates are not something to be celebrated but should be inspected so the organization can determine how to avoid them in the future. You can read more about the agile manifesto here: agile manifesto here.

You may be thinking, “Great, but you still haven’t told us how to be agile!” Every organization is different, and context is key to successful implementation. However, I think the following statements are good things to think about as ways to check on your transformation.

Agile is a mindset, not a methodology.
Scrum is a framework that reinforces the Agile mindset.
If you aren’t collaborating, you aren’t being Agile.
If you aren’t delivering value in short increments, you aren’t being Agile.
Lean thinking can enable better Agile practices.

When in doubt, go back to the principles behind the agile manifesto and ask if your organization embodies them. If not, what can you change to bring your teams closer to doing so?

The Twelve Principles of Agile Software (according to the Agile Manifesto)

Our highest priority is to satisfy the customer through early and continuous delivery of valuable software.
Welcome changing requirements, even late in development. Agile processes harness change for the customer's competitive advantage.
Deliver working software frequently, from a couple of weeks to a couple of months, with a preference for the shorter timescale.
Business people and developers must work together daily throughout the project.
Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done.
The most efficient and effective method of conveying information to and within a development team is face-to-face conversation.
Working software is the primary measure of progress.
Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely.
Continuous attention to technical excellence and good design enhances agility.
Simplicity--the art of maximizing the amount of work not done--is essential.
The best architectures, requirements, and designs emerge from self-organizing teams.
At regular intervals, the team reflects on becoming more effective, then tunes and adjusts its behavior accordingly.

The Importance of Usefulness in UX and UI

2021-06-15T00:00:00Z

We explore usability and utility through five major areas. Learnability, Efficiency, Memorability, Errors, and Satisfaction.

Learnability

How easy is it for users to accomplish basic tasks the first time they encounter them?

Efficiency

Once users have learned the design, how quickly can they perform the task?

Memorability

When users return after some time, how easy is it for them to reestablish proficiency?

Errors

How many errors are users making, how severe are they, and how easily can they recover from them?

Satisfaction

How pleasant is the design to use?

Usability Evaluation Criteria / Things to keep in mind when designing #

1. Keep users informed about their status appropriately and promptly. (Always show status)

GOOD: The J.Crew site displays a notification that there are “Only a Few Left!” when the user moves the mouse over low-stock sizes of a product. Some sizes are already sold out, and thus shown crossed out in light gray.

BAD: The Paradise Drinking Water site lacks breadcrumbs to indicate the user’s location on the websites and no way for the user to move back and forth between the pages other than the main navigation bar.

2. Show information in ways users understand - how the real world operates and in the users' language. (Be human and talk like one)

GOOD: The Yummly website does an effective job using icons that reflect their real-world equivalents and terms that make sense to foodies of all levels.

BAD: The Seascanner site under cruise finder doesn’t speak the users' language, with words, phrases and concepts familiar to the user, rather sticks to system-oriented terms.

3. Offer users control and let them undo errors easily. (Give users the freedom to fix mistakes easily and quickly)

GOOD: In Gmail, if a user attaches a file mistakenly, they have the option to cancel uploading before it's fully uploaded.

BAD: The iMessage app has no way for users to recall a text message (a feature that other communication apps such as WhatsApp and Slack do provide).

4. Be consistent so users aren't confused over what different words, icons, etc., mean. (Set a standard and stick with it)

GOOD: Google uses conventional menu items in its online applications. These menu labels and icons follow patterns of other competing and similar applications to lessen the user’s need to learn something new.

BAD: Ling’s car is a unique website that lacks familiarity with the well-established website conventions in terms of terminology, actions, layouts etc.

5. Prevent errors – a system should either avoid conditions where errors arise or warn users before they take risky actions. (Minimize human error)

GOOD: When booking a plane ticket on their website, JetBlue does not allow users to pick a return date that is before their departure date in order to prevent users from accidentally choosing a date that is too early.

BAD: Bitly website isn’t demonstrating error prevention by not telling me whether my email address/username or password was entered wrong or if I even have an account to login.

6. Have visible information, instructions, etc., to let users recognize options, actions, etc., instead of forcing them to rely on memory. (Don't make me think)

GOOD: Google search typing suggestion is an excellent example of contextual recommendations. As the user starts typing, Google Search suggests the relevant query, and this helps users find the relevant query in less time.

BAD: On Yale University School of Art’s website, the content has absolutely no structure, and in addition, the footer, header, and sidebar are poorly designed. Overall extremely hard for the user to navigate and find any relevant information or actions.

7. Be flexible, so experienced users find faster ways to attain goals. (Optimize to the level of the current user)

GOOD: When one searches for a specific animal on Google, it summarizes all the available resources/information into pre-refined categories to help user to efficiently navigate and consume relevant information.

BAD: Craigslist is one of the most visited websites but they have a link-based structure for the users to follow to check the necessary location-based information and complete various actions but no shortcuts.

8. Have no clutter, containing only relevant information for current tasks. (Keep It Simple Stupid)

GOOD: The Apple website is an excellent example of minimalism. Minimalistic products focus on content and remove all unnecessary visual design details. Many pages of the website are centered around one particular product or idea, and this makes it easier to prioritize information.

BAD: The Gates N Fences website is extremely cluttered and contains a lot of irrelevant information and information that is likely not to be used often, taking the focus off of the user’s main goal.

9. Provide plain-language help regarding errors and solutions. (Help users in clear language)

GOOD: On Hotels.com website the details and payment form provides alerts of what is wrong and what needs to be done to recover. The fields with errors are highlighted and itemized instructions are listed adjacently, void of error codes or technical jargon.

BAD: Blogger.com’s 404 error page does not tell users anything about what went wrong or how they can fix it, which can easily confuse users.

10. List straightforward steps in lean, searchable documentation for overcoming problems. (A manual should not be required, but is there if needed)

GOOD: Slack’s Slackbot offers users an easy and readily accessible way of getting help. All users have to do is message the bot with their question and it will help them by either answering it or providing the documentation necessary to answer their query.

BAD: Ling’s car website does not offer any visible help or documentation, preventing users from being able to access help when they need it.

Embracing the burrito How we signal affirmation at BrainGu

2021-06-01T00:00:00Z

In the early days of BrainGu, we were working on our first government contract, and in the process of developing and establishing our remote team communications protocols. We discovered a gap in our methods. We didn’t have a non-intrusive way to acknowledge a message. If someone were to reply to a comment with “Got it,” or “Roger,” or any variation a notification would be sent out to everyone associated with that message, which was quite unnecessary.

The solution was of course to add an emoji to a message indicating read and received. This left a clear visible indicator that the message had been read by the intended recipient, without sending out a cascade of notifications.

The obvious ones like :thumbs-up: 👍 were used at first, but those took too long to find, remember this was in the before times, long before your favorite and most frequently used emojis would get automatically stored at the top. So, the :burrito: 🌯 was born. Why? No one really knows, but everyone loves burritos, so it stuck and became the BrainGu universal symbol for “I’ve seen this.” Soon the use of the burrito started to spill out from BrainGu Slack channels into our customer chat services and was being used on those teams as well, by both BrainGu employees and their counterparts that worked for our partners.

In the spirit of BrainGu’s philosophy of driving customer journeys from Automation to Innovation, our own Brent Johnson uttered those famous last words, “Why stop there?” And went onto develop the now-defunct, Botrito. (Side note: developed might be a slight exaggeration, he spent a few minutes creating this automation.) The Botrito’s sole purpose was to automatically add emojis to slack messages.

Like all language, our BrainGu-isms have also evolved. From simply indicating “I’ve seen this,” to being used as a symbol for celebrating good news. Whether that good news is work-related, “Hey, I just got a promotion!” or personal, “Hey, I just got engaged!” We’ve also kicked our emoji game up a notch, including a :party-burrito: :party-Kubernetes: and so many Star Wars themed ones.

More on the Botrito

Why was the Botrito created? Truthfully, it made Brent Johnson laugh.

    
import time
from slackclient import SlackClient
#Put the OATH token here or do a get_env as in the post mentioned above.
slack_client = SlackClient('SOMETHING')
#Target's user ID in slack.  Code below shows how to get all.
someone_id = ''
#starterbot's user ID in Slack: value is assigned after the bot starts up
starterbot_id = None
#constants
RTM_READ_DELAY = 1 # 1 second delay between reading from RTM
def add_reaction(channel, ts, emoji):
  slack_client.api_call(
    "reactions.add",
    channel=channel,
    name=emoji,
    timestamp=ts
  )
def parse_bot_commands(slack_events):
  for event in slack_events:
    if event["type"] == "message" and not "subtype" in event:
      if event['user'] == someone_id:
        add_reaction(event['channel'], event['ts'], 'burrito')
      
      if name == "main":
        if slack_client.rtm_connect(with_team_state=False):
          print("Starter Bot connected and running!")
          
          #Read bot's user ID by calling Web API method auth.test
          starterbot_id = slack_client.api_call("auth.test")["user_id"]
          
          #uncomment these to print a list of all available users and their IDs.
          #users = slack_client.api_call("users.list")
          #for usr in users['members']:
          #print usr['profile']['display_name'], usr['id']
          
          while True:
            parse_bot_commands(slack_client.rtm_read())
            time.sleep(RTM_READ_DELAY)
        else:
          print("Connection failed. Exception traceback printed above.")

WIDOW Bridging Operational Gap Between Air Force and Navy

2021-05-18T00:00:00Z

For the first time, Naval Aviation units embarked at sea and Air Force units based on land were able to plan collaboratively and in real time. This was made possible during Northern Edge 21 by the WIDOW mission planning software developed by BrainGu.

For two weeks in May, over 10,000 service members across all branches of the armed services gathered in Alaska to participate in Northern Edge 2021 — a training ground for large scale, multi-domain operations. Coordinating over 300 aircraft covering upwards of 60,000 square miles of airspace is no easy feat, and this is where WIDOW stepped up to the challenge optimizing planning tasks to enable warfighters to focus on tactics and enhancing lethality.

WIDOW demonstrated at WSINT that a collaborative environment enables warfighters to optimize planning tasks between receipt of the Air Tasking Order and mission execution. These extra hours are invaluable to refine tactics and enhance lethality.

Operators on USS Makin Island, USS Theodore Roosevelt, and at Eielson AFB, Joint Base Elmendorf–Richardson, and many outlying stations all planned collaboratively in real time — the first time this has been accomplished across branches. WIDOW builds products like Communication Flows, Tanker Plans, and Altitude Blocks that were previously slowly developed by sending files back and forth over email. Initially skeptical Naval Aviators communicated how impressed they were of the quality of the software and how big of an advantage it was to be able to see missions planned in real time on the carriers, and not be in the dark until the last moment.

WIDOW is hosted on DoD Platform One, which allows BrainGu to develop and release upgrades at the speed of relevance on NIPR, SIPR, and JWICS. BrainGu had a number of engineers onsite during the exercise interfacing directly with operators to gain real-time feedback and often deployed the requested changes within a day or two. Over the course of Northern Edge, the BrainGu team implemented over 60 upgrades that were pushed to SIPR daily thanks to the CI/CD pipeline powered by DoD Platform One.

BrainGu is a cutting-edge software innovation lab with a strong mission focus that supports operators across the DoD. BrainGu partnered with the USAF in order to produce the Web-based Information Dominant Warfare (WIDOW) Mission Planning Software within only five weeks. In the year since its inception, WIDOW has planned hundreds of missions, coordinated over a thousand assets, supported 6 large scale exercises, and been designated the official USAF Mission Planning Cell Tool.

The Alliance for Commercial Technology in Government

2021-04-21T00:00:00Z

The Alliance for Commercial Technology in Government represents startups and the commercial tech sector, advocating for policies that can improve our government services and maintain our competitive advantage by bringing more tech into government programs.

The Alliance is a non-profit that advocates on behalf of our nation's innovative technology startups looking to work with the U.S. government. They do this by aligning the voice of their members and advocating for change in federal policy that will make the government market more accessible to the startup and commercial tech ecosystem.

The Alliance's founding members include former government leaders, startup executives, and venture capitalists passionate about brining best of breed technology to government. The Alliance Team.

Priorities

American innovation is driven by an incredible ecosystem for startups and commercial technology companies, but too often the U.S. government is left behind because of the complexities and barriers of federal procurement.

They are focused on reducing barriers to entry and increasing opportunities for innovative private sector tech to work with the U.S. government. The Alliance's Policy Priorities.

Membership

The Alliance's members are commercial technology companies looking to do business with the U.S. government. Membership dues support their advocacy efforts and member services and benefits, including exclusive policy insights and access to briefings and events. Apply for Membership.

BrainGu partners with Girls Who Code to close the gender gap in tech.

2021-04-01T00:00:00Z

Girls Who Code is on a mission to close the gender gap in technology and to change the image of what a programmer looks like and does. Girls Who Code equips girls with the skills they need to pursue careers in technology and the confidence they need to break barriers and thrive in a male-dominated industry.

The gender gap in computing is getting worse. In 1995 37% of computer scientists were women. Today, it's only 24%. The percentage will continue to decline if we do nothing. We know that the most significant drop-off of girls in computer science is between the ages of 13 and 17.

Girls Who Code is changing the game. They're reaching girls worldwide and are on track to close the gender gap in new entry-level tech jobs by 2027.

We believe that being brave is about being resilient, persistent, and ambitious. We believe that diverse ability, culture, identity, and opinion makes our organization stronger. We're not just preparing our girls to enter the workforce - we're preparing them to lead it, improve it, to completely and totally transform it.

Game-Changing Results

500 million people reached through online resources, campaigns, books, and advocacy work around the world.
300,000 girls served through in-person programming, including Summer Immersion Programs, Clubs, and College Loops.
50% HUGS - half of the girls served come from historically underrepresented groups, including girls who are Black, Latinx, or from low-income backgrounds.

If you'd also like to get involved and support Girls Who Code, start by visiting their website: www.girlswhocode.com

BrainGu is a corporate partner of Girls Who Code. In addition to a financial contribution, we are very excited to create a hiring pipeline for Girls Who Code Alumni both through our Internship Program and Full-Time positions. We are also looking for ways to continually support Girls Who Code in achieving their mission to close the gender gap in tech.

The BrainG-UX Philosophy

2021-03-01T00:00:00Z

Tl;dr: UX or User Experience encompasses all aspects of the end-user interactions with the company, its services, and its products.

An authentic user experience goes far beyond giving customers what they say they want. So we go deeper and research the underlying wants and needs of the end-user. To provide a high-quality user experience, we have to be seamless in our disciplines, which we discuss in detail.

There are also two primary requirements to provide a superior user experience. The first is to meet the customer’s exact needs without fuss or bother. Next, focus on simplicity and elegance to produce products that are a joy to use.

What is the difference between UI and UX?

While UX/UI is a generic term, there is a distinct difference between the two when talking about a product. The term User Interface (UI) refers to the elements that make up the interface of the product. The "tangible" portion of a design, what we see. In short, UI refers to the colors, typography, iconography, layout, and components themselves. User Experience (UX) is the intangible, the experience, the feelings of a user. It is the how or why of design as a user might think, "Why am I doing this?" or "Why is this so hard?" UX refers to the user's goal, how they get something accomplished in the product, or even why they should be bothered completing something.

Imagine the checkout process at your local grocery store. The user interface is the series of lanes. They are marked with numbers and placed conveniently at the front of the store. The user experience is the process of removing the items from your cart onto the belt and a clerk scanning and bagging your groceries while you pay. You’ve seen variations of the user interface and user experience at different stores. All else being equal, you probably prefer to shop at stores with a nicer interface and an easier and more joyous experience. It’s the same when it comes to software and its users.

Disciplines of UX

UX is an umbrella term covering a wide range of concepts; at BrainGu, we break UX out into six different disciplines.

Interaction Design

Designers focused on the user experience and how to guide users through the product to accomplish tasks.

Visual Design

Designers focused on the aesthetics of the product. Love color, typography, spacing, etc.

Motion Design

Designers adept at using motion to add another layer of aesthetics to designs.

Content Design

Content writers/strategists shape the verbiage and written experience of the product.

UX researcher

Usability researchers run studies and understand the user at a deeper level, take feedback, and translate that feedback back into directions for designers. UX Researchers dive deeper than what the user said their needs and wants are to unlock underlying requirements.

Design Engineering

Hybrid designer/front-end developers translate designs into code for handoff and prototype development for usability studies.

Goals for UX

BrainGu products and those we build on behalf of our clients should embody the pinnacle of UX principles.
Create a high-quality, consistent, enjoyable experience for our users, creating an ecosystem that people want to participate in.
Breathe life into our products to make them at or above the best products available.

Change the Box

2021-02-01T00:00:00Z

At its core, our philosophy of “Changing the Box” is about making a positive impact. Traditionally, the saying is "think outside the box." All too often, when approaching the "impossible," it is assumed that a current or previously tried approach is entirely useless. We believe that all progress against a difficult outcome is valuable, so we seek to evaluate the situation, maximize its strengths, and minimize its weaknesses. If it can be avoided, we don't want to abandon the box; we want to change it for the better – leveraging its strengths to give us a head start on solving the problem.

So how do we Change the Box?

Measure > Model > Modify

First, we Measure the situation by evaluating existing assets against the challenge at hand. Second, we Model a plan to apply those assets in a way that will most quickly begin to make a difference. Then, we Modify the situation by running the plan and getting that change into real users' hands. Once we have real-world usage, we go back to the Measure step to see how effectively we hit the mark, Model our next step in solving the problem, and Modify again until the problem is solved.

Our end goal is to support our customers by guiding them from automation to innovation.

While most view automation as an all-or-nothing proposition, we develop incremental improvements that provide an immediate impact. An apt analogy is cruise control; the technology helps drivers, but it doesn't remove the human element. It amplifies the human's capability and lessens the load. Beyond automating to solve a specific problem, BrainGu strives for true innovation by solving an entire class of problems. Think of a cherry pitter as automation and seedless fruit as innovation.

WIDOW Press Release

2020-06-09T00:00:00Z

PRESS RELEASE: June 9, 2020

The COVID-19 pandemic will have lasting effects on the U.S. military and how it operates in the future. Hundreds of airmen completing the U.S. Air Force Weapons School’s (USAFWS) rigorous coursework were left without a way to collaborate in real time while planning the final capstone exercise. The U.S. Air Force Weapons School Integration (WSINT) exercise is a series of complex, large-force employment missions, converging over the Nevada Test and Training Range. WSINT previously necessitated co- location of all participants at Nellis AFB. BrainGu is a cutting-edge software innovation lab that supports operators across the DoD. BrainGu partnered with the USAF in order to produce the Web-based Information Dominant Warfare (WIDOW) Mission Planning Software within only five weeks. WIDOW exceeded mission and operator needs, enabling WSINT participants to plan in a modern and collaborative environment.

COVID forced the Weapons School to execute our first distributed tactical-integration exercise with participants from more than ten geographically separated locations across the CONUS. WIDOW helped synchronize mission planning to ensure safe and effective execution of highly complex air, space, and cyberspace operations designed to solve our toughest potential tactical problems. The threat may force us to operate from distributed locations in the future. WIDOW is helping the Weapons School prepare the force to WIN! - USAFWS Commandant, Col Jack "Winder" Arthaud

WIDOW, built on PlatformOne, is a streamlined mission planning tool. It is purpose-built to give mission planning cell chiefs, mission commanders, and their teams time back to focus on lethality instead of admin. It makes administrative tasks more efficient across disparate teams of mission planners. In order to meet these timelines, BrainGu and the USAF relied on PlatformOne and the automated software tools provided by the DOD Enterprise DevSecOps Initiative. PlatformOne allowed BrainGu to meet the tight deadlines in a secure, flexible, and interoperable manner. During WSINT the BrainGu team completed 246 front end deployments, and 94 backend deployments during live usage (with zero downtime)— all powered by the CI/CD pipeline on PlatformOne.

Distributed mission planning is a brutal reality, but WIDOW significantly decreases the amount of time we spent working on admin and formatting excel sheets. This allowed the bulk of our focus to be spent refining the tactical plan. I loved it. I think WIDOW is the future of mission planning. Literally click one button, and it builds the product for you. It couldn’t get any easier or faster. - Capt Alex "Tuna" Plonk, 8th Weapons Squadron

BrainGu is an innovation lab with an overarching mission to dream of, incubate, and scale technology around capabilities that advance the state of the art. As a company, we combine critical analysis, creativity, and technology to transform and scale existing workflows by an order of magnitude.