What Is a Software Factory? The Governed Version for Business Teams
AI is expanding software creation beyond engineering. A governed software factory lets business teams build useful apps, agents and workflows while IT sets guardrails, manages access and sees what runs in production.

TL;DR: what you'll build. A software factory is the repeatable system a company uses to turn a business need into working, governed software, again and again. This guide defines the enterprise version: business teams describe the app, agent or workflow they need, and a shared platform builds it with identity, permissions and audit already in place, so IT sets guardrails once instead of reviewing every request from scratch. You'll get a risk-tier model, a seven-step build pattern, and a concrete walkthrough of building that factory on Major.
What is a software factory?
A software factory is a repeatable system: an intake, a shared set of tools and standards, and a delivery process that turns a need into working software over and over, rather than a one-off project. CircleCI defines it as an integrated system that moves engineering work through development, validation, delivery and feedback to produce verified software repeatedly. That is the engineering meaning: a CI/CD pipeline plus people, environments and release controls built for professional developers shipping product code.
This article is about the other half of the same idea, applied to business teams. When operations, finance, support or RevOps staff need an app, an agent, or an automated workflow, most companies still route that request through a central engineering backlog, where it waits for a sprint and competes with product work. Microsoft's Power Platform delivery-models guidance calls this a centralized delivery model and names its main failure mode directly: centralized teams become bottlenecks, and business expertise gets lost in translation to a developer who doesn't own the process.
A governed business-team software factory flips the sequence without removing the controls. The business owner describes what they need in plain language, and a shared platform builds the app, agent or workflow with authentication, data access and logging already wired in. IT sets the guardrails once, at the platform layer, instead of reviewing each new tool from scratch. That is what software factory model, software factory pattern, software factory platform and software factory meaning refer to in an enterprise AI context: a factory is the system, not a single app.
Major fits here because of how it builds software. On Major, the platform itself is the enterprise platform where agents build the software they run on: a person or an agent describes the work, and Major produces a deployed app with its own database, screens and audit log, governed by the same identity and permission layer every other app on the platform uses. That mechanism is what turns ad hoc requests into a factory.
This builds on the operating-model question in enterprise AI adoption and the access-control question in AI agent governance. This article is about the delivery system itself.
Why AI demand breaks the old delivery model
Every team now wants an AI agent that drafts something, routes something, or watches a system for them. That demand did not exist two years ago at this scale, and most IT organizations were not staffed for it.
Retool's November 2026 survey of 300 technology leaders, "Governing the Agentic Workplace," found that 89% of IT leaders report their company already has at least one AI agent in production. The numbers inside that group show the strain:
- One team owns all of it, or nobody does. 27% say a single team owns every agent; the rest have ownership scattered or undefined.
- Governance capacity hasn't caught up. 55% lack the staff to govern agents at scale.
- Business teams are outrunning review. 54% say business teams move faster than IT can review their work.
- Credentials get handled ad hoc. 40% set up data credentials one agent at a time, and 20% of that group admit credentials were shared insecurely just to get an agent working.
- Visibility is rare at the top. Retool's companion State of AI Governance report found only 5% of CIOs, CTOs and CISOs report full visibility into the AI tools running in production.
Those numbers describe a predictable failure pattern. A business team can't wait for engineering, so they wire up a prototype themselves: a spreadsheet macro, a low-code tool with an API key pasted into a script, a chatbot plugin with database read access nobody tracked. It works, so it spreads, and six months later engineering inherits a tool with no owner, no test coverage and a credential that was supposed to be temporary.
Think of a credential pasted into a script like a spare house key left under a doormat: convenient for the person who put it there, and just as available to anyone else who knows where to look.
Shadow IT is not new, but AI changes its shape. The old version was an unapproved SaaS subscription; the new version is an agent with standing access to a production database, a vendor API, or a customer's inbox, built by someone with no security training because the request would otherwise sit in a backlog for a quarter. Multiply that across every team with an AI idea, and the IT organization meant to be the safety net becomes the thing getting routed around entirely.
The software factory model: roles, controls and risk tiers
A usable operating model names who does what, and ties the amount of review to the actual risk of the work, not to who is asking. Five roles cover most of it:
- Business owner. Accountable for the process this software supports (AP manager, support lead, RevOps analyst); defines "done" and signs off that it works correctly.
- Maker. The person, often the business owner, who describes the app, agent or workflow in plain language and iterates on it. On Major this can be anyone with access, not just an engineer.
- Platform/IT owner. Sets shared guardrails: which connectors are approved, what data classes exist, what each risk tier requires. Maintains the credential store and audit trail.
- Security/data owner. Approves connector scopes for sensitive data and defines what counts as a high-impact action for this org.
- Approver. Signs off a high-risk action before it runs, either per-instance or per-release.
Risk tiers make approval proportional to consequence instead of uniform friction on everything:
- Tier 1, read-only. Dashboards and alerts that only read data, like a churn-risk dashboard. Scope: read-only API access. Approval: none; the platform owner reviews periodically. Owner: the business owner.
- Tier 2, reversible writes. Draft content and ticket creation, like an agent drafting a support reply or opening a Jira issue. Scope: write access to non-financial, internal records. Approval: logged and spot-checked, no per-action sign-off. Owner: the business owner, audited by the platform owner.
- Tier 3, high-impact writes. Payments, deletions, customer-facing sends, regulated data, like an agent issuing a refund. Scope: write access to financial systems, PII or customer channels. Approval: blocked until a named human signs off. Owner: the security/data owner and the approver jointly.
An intake form captures what a request needs before it gets built: the data class involved, the connector scope requested, a rollback plan if the automation misbehaves, a review cadence, and a named lifecycle owner for when the business owner moves teams. Skipping the intake form is how a Tier 1 dashboard quietly grows into a Tier 3 write path nobody classified.

Risk-tiered intake and approval path: what runs self-service versus what needs a human
How the software factory pattern works in practice

The governed software factory: request to production, with IT controls at every layer
The pattern is a loop, not a one-time project:
- Intake. The business owner fills out the short form above: what the software does, what data it touches, what tier it probably falls into. Minutes, not a sprint-planning cycle.
- Build. The maker describes the app, agent or workflow in plain language, producing a real deployed artifact, not a mockup.
- Connector authorization. The build requests access to specific systems, such as Shopify, Jira or Intercom. The platform owner reuses an already-scoped connector or authorizes a new one with minimum-necessary scopes.
- Test. The maker and business owner run it against real or realistic sandbox data, and confirm the risk tier matches the actual data flow.
- Risk-based approval. Tier 1 ships without a gate. Tier 2 ships with logging and spot checks. Tier 3 is blocked until a named approver signs off.
- Release. It goes live under the platform's existing SSO and role-based access.
- Logs and ownership. Every run is logged; the business owner stays the point of contact for whether it's still doing the job.
- Retirement. When the process changes or the owner leaves, someone updates or decommissions the software, rather than letting it run unattended.
A software factory is not the same as DevOps. DevOps is a set of practices, continuous integration, continuous delivery, infrastructure as code, monitoring, that a team can adopt. A factory is the production system that runs those practices end to end, with roles, intake and governance wrapped around them, for a defined population of builders. A team can have good DevOps practices and still have no factory if there's no consistent intake-to-retirement loop behind them.
What this looks like on Major: how to build the factory
Here is the build walkthrough, the way you'd actually set this up this week. It treats "the factory" as three concrete pieces: an app that holds state, an agent that makes judgment calls, and a workflow that runs the loop.
- Connect the approved connectors once. An IT admin connects the systems this process touches, for example Shopify, Jira, Intercom and Slack, through Major's connector catalog, with credentials scoped per connector in the central credential store. You should see each connector listed once, reusable by any app, agent or workflow granted access.
- Build the app that holds the intake and the state. Describe the data model: an intake table (owner, data class, connector scope, risk tier, rollback plan), a case table for work items, and a status field tracking tier and approval state. You should see a working app with a screen listing open cases and their status.
Example prompt: "Build an order exception review app that holds case history, routes high-risk orders to a person, and logs each decision with who approved it and when."
- Add the agent that uses the app. Describe the judgment the agent should make, and nothing more: read new escalations from Intercom, decide whether this looks like a product bug or a how-to question, summarize it, and draft a Jira issue, but never create it without approval.
Example prompt: "Create an agent that summarizes new support escalations, proposes a Jira issue with the relevant conversation context, and waits for a person to approve before the issue is actually created."
You should see the agent producing draft summaries in the app, with nothing written back to Jira yet.
- Set the workflow trigger. Decide what kicks the loop off: a schedule, a connector event such as a new Intercom conversation tagged "bug," or a manual button in the app. Wire the workflow to call the agent, then the app, to record the proposed action. You should see a run entry each time it fires, timestamped against the record it touched.
- Test it against real data in a sandbox scope. Run the workflow against a handful of real or copied records first, and confirm the risk-tier logic blocks the Tier 3 path by trying to force a high-impact action through. You should see the case sitting in a "pending approval" state, not "done."
- Roll out with permissions. Grant access by role: the support team can view and trigger the workflow, the engineering lead is the Tier 2 approver for Jira issue creation, and only a named manager can approve anything touching a customer refund for Tier 3 work. You should see role-scoped views, so a support rep sees their queue and the approver sees theirs, backed by the same records and audit log.
That five-piece split, connectors once, app for state, agent for judgment, workflow for the loop, and permissions on top, is what a governed software factory produces instead of a pile of one-off scripts. Other teams have shipped similar builds on Major: an operations team automated Shopify fraud-risk order review; a finance team handled Shopify-NetSuite order-to-cash exceptions; a RevOps team built Apollo.io lead routing into Salesforce; a support and engineering pairing automated the Intercom-to-Jira bug escalation flow described above; and a customer success team wired up Amplitude-to-Gainsight churn alerts. Each is a different team and a different risk tier, running the same underlying pattern.
Governance and IT control
None of the speed above is worth anything if IT can't see or control what's running. Four controls do most of the work.
- Identity and access. SSO ties every person's and every agent's action to a real identity. Role-based access means the support rep sees their queue and nothing else, and only the approver role can clear a Tier 3 action.
- Scoped credentials, not keys in code. Connector credentials live in Major's credential store, scoped to the minimum access needed, never visible in a prompt or a workflow's code. Tightening a scope once, centrally, updates every app and agent using that connector.
- Audit logs. Every app write, agent decision and workflow run is logged: what happened, who or what triggered it, when. This is what makes a Tier 2 spot-check model work.
- Managed database, storage and versioned deploys. App data lives in Major's managed database and storage, not a spreadsheet on someone's laptop. Deploys are versioned, so a bad change can be rolled back.
Tie this back to the risk tiers: Tier 1 needs identity and logging, nothing more. Tier 2 adds scoped credentials and periodic audit review. Tier 3 needs all of the above plus a named human approver before anything executes. Governance effort should scale with risk, not apply uniformly to every dashboard and every payment action alike.
Failure handling and edge cases
Things go wrong in predictable ways, and the factory pattern should expect them rather than be surprised by them.
- API errors and rate limits. Every connector has limits; Jira, Intercom, Shopify and Slack each publish their own. A workflow calling an API should back off and retry on a rate-limit response rather than failing silently or hammering the API. Build this into the workflow step, not the agent's judgment.
- Partial syncs. If a workflow pulls 50 records and fails on record 30, the app's state should reflect exactly what succeeded. Idempotent writes, where the same record processed twice produces the same result rather than a duplicate, make a retry safe. An idempotent sync is like a light switch rather than a pull-cord: flipping it "on" twice leaves the light on.
- Duplicate events. Webhooks occasionally fire twice for the same event. The app should check for an existing record by external ID before creating a new one, so a duplicate Intercom webhook doesn't create two Jira issues.
- Stale data. An agent working from an hour-old snapshot might recommend an action that no longer makes sense, like approving a refund for an order the customer already cancelled. Pull fresh data at decision time where staleness matters.
- What the agent must never do alone. Any Tier 3 action: a refund, a deletion, an external customer message, a change to someone's access. The agent proposes; a named human approves. Enforce this in the app's logic, where the write endpoint requires an approval flag, not only in the agent's instructions, since instructions can be worked around and a database constraint cannot.
- Fallback to a person. When an agent isn't confident, route to a person with full context attached, with a clear "needs review" status rather than a silent failure.
A worked example with numbers
For example, consider a 40-person customer success team at a mid-size B2B SaaS company handling about 300 active accounts. Today, a RevOps analyst manually checks a usage dashboard once a week, cross-references it against a spreadsheet of renewal dates, and flags accounts that look like churn risks. That review takes roughly 6 hours a week, and because it is manual and weekly, a usage drop on a Tuesday might not get flagged until the following Monday.
The team builds a factory output: an app holding an account-health table (account ID, usage trend, renewal date, risk flag, assigned CSM), an agent that checks usage data daily and drafts a risk summary on a meaningful drop, and a daily workflow that posts the summary into the app, routing high-value accounts (ACV over $50,000) straight to the CSM's queue.
On a given Tuesday, the workflow finds that a $75,000 ACV account's weekly active users dropped 40% over two weeks. The agent assembles context (usage trend, renewal date, ticket history) and drafts a risk summary with a recommended outreach angle. Because the account is above the threshold, the case lands in the CSM's queue flagged for review instead of auto-closing. The CSM reads it, agrees, and sends outreach that afternoon instead of a week and a half later. An account under the threshold would auto-log as a Tier 2 action with no approval gate.
Illustratively, if the weekly review used to catch risk signals with a 5-to-9-day lag and this factory output catches them within a day, and the analyst's 6 hours of weekly spreadsheet work drops to under an hour of spot-checking summaries, that is a meaningful shift in speed and headcount load, without removing the CSM's judgment on what to say to the customer. These numbers illustrate the shape of the improvement; they are not a reported customer result.
What to measure
Once a factory output like the one above is running, track the metrics the process owner already cares about, not new AI-specific vanity numbers. These are the same numbers a team would track without any AI involved; the point of the factory is to improve them, not to replace them with something new.
- Cycle time, from signal to action, such as between a usage drop and a CSM reaching out.
- Exceptions caught, cases the agent correctly flagged versus ones a person later found that the system missed.
- Manual touches per case, how many times a human intervened, edited, or overrode before the case closed.
- Approval turnaround, for Tier 3 work, how long a case waits for a named approver before it's cleared or sent back.
- Audit coverage, the share of Tier 2 actions actually spot-checked in a given period, so "logged and spot-checked" doesn't quietly become "logged and ignored."
If any of these metrics gets worse after rollout, for example approval turnaround creeping up because one approver is now a bottleneck, that is a signal to revisit the risk tier or add a second approver, not to quietly route around the gate.
Frequently asked questions
What is a software factory?
A software factory is a repeatable system, not a single tool, that turns a need into working software again and again: intake, build, approval and release, run under shared standards. In engineering, that means a CI/CD-centered delivery pipeline. For business teams, it means a governed platform where people describe apps, agents and workflows in plain language and IT sets the guardrails once.
What is the software factory model?
The software factory model names the roles and shared platform behind the system: a business owner who defines the need, a maker who builds it, a platform/IT owner who maintains guardrails and the credential store, and an approver for high-risk actions. Teams keep autonomy over what they build; the platform keeps the guardrails consistent.
What is the software factory pattern?
The pattern is the repeatable loop every piece of software goes through: intake, build, connector authorization, test, risk-based approval, release, logging and eventual retirement, whether the output is a dashboard, an agent, or a multi-step workflow.
What is a software factory platform?
A software factory platform is the shared infrastructure that makes the pattern possible: identity (SSO), role-based permissions, a managed database and storage for state, connector credentials held centrally and scoped per use, audit logging, and controlled, versioned deployment, so individual builds don't each reinvent those controls.
What does software factory mean for business teams?
For a business team, it means describing an app, agent or workflow for their own process and having it built and running the same week, instead of filing a ticket into an engineering backlog. The difference from the classic engineering SDLC factory is who the maker is: a domain expert rather than a professional developer, working inside guardrails someone else set once.
How is a software factory different from DevOps?
DevOps is a set of practices, like continuous integration, continuous delivery and infrastructure as code, that a team can adopt. A software factory is the end-to-end production system that runs those practices for a defined population of builders, with intake, roles, risk tiers and retirement wrapped around them. A team can have strong DevOps practices and still have no factory if there's no consistent loop turning requests into governed, running software.
Before you roll this out
- [ ] One workflow picked as the pilot, with a named business owner
- [ ] Data touched by the pilot classified (public, internal, confidential, regulated)
- [ ] Connector scopes reviewed and limited to what the pilot actually needs
- [ ] Risk tier assigned, with the approval requirement that tier implies
- [ ] Failure and rollback plan tested, including what happens on a partial sync or API error
- [ ] Maintenance owner named for after the pilot ships, not just for the build
- [ ] Audit log reviewed at least once before go-live, to confirm it captures what you think it does
- [ ] Sunset or re-review date set, so the pilot doesn't run unreviewed indefinitely
IT cannot safely review every prototype at the speed teams can now generate them, but direct, uncontrolled access to production data creates exactly the shadow systems the Retool survey describes. Major resolves that by moving the app layer, where the repeatable work and its state live, into a platform governed by identity, scoped credentials and audit from the first deploy. A person or an agent builds the app; IT keeps the controls that make it safe to run.
More use cases by tool: More Intercom use cases, More Jira use cases, More Shopify use cases.
Start building on Major
Build the governed software factory for your team's apps, agents and workflows. Let teams move quickly while IT controls identity, data access and what runs in production.
Related articles
- No-Code AI Agent Builder: What It Is and What to Evaluate
- AI-Powered No-Code App Builder: From Prompt to Governed App
- Enterprise App Builder: Choose for Governed Work
About the author
Ritvij Gautam is Head of Growth at Major.
Last reviewed November 19, 2026 by Ritvij Gautam.
Frequently asked questions
- What is a software factory?
- A software factory is a repeatable system, not a single tool, that turns a need into working software again and again: intake, build, approval and release, run under shared standards. In engineering, that means a CI/CD-centered delivery pipeline. For business teams, it means a governed platform where people describe apps, agents and workflows in plain language and IT sets the guardrails once.
- What is the software factory model?
- The software factory model names the roles and shared platform behind the system: a business owner who defines the need, a maker who builds it, a platform/IT owner who maintains guardrails and the credential store, and an approver for high-risk actions. Teams keep autonomy over what they build; the platform keeps the guardrails consistent.
- What is the software factory pattern?
- The pattern is the repeatable loop every piece of software goes through: intake, build, connector authorization, test, risk-based approval, release, logging and eventual retirement, whether the output is a dashboard, an agent, or a multi-step workflow.
- What is a software factory platform?
- A software factory platform is the shared infrastructure that makes the pattern possible: identity (SSO), role-based permissions, a managed database and storage for state, connector credentials held centrally and scoped per use, audit logging, and controlled, versioned deployment, so individual builds don't each reinvent those controls.
- What does software factory mean for business teams?
- For a business team, it means describing an app, agent or workflow for their own process and having it built and running the same week, instead of filing a ticket into an engineering backlog. The difference from the classic engineering SDLC factory is who the maker is: a domain expert rather than a professional developer, working inside guardrails someone else set once.
- How is a software factory different from DevOps?
- DevOps is a set of practices, like continuous integration, continuous delivery and infrastructure as code, that a team can adopt. A software factory is the end-to-end production system that runs those practices for a defined population of builders, with intake, roles, risk tiers and retirement wrapped around them. A team can have strong DevOps practices and still have no factory if there's no consistent loop turning requests into governed, running software.