ATO Readiness: Engineering a System for Authorization

For strong products, the obstacle to an authority to operate (ATO) is “not capability; it’s interpretability,” according to Henry Sienkiewicz, former Chief Information Officer and Authorizing Official at the Defense Information Systems Agency (DISA). Authorizing officials approve systems they can understand, and engineers decide how understandable a system is long before anyone writes an authorization package.
That makes ATO readiness an engineering problem. In the RapidFort webinar ATO 101: Beyond the Compliance Checklist, Sienkiewicz walked through the architecture decisions that speed authorization up or stall it. This article covers what he told engineering teams to get right first: boundaries, dependencies, evidence, impact level, continuous authorization, and AI.
Why ATO readiness starts in architecture
Sienkiewicz starts with where risk comes from. In his experience, risk emerges from how systems are built and how their dependencies interact, and those architecture and integration decisions shape outcomes long before an attack occurs.
Reviewers also judge your system in context. A clean container, a defined boundary, and a zero trust design all count, but cloud services, AI models, and vendor integrations change how the system behaves in ways nobody outside can see. The government has to make a risk decision about a system it can’t fully inspect.
The Risk Management Framework (RMF) gives that decision a common structure. It standardizes how systems are evaluated, pulls technical evidence (ideally produced by your CI/CD pipeline) into a consistent form, and lets authorizing officials compare very different systems. Sienkiewicz calls RMF the government’s language, and your job as a vendor is to show you speak it. If reviewers can’t see how your system fits together, authorization stalls.
Define the boundary and every dependency inside it
Your boundary defines what reviewers evaluate. They need to see what sits inside it, what the system relies on, what lies outside, and where responsibility transfers to someone else. Without those answers, they can’t assess risk.
Boundaries are the first thing to blur in practice, and AI and agentic systems blur them faster by making it harder to say which component is doing what. Sienkiewicz’s advice is to define boundaries more carefully as systems become more permeable. If your product calls an external large language model through an API, for example, the boundary should show where your system ends, where the provider’s begins, and what data crosses between them.
Dependencies get the same scrutiny. Every system has them: external calls, shared infrastructure, cloud resources, and vendor platforms. Reviewers will ask where your software comes from and where your hardware comes from, and confidence in an authorization rarely builds without those answers.
Commercial engineering habits work against this. Systems built for speed and scale abstract away layers, and each hidden dependency or unexplained call makes the system harder to interpret. For example, a current software bill of materials (SBOM) for each container image answers the sourcing question directly, and an RBOM® captures the software components, libraries and binaries actually loaded or executed during runtime.
Use evidence to explain how the system behaves
Sienkiewicz describes documentation and assessments as “waystations” on the way to understanding. Evidence exists so a reviewer can see how the system behaves and how it is governed, and a stack of artifacts with no interpretation doesn’t get you there. His practical requirements are:
- Collect the right evidence.
- Format it to follow RMF.
- Present it so the people adopting your product can understand it.
Sienkiewicz pointed to tools such as RapidFort as a way to pull this evidence together. RapidFort Continuous Compliance compiles security benchmarks into audit-ready documentation for ATO, NIST, and FedRAMP. Whatever builds the package, test it against one standard: can a reviewer who has never seen your system follow it?
Choose your impact level before you build
The impact level you design for is one of the costliest early decisions to get wrong. For a cloud service, that usually means a FedRAMP baseline of Class A, Class B, and Class C; Department of Defense work adds impact levels such as IL4 through IL6. Set the level too low and you re-engineer later. Set it too high and you spend money and time the system doesn’t need, which hurts most at a startup.
Sienkiewicz’s guidance:
- Find the real mission requirements. Talk to sponsors and customers.
- Don’t overengineer “just in case.”
- Don’t underestimate complexity at higher levels. Higher levels carry additional requirements because those systems can be critical to national security.
He described companies redoing six months of work after changing approach. Settling the impact level at the start avoids that.
Build for continuous authorization
A static authorization snapshot, renewed every year or every few years, no longer keeps pace with how systems change. Sienkiewicz pointed to continuous authorization as the direction federal practice is heading, with confidence maintained through ongoing monitoring and engagement. He noted that the effect of AI models on cybersecurity vulnerabilities has made the limits of static authorization clear.
Continuous delivery raises the bar. Frequent patches speed up delivery and add complexity, and the government needs to see how you push changes. As he put it, the patch-Tuesday model is gone. When the government can’t see how a system changes, it loses control and its confidence drops. Tool your system for continuous authorization so your change process is visible and governable.
Explain how your AI components behave
AI adds another layer. Models, their training data, and their operating context change, sometimes minute by minute. Most systems are deterministic, so the same input produces the same output. AI systems are probabilistic, and the same input can produce different outputs.
Whether your product calls an external large language model through an API or runs its own small language model, you need to show the government how it works and why it can trust a probabilistic component. Sienkiewicz was candid that this is a hard, unsolved problem, which puts more weight on a clear explanation of what the model does, what it takes in, and where it sits in your boundary.
What an ATO-ready system has from day one
The common thread is timing. Many systems aren’t designed for governance, and gaps such as unclear architecture, unknown vendor dependencies, fragmented ownership, and limited operational visibility delay authorization until someone closes them. Sienkiewicz traced several of these back to sound ITIL and IT service management (ITSM) practice that teams introduce too late.
Build these in from the start:
- Clear boundaries
- Known and explained dependencies, including sourcing
- Explainable architecture
- Clear ownership of processes inside your own organization
- Complete operational visibility, so the government can have it too
As Sienkiewicz put it, if you’re doing good engineering, you’re already building it. For the decision side of authorization, including roles and what authorizing officials look for, read our companion article.
Watch the webinar. RapidFort’s webinar, ATO 101: Beyond the Compliance Checklist, covers the RMF steps and authorization detail behind this article.
Latest posts
Eliminate Attack Vectors at the Source
Continuously eliminate up to 99.9% of CVEs without code changes
Products
Use Case
Quicklinks
Stay in touch
Subscribe for product updates and RapidFort newsletter.
Address
440 North Wolfe Road, Sunnyvale, CA 94085
© 2026 RapidFort, Inc.
RapidFort, RAPIDFORT, and RBOM® are registered trademarks of RapidFort, Inc. All other marks and names mentioned herein may be trademarks of their respective companies.



