Overview
A Stack in Paramify represents a coordinated group of people, processes, technology, and data that work together for a defined purpose and share a common approach to managing risk.
Stacks are the foundation for building a scalable security program. They allow an organization to:
- Define security responsibilities once and reuse them across multiple programs.
- Model shared services and inherited controls.
- Assign ownership for security capabilities.
- Separate products, environments, or services when their risks differ.
- Generate program-specific documentation from reusable security structures.
- Track evidence, validations, and issues at the appropriate level.
A simple way to think about the relationship is:
KEY IDEA
Stacks manage risk. Programs assemble stacks to produce a specific compliance package.
This distinction is central to using Paramify effectively. Risk intake and risk ownership are defined at the stack level, while a program brings together the stacks that apply to a particular product, system, customer, or compliance framework.
What is a stack?
A stack is a defined security or operational domain that:
- Consumes or manages data
- Serves a business or technical purpose
- Uses people, processes, and technology
- Has an identifiable risk profile
- Owns or inherits security capabilities
- Can be leveraged by other stacks or programs
For example, an organization might define the following stacks:
- Corporate Operations
- Identity and Access Management
- Security Operations
- Cloud Operations
- Site Operations
- Product Engineering
- Customer Support
- A specific product or service environment
Each stack should represent a meaningful area of responsibility, not merely a single control, tool, or isolated task.
A stack is more than a tool
A stack should not normally be defined as only “Okta,” “AWS,” or “Splunk.” Those technologies may be components or solutions within a stack.
For example:
- Identity and Access Management may use Okta, SailPoint, and YubiKeys.
- Security Operations may use Splunk, vulnerability scanners, and incident response procedures.
- Cloud Operations may manage AWS accounts, EKS clusters, S3 buckets, and cloud configuration standards.
The stack represents the responsible function and its operating model. The tools are part of how that function implements and validates security.
How stacks relate to risk
Paramify organizes security management around the relationship between:
- Data
- Risk
- Risk solutions
- Capabilities
- Evidence
- Validation
A stack begins by identifying the data it handles or protects. The sensitivity and importance of that data help determine the applicable risk and control requirements.
For example, a stack that handles customer logs or administrative authentication data may require stronger confidentiality, integrity, and availability protections than a stack handling only public information.
Paramify commonly frames this using the CIA triad:
- Confidentiality: Only authorized people and systems can access the data.
- Integrity: Data is changed only by authorized people, processes, and systems.
- Availability: Data and services remain accessible when needed.
The stack’s risk profile describes how those risks are treated. Risk may be:
- Managed directly by the stack
- Inherited from another stack
- Transferred to a service provider
- Shared between multiple stacks
- Addressed by a stack-specific implementation
For example, a cloud application may inherit physical security responsibilities from AWS while retaining responsibility for securely configuring its own S3 buckets, identity groups, and application components.
Stack versus program
Knowing the difference between a stack and a program matters for everything that follows.
| Concept | Purpose | Typical contents |
|---|---|---|
| Stack | Defines and manages risk | People, processes, technology, data, risk solutions, ownership, evidence, and validations |
| Program | Combines applicable stacks for a specific compliance or business objective | Selected stacks, controls, overlays, deliverables, system details, and framework-specific documentation |
Stacks
Stacks answer questions such as:
- What data does this environment handle?
- What people, processes, and technologies are involved?
- What risks apply?
- Who owns each capability?
- Which responsibilities are inherited?
- What evidence demonstrates implementation?
- How is the capability validated?
Programs
Programs answer questions such as:
- Which stacks apply to this product or system?
- Which compliance framework is being used?
- Which controls and overlays are in scope?
- What documentation must be produced?
- What should be shared with an auditor, customer, or government agency?
A program generally should not duplicate risk intake that already belongs in a stack. Instead, the program selects the stacks that apply and compiles their risk treatment, control implementation, and supporting content.
When should you create a new stack?
Create a separate stack when an environment, product, service, or operational function has a distinct risk management responsibility.
A new stack is usually appropriate when one or more of the following are true:
1. The purpose is different
If two groups serve different business or technical purposes, they may need separate stacks.
Example:
- Identity and Access Management provisions and certifies access.
- Security Operations monitors events and responds to incidents.
These should generally be separate stacks because their purposes and responsibilities differ.
2. The data is different
If two environments process materially different data types or data classifications, separate stacks may make the risk boundaries clearer.
Example:
- A corporate environment contains internal business data.
- A customer-facing product environment contains regulated customer data.
3. The controls or risk treatment are different
Two systems may use the same technology but configure or operate it differently.
Example:
- Corporate systems use standard multifactor authentication.
- A regulated production environment requires FIPS-enabled authentication with hardware security keys.
These may require separate stack implementations even if both use the same underlying identity provider.
4. Ownership is different
If separate teams own implementation, evidence collection, remediation, or validation, a stack boundary may help clarify accountability.
5. The products or services are materially different
When products have different architectures, managed services, deployment regions, or security tools, they may need separate stacks.
A useful rule of thumb:
RULE OF THUMB
If products are materially different in where or how they are deployed, or in the services they use, consider breaking them into separate stacks.
6. The compliance scope is different
A product or service may be subject to one framework while another is subject to a different framework or impact level. Separate stacks can make those differences explicit while still allowing shared capabilities to be inherited.
When should you reuse or inherit a stack?
Reuse an existing stack when the security responsibility, implementation, and validation approach are substantially the same.
Common examples include:
- Multiple products using the same corporate identity service
- Multiple applications hosted on the same cloud platform
- Multiple programs relying on the same security operations process
- Multiple environments inheriting the same physical security controls from a cloud provider
- Multiple customer workspaces using a shared platform security baseline
Inheritance reduces duplicated work. For example, an Identity and Access Management stack may own the configuration and validation of the organization’s identity provider. Product stacks can then inherit that capability rather than independently recreating the same configuration and evidence process.
Inheritance should reflect actual responsibility
Do not inherit a capability merely because another team uses the same tool. Confirm that the originating stack actually:
- Owns the implementation
- Maintains the configuration
- Collects or manages the evidence
- Performs the required validation
- Accepts responsibility for remediation
If a product team configures its own instance of a service or uses a materially different configuration, it may need a stack-specific implementation instead.
Recommended stack structure
A scalable security program commonly includes the following categories of stacks.
1. Organization or corporate stack
This stack contains organization-wide capabilities, such as:
- Human resources processes
- Security awareness training
- Corporate policies
- Workforce device management
- Corporate communications
- Background checks
- General business operations
Not every capability will be identical across regions or subsidiaries. Where regional or organizational differences materially change the risk treatment, consider separate stacks or stack-specific implementations.
2. Identity and access management stack
This stack may manage:
- Single sign-on
- Multifactor authentication
- Privileged access
- Access provisioning and revocation
- Access certification
- Role and group management
- Authentication hardening
- Identity-related evidence and validation
Other stacks may consume these capabilities rather than implement them independently.
3. Security operations stack
This stack may manage:
- Security monitoring
- Logging and alerting
- Vulnerability management
- Incident response
- Security event analysis
- Security information and event management
- Continuous monitoring processes
- Security issue remediation workflows
4. Cloud or technology operations stack
This stack may manage:
- Cloud accounts and subscriptions
- Compute and container platforms
- Storage
- Databases
- Network configuration
- Cloud-native security services
- Configuration management
- Infrastructure vulnerability scanning
5. Product or service stack
A product stack represents a product, service, or deployable environment that has its own risk boundary or operational responsibilities.
It may include:
- Product-specific architecture
- Product data types
- Product users
- Application security controls
- Product-specific infrastructure
- Product-specific integrations
- Product-specific evidence and validators
6. Site or facilities stack
This stack may address:
- Physical access
- Visitor management
- Environmental protections
- Physical monitoring
- Facility procedures
For cloud-hosted systems, many physical security risks may be inherited or transferred to the cloud service provider. The stack should still document that treatment where it is relevant to the applicable framework.
A practical example
Consider a SaaS product hosted in AWS GovCloud.
The organization might model the environment using:
- Corporate Operations stack
- Identity and Access Management stack
- Security Operations stack
- Cloud Operations stack
- Product stack
The resulting program would select the stacks relevant to the product and compliance scope.
Example responsibilities
| Responsibility | Owning stack | Consuming stack |
|---|---|---|
| Corporate security awareness training | Corporate Operations | Product |
| FIPS-enabled privileged authentication | Identity and Access Management | Product, Cloud Operations |
| Cloud vulnerability scanning | Cloud Operations or Security Operations | Product |
| Physical data center security | Cloud provider / inherited service | Product |
| S3 access configuration | Cloud Operations or Product | Product |
| Application-specific access roles | Product | Product |
| Continuous vulnerability monitoring | Security Operations | Product |
The product program can then include the applicable controls, implementation statements, evidence, and deliverables without duplicating the underlying security work.
How to structure a stack in Paramify
Use the following workflow when creating or refining a stack.
1. Define the stack’s purpose
Document why the stack exists and what it provides.
A good purpose statement should explain:
- What function the stack performs
- What data or services it supports
- Which teams or products depend on it
- Where its responsibility begins and ends
Example:
EXAMPLE PURPOSE STATEMENT
The Identity and Access Management stack provides centralized authentication, authorization, access provisioning, access revocation, and access certification services for organizational and product environments.
2. Identify the data
List the data types the stack handles, stores, processes, or protects.
Examples include:
- Customer records
- Administrative credentials
- Authentication logs
- System configuration data
- Security event data
- Source code
- Personnel information
- Regulated or classified information
Data should be specific enough to support meaningful risk and control decisions.
3. Identify people and roles
Document the teams and roles involved in operating the stack.
Examples include:
- Stack owner
- System administrator
- Security administrator
- Control owner
- Evidence owner
- Validator or reviewer
- Service provider
- End user
- Product administrator
Clearly distinguishing these roles matters because Paramify uses them to model responsibility and inheritance.
4. Identify processes
Document the processes used to manage the data and services.
Examples include:
- Access provisioning
- Access review and certification
- Change management
- Vulnerability management
- Incident response
- Backup and recovery
- Configuration management
- Security awareness training
- Evidence review
5. Identify technology and components
List the technologies, products, services, and infrastructure components that support the stack.
Examples include:
- Identity providers
- Cloud services
- Container platforms
- Databases
- Security monitoring tools
- Vulnerability scanners
- Ticketing systems
- Evidence collection scripts
- Hardware security keys
Technology should be mapped to the responsibility it supports. Avoid treating a tool name as a complete risk treatment.
6. Select or define the risk profile
A risk profile represents the risks that apply to the stack and the security capabilities used to address them.
The standard CIA risk profile is a useful starting point because it provides a broad baseline for confidentiality, integrity, and availability risks.
Then apply appropriate presets or configure stack-specific responses where needed.
For example:
- A shared cloud environment may inherit physical security from AWS.
- A product team may retain responsibility for S3 permissions.
- A regulated environment may require a specialized identity configuration.
- A corporate environment may use a different authentication method than a production environment.
7. Assign ownership and inheritance
For each capability, determine whether it is:
- Owned by this stack
- Inherited from another stack
- Transferred to a service provider
- Shared between stacks
- Not applicable
Avoid assigning responsibility based solely on who uses a tool. Assign it based on who implements, maintains, validates, and remediates the capability.
8. Select applicable controls
Select the control catalogs and control requirements applicable to the stack’s purpose, data, and compliance objectives.
Controls should be selected at the stack level when they describe risks or capabilities managed by that stack.
9. Define evidence requirements
For each capability, identify the evidence needed to demonstrate implementation.
Evidence may include:
- Configuration summaries
- Access review records
- Policy documents
- System reports
- Vulnerability scan results
- Audit logs
- Screenshots
- Attestations
- API results
- Evidence collected by scripts or fetchers
Where possible, define the evidence once at the owning stack and allow consuming stacks or programs to reference it.
10. Define validation
Determine how evidence will be validated.
Validation may be:
- Automated: A fetcher collects a summary and a validator evaluates the result at a set frequency.
- Attested: A responsible person manually confirms that the evidence satisfies a defined condition.
A strong implementation connects the risk solution, evidence set, validator, control, owner, and frequency.
Managing inheritance
Inheritance is one of the primary reasons to use stacks.
Example: Shared identity capability
Suppose the Identity and Access Management stack owns the organization’s identity provider.
It may be responsible for:
- Enforcing multifactor authentication
- Enabling FIPS mode where required
- Managing privileged access groups
- Maintaining authentication configuration
- Collecting configuration evidence
- Validating the settings periodically
A product stack that uses this identity service may only need to demonstrate that it:
- Uses the approved identity service
- Belongs to the appropriate identity groups
- Configures product-specific roles correctly
- Performs any application-specific access reviews
The product stack should not duplicate the entire identity provider implementation unless it actually owns that responsibility.
Example: Cloud provider inheritance
A cloud-hosted product may inherit:
- Data center physical security
- Facility access controls
- Environmental protections
- Certain infrastructure-level services
However, it may still own:
- Cloud account configuration
- Network rules
- Storage permissions
- Application identity
- Logging configuration
- Vulnerability remediation
- Product-specific security settings
Inheritance does not eliminate risk. It changes who is responsible for treating and validating the risk.
Products, services, and stacks
Organizations that sell or operate multiple products should identify the products and services included in each stack.
WHY THIS MATTERS
This will be important for when customers evaluate your security posture, providing them with relevant information for the specific SKUs they purchased.
For example, a cloud provider may offer many services, but a customer’s program may use only:
- EKS
- S3
- RDS
The program should be able to reflect the applicable services and responsibilities without including unrelated products.
When determining whether products should share a stack, consider:
- Deployment location
- Infrastructure services
- Identity and access model
- Logging and monitoring tools
- Data types
- Responsible teams
- Compliance scope
- Customer-facing commitments
If those factors differ materially, separate stacks may provide a clearer and more maintainable structure.
Using stacks in programs
After stacks are defined, create or configure a program by selecting the stacks that apply.
A program may represent:
- A product authorization
- A customer system
- A FedRAMP package
- A CMMC assessment
- An ISO or SOC 2 scope
- An internal audit
- A tenant application
- A specific deployment or environment
When stacks are associated with a program, Paramify can use the stack information to populate or inform:
- Applicable information types
- Control implementations
- Risk solutions
- Inherited responsibilities
- Evidence references
- Overlays
- System details
- Compliance deliverables
A program may contain multiple stacks, and a stack may support multiple programs.
This allows a single shared capability, such as centralized identity management or security monitoring, to be reused without manually rebuilding it for every program.
Evidence and continuous validation
Design stacks with evidence and validation in mind from the beginning.
Do not treat evidence collection as a separate activity that happens only after planning and implementation. For each capability, consider:
- What security capability is being implemented?
- What evidence proves that it is implemented?
- How often must that evidence be collected?
- How will the evidence be validated?
- Who owns the validation?
- What happens if the validation fails?
Automated evidence
Paramify can support automated evidence workflows in which:
- A fetcher or script collects a security summary from the environment.
- The summary is submitted to Paramify through the API.
- The evidence is associated with the relevant evidence set.
- A validator evaluates the result.
- A pass or failure is recorded.
- Failures can contribute to issue or continuous monitoring workflows.
The preferred pattern is generally to collect a safe, purpose-built summary rather than unnecessarily sending complete configuration files or sensitive raw data.
Manual evidence
Some evidence will remain manual or semi-automated in its validation or collection, such as:
- Policy attestations
- Annual reviews
- Screenshots
- Management approvals
- Process confirmations
- Evidence that cannot be retrieved through an API
Manual evidence should still have an owner, frequency, validation requirement, and relationship to the applicable capability and control.
Common stack design mistakes
Mistake 1: Creating a stack for every tool
A stack should represent a responsibility or operating domain. A tool may be a component within that stack.
Better approach: Create a Security Operations stack that includes Splunk, vulnerability scanners, monitoring processes, and incident response responsibilities.
Mistake 2: Creating one stack for an entire company
A single organization-wide stack may obscure ownership and make inheritance difficult to manage.
Better approach: Separate shared organizational, identity, security operations, cloud operations, and product responsibilities where their purposes differ.
Mistake 3: Duplicating inherited capabilities
Duplicating the same access management, monitoring, or physical security implementation across every product creates unnecessary maintenance and inconsistent evidence.
Better approach: Define the capability in the owning stack and have consuming stacks inherit it.
Mistake 4: Inheriting responsibilities that are not actually shared
Using the same product or service name does not mean the implementation is shared.
Better approach: Confirm who configures, maintains, validates, and remediates the capability.
Mistake 5: Mixing materially different environments
Corporate, development, production, and regulated environments may use different controls, data, or authentication requirements.
Better approach: Separate them when the differences affect risk treatment or evidence.
Mistake 6: Treating a program as the place for all risk intake
Programs should assemble and report on risk; stacks should define how risk is managed.
Better approach: Perform risk intake at the stack level, then associate applicable stacks with programs.
Mistake 7: Designing documentation without evidence
An implementation statement that cannot be supported by evidence is incomplete.
Better approach: Define the evidence and validation method at the same time as the capability.
Mistake 8: Overloading a shared workspace with unrelated scope
A shared assurance or monitoring environment may contain broad organizational data. Providing access to that environment without considering scope can expose more information than intended.
Better approach: Use separate program or application workspaces where needed, and provide customers, auditors, or agencies with appropriately scoped read-only views or deliverables.
Recommended design pattern for multi-product organizations
For organizations operating multiple products or customer environments, the following pattern is often effective:
Shared foundational stacks
Create reusable stacks for capabilities such as:
- Corporate operations
- Identity and access management
- Security operations
- Cloud operations
- Platform engineering
Product or tenant stacks
Create separate stacks or workspaces for:
- Product-specific responsibilities
- Customer-specific applications
- Unique deployment models
- Application-specific data
- Product-specific controls or evidence
Programs
Create programs that combine the shared and product-specific stacks required for a given:
- Product authorization
- Customer deployment
- Compliance framework
- Government customer
- Internal assessment
This structure allows shared controls and evidence to be managed once while preserving the separation needed for program-specific documentation.
Stack design checklist
Before finalizing a stack, confirm the following:
Purpose and scope
- Is the stack’s purpose clearly defined?
- Does it represent a meaningful business, technical, or security responsibility?
- Is the scope distinct from other stacks?
- Are the products and services associated with the stack identified?
Data and risk
- Are the data types identified?
- Are confidentiality, integrity, and availability risks considered?
- Are applicable information types and classifications documented?
- Is the compliance scope clear?
Ownership
- Is there a responsible stack owner?
- Are implementation and evidence owners identified?
- Are inherited responsibilities documented?
- Are service provider responsibilities distinguished from customer responsibilities?
Implementation
- Are the relevant people, processes, and technologies documented?
- Is the applicable risk profile selected?
- Are stack-specific exceptions or special implementations documented?
- Are applicable controls selected?
Evidence and validation
- Is the evidence required for each capability defined?
- Is evidence collection automated or manual?
- Is the validation method documented?
- Is the evidence frequency defined?
- Is there a process for handling validation failures?
Program use
- Can the stack be reused by multiple programs where appropriate?
- Can a program select only the stacks relevant to its scope?
- Are customer, auditor, or agency views appropriately limited?
- Can the resulting documentation and evidence be maintained over time?
Summary
Stacks are the core building blocks for scalable risk management in Paramify.
A well-designed stack:
- Represents a clear operational or security responsibility.
- Identifies the people, processes, technology, and data involved.
- Defines how risk is treated.
- Makes ownership and inheritance explicit.
- Connects capabilities to controls, evidence, and validation.
- Can be reused across multiple programs.
- Keeps product- and customer-specific responsibilities separate when necessary.
The recommended operating model is:
RECOMMENDED OPERATING MODEL
Define risk in stacks, reuse shared capabilities through inheritance, combine stacks into programs, and validate implementation through evidence.
This structure helps organizations avoid duplicating compliance work, clarifies accountability, and makes it easier to produce accurate, scope-specific security documentation.
Comments
0 comments
Please sign in to leave a comment.