Skip to main content

Custom application development

Turn the workflow into an owned application.

Werkon develops custom applications when a business workflow needs clearer roles, dependable records, enforceable rules, visible state, and a practical operating path that existing tools cannot provide on their own.

Application contract

Define the work, authority, records, and operating limits together.

A buildable application boundary describes what happens before and after every visible action. It includes source evidence, role authority, state, integration behavior, failure, support, and eventual exit, not only a feature list or set of screens. Review software integration for system handoffs and low-code versus custom software when configuration may be sufficient.

Inputs

Work and exceptions
Users, goals, triggers, inputs, decisions, steps, handoffs, queues, approvals, outputs, frequency, volume, measures, delays, workarounds, edge cases, and the current path when a system or person is unavailable.
Roles and authority
User and service identities, tenants, roles, permissions, separation of duties, delegated access, approval limits, sensitive actions, revocation, support access, audit readers, and accountable business owners.
Records and rules
Source systems, identifiers, fields, meanings, validation, relationships, ownership, state transitions, calculations, retention, deletion, exports, imports, reconciliation, and the rules that must remain deterministic.
Product and operating constraints
Browsers or devices, accessibility needs, languages, integrations, environments, security and privacy obligations, performance, availability, continuity, release windows, support capacity, budget, timeline, and client ownership requirements.

Outputs

Behavior and authority map
A task-by-task record of actors, inputs, source facts, rules, valid states, allowed actions, approvals, exceptions, outputs, evidence, measures, and the owner responsible for each decision and failure path.
Domain and interface contract
Explicit terminology, record models, identifiers, validation, permissions, state transitions, screens, content states, APIs or events, compatibility rules, error behavior, and representative fixtures.
Complete application slice
One useful path through identity, interface, server-side rules, source data, integration, audit, accessibility, automated checks, deployment, observability, exception handling, and a recoverable release.
Client operating pack
Source access, environment and credential ownership, decisions, setup, release and rollback steps, monitoring, alerts, runbooks, backup and recovery expectations, support boundaries, change process, tests, and supplier exit evidence.

Application path

Prove one real task across the whole system.

The first useful slice is intentionally narrow but production-shaped. It reaches from an authorized user through the rule and source record to a visible result, audit event, failure path, release, and operating owner.

  1. 01

    Observe the current task

    Follow real work, records, decisions, exceptions, handoffs, systems, delays, measures, and recovery behavior with the people who perform, approve, support, and govern it.

  2. 02

    Model authority and state

    Define terms, actors, permissions, source ownership, identifiers, valid states, transitions, invariants, approvals, audit needs, failure behavior, and the evidence for acceptance.

  3. 03

    Build a complete slice

    Connect identity, interface states, validation, server-side rules, persistence, integration, audit, accessibility, tests, deployment, observation, and an owned exception for one real behavior.

  4. 04

    Test hostile and ordinary paths

    Verify valid work, denied roles, invalid states, duplicate requests, conflicting edits, dependency failure, sensitive data handling, browsers or devices, accessibility, performance, rollback, and recovery.

  5. 05

    Release and transfer ownership

    Stage adoption, observe task and service evidence, repair root causes, document decisions, transfer access and operational knowledge, rehearse recovery, and choose the next smallest complete behavior.

Build decision

Choose the smallest durable intervention.

A custom application creates a product to own. The decision should compare that continuing responsibility with the real limits of current tools, supported configuration, integration, and process change.

01The workflow fits supported behavior

Configure a current system

Use the existing product when its data model, permissions, workflow, interface, reporting, integrations, support, and export path meet the important needs without brittle workarounds.

Evidence: Fit against critical tasks and exceptions, supported configuration, permission and data tests, total operating cost, vendor limits, upgrade path, export test, and accountable owner.

02The source system should remain

Extend or connect

Add a focused interface, service, or integration when authoritative records and core behavior are useful but one task, decision, view, or exchange needs a better boundary.

Evidence: Source ownership, supported interfaces, extension boundary, identity, compatibility, failure and reconciliation tests, release independence, support split, and exit path.

03The operating contract is distinct

Build a custom application

Build when the workflow, rules, roles, experience, integration, or ownership need is important and specific enough that available products would distort the operation or create greater long-term burden.

Evidence: Observed task, accepted product boundary, state and authority model, representative data, complete-slice proof, lifecycle cost, operating owner, recovery plan, and client handover criteria.

04Software would encode unresolved work

Change or defer the process

Simplify the policy, remove a handoff, resolve record ownership, establish authority, or postpone construction when the process itself is unstable or the expected value cannot yet be evidenced.

Evidence: Named process decision, owner, changed rule or handoff, baseline and review date, reversible experiment, stopping condition, and the evidence required to reconsider software.

Application controls

Keep authority and state outside the interface.

A polished screen is not a security boundary or source of truth. Consequential behavior needs server-side enforcement, explicit state, durable evidence, recoverable change, and an operating owner. The OWASP Application Security Verification Standard provides a basis for specifying and verifying application security requirements.

Authority is enforced at the action
Authenticate identities, derive current tenant and role context, authorize the exact record and operation on the server, minimize service privileges, protect credentials, and test denial, revocation, impersonation, and support access.
State changes are valid and traceable
Validate inputs, current state, version, invariants, ownership, approval, and duplicate effects before a write. Record who changed what and why without leaking protected values, and make conflicts visible.
Data has a lifecycle
Define collection, purpose, source, validation, access, storage, encryption needs, retention, correction, export, deletion, backup, restore, migration, and reconciliation for every material record and attachment.
Release and recovery stay usable
Use reviewed changes, isolated environments, repeatable builds, migration checks, staged release, observable health, alerts, rollback or forward repair, tested backups, dependency fallbacks, runbooks, and named incident ownership.

Engagement fit

Use custom application development when the workflow deserves a product boundary and an owner.

Good reason to begin

  • A repeated, valuable workflow has identifiable users, records, rules, exceptions, measures, and owners, but current tools cannot support it without material friction or risk.
  • The organization can provide real users, representative sanitized data, source-system owners, policy decisions, security and privacy context, and people accountable for acceptance and operation.
  • One narrow behavior can be released and evaluated end to end before the full application surface is committed.
  • The client is prepared to own source, access, environments, data, integrations, release, support, recovery, change, and eventual replacement after handover.

Resolve before beginning

  • The workflow, record owner, decision authority, expected result, or reason for a dedicated product is still disputed.
  • The request is primarily a predetermined technology, redesign, or feature list without observed users, current-state evidence, valid exceptions, and an operating measure.
  • The required access depends on broad shared credentials, unapproved sensitive data use, hidden cross-tenant behavior, client-side authorization, silent consequential changes, or no recoverable failure path.
  • No person or team can own product decisions, source systems, acceptance, release, incidents, data correction, support, recovery, and future change.

Source basis

Sources behind the control model.

  • 01

    OWASP Foundation

    Application Security Verification Standard 5.0.0

    The current stable ASVS provides a basis for specifying and verifying application technical security controls and recommends version-qualified requirement identifiers when requirements are used in contracts, reports, or tools.

  • 02

    National Institute of Standards and Technology

    Secure Software Development Framework Version 1.1

    The current final SSDF groups outcome-based practices around preparing an organization, protecting software, producing well-secured releases, and responding to vulnerabilities. NIST lists version 1.2 only as a draft.

[ WORKFLOW / SYSTEMS AUDIT ]
THE FIRST ENGAGEMENT

Start with one real workflow

A Systems Audit is the usual starting point. If the opportunity is already clear, we can move directly into a focused build.

Show Us the WorkflowStart with the free automation readiness checklist

OBSERVEQUANTIFYDECIDEBUILD