Security
See token lifetimes, sessions, WAF, and CORS and the compliance control map for deployment-level guidance.
Overview
FormKiQ is deployed into your AWS account, so security is shared between the FormKiQ application controls and the AWS controls you configure around the stack. The platform uses AWS-native services for identity, API access, storage encryption, backups, logging, and network controls.
By default, the AdminEmail configured during installation is created as an administrator with full access.
For production planning in regulated or control-sensitive environments, use the Regulated Production Deployment Checklist alongside this security reference.
| Security area | How FormKiQ handles it |
|---|---|
| API authentication | JWT, AWS IAM, and API key endpoints are deployed for different integration patterns. |
| User authorization | Role-Based Access Control (RBAC) maps users and groups to FormKiQ sites and permissions. |
| Document authorization | Attribute-Based Access Control (ABAC) can evaluate document metadata through Open Policy Agent (OPA). |
| Data protection | Documents, metadata, and search indexes use AWS-managed encryption services. |
| Operational recovery | DynamoDB Point-in-Time Recovery is configured for FormKiQ tables except cache tables. |
| Network controls | VPC deployment options can be combined with customer-managed controls such as VPC Flow Logs and AWS DNS Firewall. |
Data Security
FormKiQ protects document content and metadata with encryption, authentication, and access control. The exact AWS resources depend on the modules and deployment options selected during installation.
Encryption in Transit
All API and console traffic should use HTTPS endpoints. FormKiQ API endpoints are served through AWS API Gateway, which supports:
- TLS 1.2 or higher
- HTTPS-only API access
- API Gateway managed certificates
- Custom domain certificates when configured by the customer
Encryption at Rest
FormKiQ uses AWS-managed encryption services for the primary data stores used by the platform.
| Data type | AWS service | Notes |
|---|---|---|
| Document files | Amazon S3 | Stores uploaded document content and related files. |
| Metadata and configuration | Amazon DynamoDB | Stores document metadata, site data, permissions, queues, workflow state, and configuration records. |
| Search indexes | Amazon OpenSearch Service | Used when enhanced full-text search is installed. |
| Logs and execution data | Amazon CloudWatch | Stores service logs and operational events based on the deployed stack configuration. |
For more detail on how documents and metadata are stored, see Document Storage. For encryption-specific module options, see Full Encryption.
API Security
FormKiQ deploys separate API Gateway endpoints for the supported authentication methods. This lets you choose the endpoint that matches the caller rather than forcing every integration through one authentication model.

The FormKiQ API URL values are available in the CloudFormation outputs of your FormKiQ stack.

| Authentication method | CloudFormation output | Best fit |
|---|---|---|
| JWT token | HttpApiUrl | FormKiQ Web users, browser clients, interactive testing, and user-context API calls. |
| AWS IAM | IamApiUrl | Machine-to-machine integrations, AWS services, backend jobs, and automation that can sign requests with AWS Signature Version 4. |
| API key | KeyApiUrl | Site-scoped integrations where a generated key is easier to manage than a user token. |
FormKiQ Enterprise customers can use additional authentication options such as SAML or custom JWT authorizers. See Single Sign-On and Custom JWT Authorizer.
JWT Token

JWT authentication is the default path for user-context API calls. By default, FormKiQ uses Amazon Cognito as the JWT issuer, and authorization is handled through the user's assigned groups and permissions.
A JWT token can be obtained through:
Use the HttpApiUrl CloudFormation output when calling the JWT-secured API.
FormKiQ Web
You can inspect FormKiQ Web network requests in browser developer tools and copy the Authorization header for local testing.

Browser developer tools are useful for development and troubleshooting. Do not use copied browser tokens as a production integration pattern.
Google Chrome
- Log in to FormKiQ Web.
- Open Developer Tools with
F12,Ctrl+Shift+I, orCmd+Option+I. - Select the Network tab.
- Refresh the page.
- Find an API request that includes an
Authorizationheader. - Copy the bearer token from the request headers.
Safari
- Log in to FormKiQ Web.
- Enable the Develop menu from Safari > Preferences > Advanced.
- Select Show Develop menu.
- Open Web Inspector with
Cmd+Option+I. - Select the Network tab.
- Refresh the page and copy the token from an API request header.
Mozilla Firefox
- Log in to FormKiQ Web.
- Open Developer Tools with
Ctrl+Shift+IorCmd+Option+I. - Select the Network tab.
- Refresh the page.
- Find an API request with an
Authorizationheader. - Copy the bearer token from the request headers.
Curl CLI
The Cognito API endpoint can be found in the FormKiQ CloudFormation outputs.

Use that endpoint to request a JWT token:
curl -X POST https://COGNITO_API_ENDPOINT_URL/login \
-H "Content-Type: application/json" \
-d '{"username": "USERNAME", "password": "PASSWORD"}'
AWS CLI
The Cognito CognitoClientId can be found in the FormKiQ CloudFormation outputs.

Use the client ID to request a JWT token:
aws cognito-idp initiate-auth \
--client-id YOUR_COGNITO_APP_CLIENT_ID \
--auth-flow USER_PASSWORD_AUTH \
--auth-parameters USERNAME=your_username,PASSWORD=your_password
The response includes an access token, ID token, refresh token, token type, and expiration:
{
"ChallengeParameters": {},
"AuthenticationResult": {
"AccessToken": "eyJraWQiOiJ0W...",
"ExpiresIn": 86400,
"TokenType": "Bearer",
"RefreshToken": "eyJjdHkiO...",
"IdToken": "eyJraWQiOiI5YUpvb..."
}
}
AWS IAM

IAM authentication allows API callers to sign requests using AWS Signature Version 4. This is commonly used for backend services, scheduled jobs, AWS Lambda functions, and other machine-to-machine integrations.
Use the IamApiUrl CloudFormation output when calling the IAM-secured API.
IAM-authenticated requests are authorized by AWS IAM before they reach the FormKiQ API. Because IAM requests do not carry normal FormKiQ user group context, they are typically treated as administrative or service-level integrations. For more detail on the production security value of IAM authentication, see IAM Authentication Option.
Setting Up IAM Authorization
From the AWS IAM Console, create a new IAM user or role for the integration.

For quick testing, you can attach the AWS-managed AmazonAPIGatewayInvokeFullAccess policy.

For production, prefer a least-privilege IAM policy scoped to the FormKiQ API Gateway resource instead of granting access to all API Gateway invoke operations.
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "execute-api:Invoke",
"Resource": "arn:aws:execute-api:<region>:<account-id>:<api-id>/*/*/*"
}
]
}
Create an access key only when the integration cannot use an IAM role.

You can then use the access key and secret key to sign requests to the FormKiQ IAM API. In AWS-hosted workloads, prefer IAM roles over long-lived access keys.
API Key

FormKiQ API keys provide site-scoped access to the API. Each API key is valid for a particular SiteId.
Use the KeyApiUrl CloudFormation output when calling the API key-secured API.
To create an API key from FormKiQ Web:
- Log in to FormKiQ Web as an administrator.
- Navigate to Administration > API Keys.
- Choose Create new.
- Set the key name and permissions.
- Copy the generated key immediately.

API keys can also be generated through POST /sites/{siteId}/apiKeys using WRITE_SYSTEM_MANAGEMENT for the selected site, or administrator access. Select a predefined roleType or a custom set of scoped permissions; ADMIN roles and grants cannot be assigned through this endpoint.
Store API keys securely, rotate them on a regular schedule, and remove unused keys. API keys should not be embedded in public client-side applications.
Creating an API key without a roleType or nonempty permissions array preserves the legacy READ, WRITE, and DELETE grants. Specify the desired role or scoped permissions explicitly when creating a restricted key. See API Permissions for role inheritance and grant selection.
Authorization and Access Control
Authentication confirms who or what is calling the API. Authorization controls what that caller can do after authentication succeeds.
FormKiQ supports:
- Site-level and group-level permissions through Role-Based Access Control (RBAC)
- Folder-level permissions for more specific document area controls
- Attribute-Based Access Control (ABAC) through Open Policy Agent for metadata-driven access decisions
Role-Based Access Control (RBAC)
FormKiQ supports multi-tenant environments by grouping users according to their roles and mapping those groups to one or more sites.
Each user can be associated with one or more groups. These groups determine the user's access across sites in the platform.
The permission model supports predefined roles and scoped grants such as READ_DOCUMENTS and READ_DOCUMENT_ATTRIBUTES. User Management and System Management have dedicated permissions. See API Permissions for role inheritance, group mappings, descriptions, and the permission catalog.
You can choose between:
- Automatic Site Permissions: Sites and permissions are inferred from group names.
- Defined Site Permissions: Sites are created explicitly, and permissions are granted through the API. This is supported in FormKiQ Essentials, Advanced, and Enterprise.
Automatic Site Permissions
In automatic mode, any group whose name matches the supported pattern automatically creates or links to a site with the same name and grants the corresponding permissions.
FormKiQ sites are created automatically when a user interacts with the API.
| Group | Access Level |
|---|---|
Admins | Full administrator rights on all sites. |
authentication_only | Can log in, but has no site access. |
<site> | Read, write, and delete access on <site>. |
<site>_read | Ordinary read permissions on <site>. |
<site>_write | Ordinary read, write, and delete permissions on <site>. |
<site>_delete | Ordinary delete permissions on <site>. |
<site>_govern | Ordinary govern, read, write, and delete permissions on <site>. |
<site>_system_management | The three System Management permissions on <site>. |
<site>_user_management | The four User Management permissions on <site>. |
Example group behavior:
| User group | Resulting access |
|---|---|
Finance | Read, write, and delete access on the finance site. |
Finance_read | Read-only access on the finance site. |
Finance_govern | Read, write, delete, and govern access on the finance site. |
If a user belongs to multiple groups, their permissions combine for each site. Ordinary read, write, delete, and govern roles do not grant User Management or System Management permissions. Use the corresponding management role, explicit scoped grants, or Admins for those operations.
| Example user membership | Resulting access |
|---|---|
Managers and Finance_read | Read, write, and delete access on managers; read-only access on finance. |
Govern access provides additional permissions for data governance and document control roles.
Default Cognito Groups
By default, FormKiQ uses Amazon Cognito for user authentication and creates these groups:
| Default Group | Permissions |
|---|---|
Admins | Full administrator privileges across all sites. |
authentication_only | Can authenticate, but has no site access. |
default | Read, write, and delete access on the default site. |
default_read | Read-only access on the default site. |

The Cognito user pool can be found by opening the Cognito Console and searching for the AppEnvironment name configured during installation.

Add Multi-Tenant Site
Creating a new multi-tenant site is as simple as creating a new group and adding users to that group.
To add a new group:
- Open FormKiQ Web as an administrator.
- Select Groups under Administration.
- Choose Create New Group.
- Enter the group name.

The site is created and users can be added to the group to give them access.
Add User to Site
To add a new user:
- Open FormKiQ Web as an administrator.
- Select Users under Administration.
- Choose Create New User.
- Enter the user details.

Add User to Group
To add a user to a group:
- Open FormKiQ Web as an administrator.
- Select Groups under Administration.
- Open the far-right menu on the group.
- Choose Add Member.

Search for the user and add them to the group.

Defined Site Permissions
Defined site permissions require explicit creation of FormKiQ sites. User groups can then be linked to a site with specific permissions.
Add Site
A defined site can only be created by a user with administrator access.
The example below creates a FormKiQ site called projects.
POST /sites
{
"site": {
"id": "projects",
"title": "A site that contains system projects",
"status": "ACTIVE"
}
}
Add Group Permissions
Use PUT /sites/:siteId/groups/:groupName/permissions to give a group specific permissions for a site.
For example, if you have a group called employees and want members of that group to have read and write access to the projects site, call:
PUT /sites/projects/groups/employees/permissions
{
"permissions": ["READ", "WRITE"]
}
For narrower access, the site-group service accepts scoped permission names in the JSON request:
{
"permissions": ["READ_DOCUMENTS", "READ_DOCUMENT_ATTRIBUTES"]
}
This grants those document and attribute read operations without granting write operations or management permissions. The OpenAPI schema and updated clients support these scoped names. The optional roleType selects a predefined role with omitted or empty permissions, or CUSTOM with a nonempty grant array. Without roleType, explicit permissions remain exact custom grants. Setting group grants requires WRITE_SYSTEM_MANAGEMENT for the site, and ADMIN roles and grants cannot be assigned through this endpoint. See API Permissions for supported scoped names and descriptions.
API Permissions
FormKiQ 1.19.2 adds operation-specific permissions for API keys and site roles. Use a predefined role for an access level with inherited permissions, or CUSTOM to select individual grants.
Predefined Roles
| Role | Effective access |
|---|---|
ADMIN | All API permissions, including User Management and System Management. |
READ | Ordinary read permissions. |
WRITE | Ordinary read, write, and delete permissions. |
DELETE | Ordinary delete permissions. |
GOVERN | Ordinary govern, read, write, and delete permissions. |
SYSTEM_MANAGEMENT | READ_SYSTEM_MANAGEMENT, WRITE_SYSTEM_MANAGEMENT, and DELETE_SYSTEM_MANAGEMENT. |
USER_MANAGEMENT | READ_USER_MANAGEMENT, WRITE_USER_MANAGEMENT, DELETE_USER_MANAGEMENT, and GOVERN_USER_MANAGEMENT. |
CUSTOM | Only the explicitly supplied grants; no inherited role permissions. |
Ordinary READ, WRITE, DELETE, and GOVERN roles do not include the dedicated User Management or System Management permissions. For example, the WRITE role can create documents but does not grant permission to create API keys.
ADMIN appears in the permission catalog to describe administrator access. The API key creation and site-group permission endpoints reject ADMIN roles and grants, even when called by an administrator. The reserved Admins identity group provides administrator access.
For a predefined role, provide roleType and omit permissions or leave it empty. For CUSTOM, supply a nonempty permissions array. A predefined role cannot be combined with a nonempty permissions array.
For example, this grants the predefined User Management role through PUT /sites/{siteId}/groups/{groupName}/permissions:
{
"roleType": "USER_MANAGEMENT"
}
Role Inheritance and Explicit Grants
Selecting a predefined role differs from supplying an explicit umbrella grant:
| Request | Result |
|---|---|
{"roleType":"WRITE"} | Inherits ordinary read, write, and delete permissions. |
{"permissions":["WRITE"]} | Grants the ordinary write category only. |
{"permissions":["WRITE_DOCUMENTS"]} | Grants only that scoped permission. |
A scoped grant does not imply other grants in the same area. For example, READ_DOCUMENTS does not imply READ_DOCUMENT_ATTRIBUTES.
Permission Catalog
Use GET /permissions/catalog to discover supported role types and their effective scoped permissions on the deployed version. The endpoint requires authentication but no site-specific permission or siteId.
Each role has permission groups containing names and human-readable descriptions. For example, an abbreviated response looks like:
{
"roleTypes": [
{
"name": "READ",
"groups": [
{
"name": "DOCUMENTS",
"label": "Documents",
"permissions": [
{
"name": "READ_DOCUMENTS",
"description": "Read and search documents, their content, and related document data."
}
]
}
]
}
]
}
Predefined roles list their effective permissions, including inherited operation categories. CUSTOM lists all available scoped permissions as selectable options; it does not grant those permissions automatically. Legacy umbrella grants are omitted from the scoped lists, and empty groups are omitted.
The catalog describes supported permissions, rather than the caller's current access or authority to assign grants. A listed permission does not enable a module that is not installed.
Scoped Permission Reference
The following permissions are supported by FormKiQ 1.19.2. Use the deployed permission catalog for the names and descriptions applicable to your installation.
READ_ENTITY, WRITE_ENTITY, and DELETE_ENTITY apply to custom entities and presets without dedicated permissions. The RetentionPolicy and ReminderPolicy PRESET entity types and their definitions require their dedicated *_RETENTION_POLICY and *_REMINDER_POLICY permissions instead.
| Permission | Description |
|---|---|
GOVERN_ACCESS_CONTROL | Read and manage access-control policies. |
READ_ATTRIBUTES | Read attribute definitions and allowed values. |
WRITE_ATTRIBUTES | Create and update attribute definitions and allowed values. |
DELETE_ATTRIBUTES | Delete attribute definitions and allowed values. |
READ_DOCUMENT_ACTIONS | Read document actions and their status. |
WRITE_DOCUMENT_ACTIONS | Create, update, and retry document actions. |
READ_DOCUMENT_ATTRIBUTES | Read attributes assigned to documents. |
WRITE_DOCUMENT_ATTRIBUTES | Add, update, and generate attributes assigned to documents. |
DELETE_DOCUMENT_ATTRIBUTES | Remove attributes and attribute values from documents. |
GOVERN_DOCUMENT_FOLDERS | Read and manage folder access permissions. |
WRITE_DOCUMENT_GENERATION | Generate documents from templates and data. |
WRITE_DOCUMENT_SHARES | Create shares for folders and their documents. |
DELETE_DOCUMENT_SHARES | Delete document shares. |
READ_DOCUMENT_TAGS | Read tags assigned to documents. |
WRITE_DOCUMENT_TAGS | Add and update tags assigned to documents. |
DELETE_DOCUMENT_TAGS | Remove tags and tag values from documents. |
READ_DOCUMENT_VERSIONS | Read document versions. |
WRITE_DOCUMENT_VERSIONS | Set the active version of a document. |
GOVERN_DOCUMENT_VERSIONS | Delete historical document versions. |
READ_DOCUMENT_WORKFLOWS | Read workflows, queues, and document workflow status. |
WRITE_DOCUMENT_WORKFLOWS | Create and update workflows and queues, and submit document workflow decisions. |
DELETE_DOCUMENT_WORKFLOWS | Delete workflows and queues. |
READ_DOCUMENTS | Read and search documents, their content, and related document data. |
WRITE_DOCUMENTS | Create, upload, and update documents, their content, and related document data. |
DELETE_DOCUMENTS | Delete documents and related document data. |
GOVERN_DOCUMENTS | Permanently delete documents and manage document governance, including legal holds. |
READ_E_SIGNATURE | Read electronic signature requests, envelopes, and recipients. |
WRITE_E_SIGNATURE | Create and manage electronic signature envelopes, signing views, and reminders. |
READ_ENTITY | Read entities and their attributes. |
WRITE_ENTITY | Create and update entities and their attributes. |
DELETE_ENTITY | Delete entities and their attributes. |
READ_EXAMINE_OBJECTS | Upload PDFs for examination and read their details. |
WRITE_GOOGLE_INTEGRATION | Export documents through the Google Drive integration. |
READ_INTELLIGENT_DOCUMENT_PROCESSING | Read document classifications and AI processing results. |
WRITE_INTELLIGENT_DOCUMENT_PROCESSING | Classify documents and run AI prompts against document content. |
READ_MAPPINGS | Read document data mappings. |
WRITE_MAPPINGS | Create and update document data mappings. |
DELETE_MAPPINGS | Delete document data mappings. |
READ_RULESETS | Read rulesets and their rules. |
WRITE_RULESETS | Create and update rulesets and their rules. |
DELETE_RULESETS | Delete rulesets and their rules. |
READ_SCHEMAS | Read schemas and their attribute definitions. |
WRITE_SCHEMAS | Create and update schemas and their attribute definitions. |
DELETE_SCHEMAS | Delete schemas and their attribute definitions. |
WRITE_SHORTLINKS | Create short links. |
READ_SYSTEM_MANAGEMENT | Read system and site configuration, API keys, and search settings. |
WRITE_SYSTEM_MANAGEMENT | Manage system and site configuration, API keys, and search settings. |
DELETE_SYSTEM_MANAGEMENT | Delete site groups, API keys, locales, and search resources. |
GOVERN_USER_ACTIVITIES | Read user activity and audit records. |
READ_USER_MANAGEMENT | Read users, groups, and their memberships. |
WRITE_USER_MANAGEMENT | Create and update users, groups, and their memberships. |
DELETE_USER_MANAGEMENT | Delete users, groups, and their memberships. |
GOVERN_USER_MANAGEMENT | Govern access to users and groups. |
READ_WEBHOOKS | Read webhooks and their configuration. |
WRITE_WEBHOOKS | Create and update webhooks and their configuration. |
DELETE_WEBHOOKS | Delete webhooks. |
READ_REMINDER_POLICY | Read reminder policy preset entities and their entity type definitions. |
WRITE_REMINDER_POLICY | Create and update reminder policy preset entities and their entity type definitions. |
DELETE_REMINDER_POLICY | Delete reminder policy preset entities and their entity type definitions. |
READ_RETENTION_POLICY | Read retention policy preset entities and their entity type definitions. |
WRITE_RETENTION_POLICY | Create and update retention policy preset entities and their entity type definitions. |
DELETE_RETENTION_POLICY | Delete retention policy preset entities and their entity type definitions. |
Folder Permissions
Beyond site-wide roles, you can control specific folders by assigning folder-scoped RBAC through the API. Folder permissions work in addition to site-level RBAC. A user must have the required site-level permission and folder-level permission to perform an action.
Permission Types
| Permission | Allows |
|---|---|
READ | List or download documents in the folder. |
WRITE | Create or update documents in the folder. |
DELETE | Remove documents from the folder. |
See Folders for how listed roles are evaluated and the v1.19.2 limitation on metadata access.
API Endpoint
Use this endpoint to set folder role permissions:
PUT /folders/permissions
Request Body Parameters
| Field | Type | Description |
|---|---|---|
path | string | Folder path within the site. |
roles | array | List of role and permission mappings to apply. |
roleName | string | Cognito group or custom role to grant folder permissions to. |
permissions | string[] | One or more of READ, WRITE, and DELETE. |
Example Request Body
{
"path": "invoices/2025/Q2",
"roles": [
{
"roleName": "Finance",
"permissions": ["READ", "WRITE", "DELETE"]
},
{
"roleName": "Managers",
"permissions": ["READ"]
}
]
}
Attribute-Based Access Control (ABAC)

Attribute-Based Access Control (ABAC) evaluates attributes related to the user, document, and request context. Unlike RBAC, which assigns permissions based on predefined groups, ABAC can make access decisions from metadata such as department, document type, owner, classification, or project.
FormKiQ's ABAC support is implemented through Open Policy Agent (OPA).
Attribute-Based Access Control (ABAC) is supported with FormKiQ Advanced and Enterprise.
OPA Evaluation Policies
OPA evaluates policies and returns decisions based on policy rules. The common outcomes are allow, deny, and partial.
Allow
An allow policy grants access when the specified conditions are met.
package example
default allow = false
allow {
input.user.role == "admin"
}
Deny
A deny policy blocks access when the specified conditions are met. Deny policies can enforce restrictions that override broad access.
package example
default deny = false
deny {
"guest" in input.user.roles
}
deny {
"guest" in input.user.roles
data.documents.documentType == "private"
}
Partial
OPA partial evaluation can compute document criteria that must be met before a user can access a document.
The policy below restricts users in the guest role to documents whose documentType attribute is public.
package example
default allow = false
allow {
"guest" in input.user.roles
data.documents.documentType == "public"
}
Partial Limitations
When using POST /search, multiple attribute criteria may require a configured composite key so DynamoDB can search efficiently across the requested criteria. POST /searchFulltext uses OpenSearch and does not have the same DynamoDB composite key limitation.
For module-specific setup details, see Open Policy Agent.
Document Attributes

FormKiQ enables ABAC by attaching metadata, called document attributes, to individual documents. These attributes can be evaluated by OPA policies to determine whether a user is allowed to access, modify, or delete a document.
Common document attributes include:
departmentconfidentialityownerprojectdocumentTypeclassification
These attributes form the resource context used in OPA decisions. When a user makes a request, the policy can evaluate both user attributes and document attributes.
API Endpoint
This endpoint allows administrators to define or update OPA access policies for a site:
PUT /sites/:siteId/opa/accessPolicy/policyItems
Request Body Parameters
| Field | Type | Description |
|---|---|---|
type | string | Type of policy logic. Only ALLOW is currently supported. |
allRoles | string[] | The user must belong to all listed roles to match the policy. |
anyRoles | string[] | The user must belong to at least one listed role to match the policy. |
attributes | array | Attribute matchers used to evaluate access. |
Each attribute object supports these operators:
| Operator | Description |
|---|---|
eq | Equal to a string, number, boolean, or username match. |
neq | Not equal to. |
gt | Greater than, for numbers only. |
gte | Greater than or equal to. |
lt | Less than. |
lte | Less than or equal to. |
When eq.input.matchUsername is true, the document attribute must equal the authenticated user's username.
Example Use Cases
Restrict Access to Reports Only
Allow users with the finance and auditor roles to access documents where documentType is report.
{
"type": "ALLOW",
"allRoles": ["finance", "auditor"],
"attributes": [
{
"key": "documentType",
"eq": {
"stringValue": "report"
}
}
]
}
Owner-Only Access
Allow users to access documents only if they are the owner based on the username in the access token.
{
"type": "ALLOW",
"anyRoles": ["user"],
"attributes": [
{
"key": "owner",
"eq": {
"input": {
"matchUsername": true
}
}
}
]
}
Operational Security Controls
These controls help harden a production FormKiQ deployment. Some are configured by FormKiQ automatically, while others should be reviewed as part of your AWS account and network security baseline.
DynamoDB Point-in-Time Recovery
FormKiQ automatically configures Point-in-Time Recovery for all DynamoDB tables except cache tables, with a 35-day recovery window. This protects document metadata and configuration data from accidental deletion, application errors, and service disruptions.
Point-in-Time Recovery supports:
- Recovery to a specific point within the recovery window
- Business continuity planning
- Data protection for accidental writes or deletes
- Compliance and retention requirements that require recoverable operational data
For broader recovery planning, see Backup and Recovery.
IAM Authentication Option
IAM authentication is a strong production option for backend systems and AWS-native integrations.
Using IAM authentication can provide:
- Fine-grained AWS IAM policies for API invocation
- Credential management through AWS IAM roles
- CloudTrail visibility for AWS-authenticated requests
- Conditional access using IAM policy conditions such as source IP restrictions
- Integration with AWS identity federation
Use IAM roles where possible. Use long-lived access keys only when the caller cannot assume a role.
AWS DNS Firewall
AWS DNS Firewall can be implemented by FormKiQ customers to filter and control outbound DNS traffic from their VPC. Once configured, these DNS firewall settings are customer-managed and are not modified by FormKiQ updates.
DNS Firewall can help with:
- Blocking DNS queries to known malicious domains
- Reducing DNS-based data exfiltration risk
- Enforcing approved domain allow or deny lists
- Logging DNS activity for security analysis
- Supporting network security compliance controls
Password Policy
FormKiQ password policy settings can be customized for each instance using the CloudFormation template.
A production password policy should align with your organization's security requirements and should consider:
- Minimum password length
- Complexity requirements
- Password reuse restrictions
- Account recovery process
- Identity provider requirements when SSO is used
Strong password policies reduce the risk from brute force attacks, dictionary attacks, and credential stuffing.
VPC Flow Logs
VPC Flow Logs can be configured by customers to monitor network traffic within their VPC. Once associated with the VPC, these logs are customer-managed and are not modified by FormKiQ updates.
VPC Flow Logs can help with:
- Security monitoring for unusual network patterns
- Troubleshooting connectivity issues
- Compliance evidence for network activity monitoring
- Operational visibility into traffic between resources
- Integration with SIEM or log analytics systems
Production Security Checklist
Review these items before moving a FormKiQ deployment into production:
- Confirm the admin user and
Adminsgroup membership are correct. - Remove or disable unused users.
- Use
authentication_onlyfor users who should authenticate but should not have site access. - Prefer IAM authentication for AWS-hosted service integrations.
- Scope IAM policies to the required FormKiQ API Gateway resources where possible.
- Rotate API keys and remove unused keys.
- Store API keys and access keys in a secure secret store.
- Confirm site, group, and folder permissions match your tenant model.
- Configure password policy settings to match organizational requirements.
- Review DynamoDB Point-in-Time Recovery and broader backup requirements.
- Review S3, DynamoDB, and OpenSearch encryption requirements.
- Enable VPC Flow Logs for VPC deployments where network auditability is required.
- Consider AWS DNS Firewall for VPC deployments with strict outbound DNS controls.
- Monitor API Gateway, Lambda, Cognito, and application logs in CloudWatch.
- Use ABAC and OPA when document metadata should affect access decisions.