PRODUCT ENGINEERING / CONNECTED BUSINESS SYSTEMS
Omnistu Global - Everything ConnectedStart a project

Cloud engineering / Azure

Azure application development.
Identity, compute and handover.

Plan Azure applications around their users, data, runtime and operating team. Review the actual application, infrastructure, identity boundaries and recovery evidence rather than treating a cloud subscription as a finished system.

Discuss Azure requirements β†—
Contents Β· Azure

Start with the application and its operating constraints.

Azure work can include subscription foundations, application APIs and interfaces, managed compute, containers, databases, messaging, analytics, AI integration, delivery and migration. Existing Microsoft identity or licensing can influence the design; neither establishes that every workload belongs on Azure.

The original proposes reusable foundations and custom additions. Inspect the actual code, supported runtime, dependencies, licensing and acceptance evidence. A catalogue product, an infrastructure foundation and a custom enterprise application are different deliverables, even when they share tools.

Agree control of subscriptions, source and dependencies.

Name the subscription and tenant owners, billing contact, administrators, recovery routes and permitted delivery access. Separate application users from Azure resource operators and deployment identities. Decide who can revoke access, rotate credentials, authorize spending and recover each environment.

The receiving team needs application and infrastructure source, build instructions, dependency versions, data schemas and migrations, identity/network diagrams, release configuration, tests, backups and operating steps. Rights to Omnistu additions, inherited code, open-source packages, commercial components, media and third-party integrations need separate written review. A source archive alone is not proof of unrestricted ownership or an independently rebuildable application.

Application catalogue scope is not an Azure foundation.

These names describe comparison-style product categories in the supplied material. They do not establish affiliation, use of another company’s stack, an installed Azure implementation or a working demonstration. Inspect the selected base and verify each claimed feature before treating it as included.

Choose a provider from requirements, not brand stereotypes.

Use equivalent failure, security, traffic, data-transfer, support and recovery assumptions in written comparisons. Ask for the resource assumptions and exclusions behind a quote rather than publishing universal cost or performance rankings.

Six questions before choosing Azure work.

What does the work include?

List application interfaces, APIs, compute, databases, identity, private connectivity, observability, delivery, migration and handover. State which existing components remain and which are replaced.

Which compute mode fits?

Compare App Service, Container Apps, Functions and AKS against runtime, request/event duration, background work, state, scaling, networking and operator requirements. A preferred framework does not settle that choice.

What makes up the operating bill?

Inventory compute capacity, idle/minimum instances, databases, storage, network transfer, gateways, logs, AI usage, backup and support. Obtain a current estimate for the actual configuration.

How will migration work?

Assess source servers, application behaviour, SQL compatibility, files, jobs, identity, callbacks and network dependencies. Rehearse data conversion, cutover validation and recovery after new writes.

When does another provider fit better?

Compare the required services, current estate, licenses, regulations and receiving team. Include the cost and risk of staying where the application already runs.

Who controls the result?

Confirm subscription/tenant access, billing, source and component rights, data export, administrative recovery and deployment credentials in the agreement. None follows automatically from using Azure.

Keep application structure, compute and telemetry distinct.

. NET Clean Architecture and CQRS

Separate domain rules, use cases and infrastructure where that helps change and testing. CQRS can separate write and read concerns, but adds design choices around consistency, authorization, idempotency and projection recovery. It is not mandatory for every . NET application or proof a module can be reused unchanged.

App Service, Container Apps and AKS

Map stateless request handling, event consumers, background work and state to supported runtime modes. App Service plans, Container Apps revisions and Kubernetes deployments have different scaling, health and release controls. AKS HPA settings do not configure App Service scaling.

Azure Monitor and Application Insights

Define request/dependency traces, failure and latency distributions, capacity signals and business invariants. Instrument code, correlate releases, minimize private data and test alert delivery. Installing an agent does not establish a useful on-call process or complete tracing.

The Bicep sample declares a partial App Service setup.

The example main.bicep uses the resource group location, an appName and a runtime parameter. It declares a Linux P1v3 App Service plan with capacity three and zoneRedundant enabled, a standard Key Vault with RBAC and purge protection, a system-assigned application identity, and a vault-scoped Key Vault Secrets User assignment.

The example is retained for review, not executed here. Its API versions identify the recorded resource definitions; check current schema, supported configuration and the resulting plan before implementation.

Technical example

Source sample, not an installed backend or verified deployment. The limitations above apply.

// main.bicep - an App Service web app that reads its secrets through its own identity
// Deploy: az deployment group create -g rg-prod -f main.bicep -p appName=orders-api runtime='DOTNETCORE|<version>'
param location string = resourceGroup().location
param appName string
param runtime string

// Built-in role: Key Vault Secrets User
var secretsUserRole = subscriptionResourceId('Microsoft.Authorization/roleDefinitions', '4633458b-17de-408a-b874-0445c86b69e6')

resource plan 'Microsoft.Web/serverfarms@2023-12-01' = {
  name: 'plan-${appName}'
  location: location
  kind: 'linux'
  sku: { name: 'P1v3', capacity: 3 }
  properties: { reserved: true, zoneRedundant: true }
}

resource vault 'Microsoft.KeyVault/vaults@2023-07-01' = {
  name: 'kv-${appName}'
  location: location
  properties: {
    tenantId: subscription().tenantId
    sku: { family: 'A', name: 'standard' }
    enableRbacAuthorization: true
    enablePurgeProtection: true
  }
}

resource app 'Microsoft.Web/sites@2023-12-01' = {
  name: appName
  location: location
  identity: { type: 'SystemAssigned' }
  properties: {
    serverFarmId: plan.id
    httpsOnly: true
    siteConfig: {
      linuxFxVersion: runtime
      minTlsVersion: '1.2'
      ftpsState: 'Disabled'
      healthCheckPath: '/healthz'
      appSettings: [
        {
          // Secret reference only; provisioning and resolution require verification
          name: 'ConnectionStrings__Orders'
          value: '@Microsoft.KeyVault(VaultName=${vault.name};SecretName=orders-db)'
        }
      ]
    }
  }
}

// Vault-scoped secret reads; review all effective permissions
resource readSecrets 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(vault.id, app.id, secretsUserRole)
  scope: vault
  properties: {
    roleDefinitionId: secretsUserRole
    principalId: app.identity.principalId
    principalType: 'ServicePrincipal'
  }
}

Resolve secrets through identity, then test rotation and reachability.

App Service Key Vault references use the application’s configured managed identity. Granting the identity access and providing a network route are separate requirements. A network-restricted vault may need outbound VNet integration, routing and private DNS appropriate to the plan; neither a vault name nor an RBAC grant creates that path.

Versionless references can follow a newer secret, but App Service caches reference values and normally refetches them within its documented refresh interval, currently up to twenty-four hours. A configuration change restarts the app and triggers refetch; an authenticated refresh operation is also available. This is not instantaneous rotation, and it must be coordinated with database credential validity and application connection pools.

Role or identity changes can take time to propagate. Test successful resolution and safe failure after deployment, restart and rotation. A managed identity token does not automatically create Azure SQL users or grant SQL permissions. Keep operator, deployer, application and human-user identities separate and inspect inherited access.

Compute features depend on the selected hosting mode.

App Service fits supported application runtimes and custom containers under its plan model. Slots, scale options, certificates and network capabilities depend on tier and configuration. A slot swap still needs application health, setting/secret boundaries, warm-up and compatible data changes.

Container Apps offers revision and event-driven scaling controls. Minimum replicas, ingress and HTTP/event rules affect whether a workload can scale to zero and wake again. A queue consumer without a working trigger or a process that assumes a permanent local worker needs explicit design. Review concurrency, startup, retries and persistent-state placement.

Functions hosting modes differ in runtime/container support, execution constraints, scaling and network features. Current Microsoft guidance recommends Flex Consumption for new serverless function apps and classifies the older Consumption plan as legacy. Select the supported mode from the actual task rather than repeating one universal timeout or price model.

AKS can be useful for workloads that need Kubernetes APIs or operational patterns. Review current managed/Automatic capabilities, supported versions, node and workload responsibility, access, upgrades, policy and cost. Kubernetes is not automatically required for traffic growth; a cluster also creates operating obligations.

Choose data services from transactions and recovery requirements.

Azure SQL, PostgreSQL, Cosmos DB, Blob Storage, cache and messaging address different records and access patterns. Describe transaction boundaries, partition keys, consistency, indexes, retention and data location before selecting services. Separate high availability, read scaling and recoverable backups.

Service Bus and Event Grid need event contracts, authentication, duplicate handling, retries, dead-letter ownership and replay controls. A payment, notification or external webhook may be delivered more than once or arrive out of order. Define which durable application record establishes the result.

Do not infer that managed services remove schema maintenance, connection planning or restore testing. Validate private connectivity, identity/database permissions, credentials, pool limits and degraded behaviour. Backups need a verified restore path and application-level checks, not a success badge alone.

Directory identity and application authorization are different layers.

Workforce identities, customer identities and application service principals have different tenant, feature and licensing contexts. Inspect the intended Entra workforce or External ID customer setup, supported authentication methods, recovery, consent and application registrations. An existing Microsoft 365 tenant does not settle every customer-login or Conditional Access requirement.

Define user roles and object-level authorization in the application. Resource RBAC, directory administration and application permissions are not interchangeable. Microsoft Graph permissions need the specific delegated/application scopes, consent and effective access required for the operation, not a broad assumption that sign-in permits reading directory or business data.

Plan account lifecycle, support impersonation controls, device/session handling and privileged-access review. Test denied cross-tenant and cross-role requests as well as successful sign-in. A valid token is not proof a user may act on a particular order, file or patient record.

Azure AI needs a data-flow and permission design.

Azure OpenAI and other Foundry model services are managed services, not automatically models running inside a customer’s private tenant network. Private endpoint and public-network settings, application identity, deployment type, feature choice and logging need explicit configuration and evidence.

Current documentation distinguishes geography, Global and DataZone processing choices. Review the selected model/deployment, processing location, storage, abuse monitoring, retention and optional features. A resource’s region is not a universal promise that all prompts, telemetry and integrations remain there.

Scope retrieval sources, document permissions, evaluation, unsupported-answer handling and human review for sensitive actions. Retrieved content and model output must not grant access or authorize external actions. An AI integration plan is not a live assistant, a verified answer-quality result or a substitute for application authorization.

Assess compatibility before deciding how to move.

Inventory servers, application versions, databases, scheduled jobs, files, identity, certificates, external allowlists and provider callbacks. Decide separately what to rehost, replatform or change. A move from SQL Server to SQL Managed Instance needs a supported-feature and workload assessment, including jobs and cross-database behaviour; resemblance to SQL Server is not full compatibility proof.

Rehearse transfer, replication/catch-up, downtime or write control, smoke checks and business reconciliation. Record stop criteria and the decision maker. After the new system accepts writes, switching DNS back can lose or split records unless reverse movement or reconciliation is designed.

The supplied German industrial-IoT example records more than three hundred and fifty sensors across four factories, existing SCADA/OPC UA and Siemens edge components, IoT Hub, Stream Analytics, Power BI and Entra-based access. Preserve that as an unverified scenario specification, not evidence of a named customer, measured latency, completed audit or deployed migration. The source’s timetable and outcome claims are not a current commitment.

Release controls must cover state as well as code.

Review Bicep/Terraform definitions, target subscription/region, permissions, replacements and deletions. Azure Resource Manager what-if predicts changes without applying them, but unresolved expressions, expansion limits and short-circuiting can leave resources unanalyzed. It is one review input, not proof a deployment is safe.

Choose build artifacts, approvals, staged rollout, health checks and stop conditions for the actual compute mode. Test a receiver rebuild with the intended identities and versions. Releasing an older binary does not undo an incompatible database migration or an external payment.

Define recovery objectives around meaningful user functions. Test detection, credentials, restore/replay, application configuration and business invariants. Zone redundancy, provider availability terms and backups address different failure classes; none establishes a complete continuity plan by itself.

Policy and evidence need a clearly scoped system.

Azure Policy evaluates configured resource state and can audit, deny or remediate supported conditions according to its effect and permissions. It does not replace RBAC grants, application authorization, threat modelling or a compliance assessment. A compliant policy result is limited to what the policy actually checks.

Scope encryption/key access, network boundaries, administrative recovery, dependency/image checks, application tests, logs, retention and incident ownership. Inspect exclusions, inherited policies and approved exceptions. A provider certification does not certify the application, staff practice or data use.

For United States workloads, choose regions and integration/data-flow controls from the actual requirement. A US resource location does not establish that all support, identity, telemetry or third-party processing occurs there. Source statements about offices, staffing, response intervals and headquarters remain unverified and are not adopted here.

Catalogue, custom and ongoing work are different engagements.

Catalogue application delivery

Inspect the chosen product, complete feature map, base provenance, licenses and gaps. Define branding, workflow changes, integrations, environments, migration and acceptance; never assume an Azure infrastructure foundation includes a catalogue application.

Custom Azure build

Specify application rules, integrations, identity, compute/data/network choices, migration and operating needs. Reusable foundations can be part of this work if compatible, but their presence does not settle ownership, fit or effort.

Ongoing Azure work

Agree an explicit backlog, access, release process, monitoring and incident boundaries, support availability, exclusions, notice terms and how responsibilities end. A retainer name is not unlimited support or authority to make paid changes.

The pricing area separately names a Cloud-Native Starter. Keep that distinct from catalogue delivery: obtain an itemized foundation scope rather than silently treating these labels as the same package.

Six gates need concrete evidence.

The supplied universal production-standard and clean-scan language is not proof these gates ran. Agree the evidence and pass conditions before work starts; these are checks to verify, not completed test claims.

The recorded stack is a set of choices, not a mandatory bundle.

Choose current supported versions and document what is actually included. Listing sixteen tools does not mean all sixteen are installed, licensed or needed in one application.

Five stages describe decisions, not a promised duration.

Brief and confidentiality

Describe users, records, current systems, constraints and authorized discovery. Agree confidentiality and necessary access before sharing sensitive source or data.

Scope and plan

Inspect any base and write the feature, integration, migration, infrastructure, acceptance and handover boundaries. Record dependencies, receiver responsibilities and the current quote.

Build and review

Review demonstrable slices with representative data. Keep issues and configuration differences visible; do not label a mock interaction as an installed cloud backend.

QA and acceptance

Run the agreed gates, review evidence and resolve or explicitly accept remaining defects. Security and restore work must match the actual deployment, not only a local branch.

Deploy and hand over

Use approved accounts and artifacts, verify user/operator paths and provide recovery information. Confirm billing ownership, access transfer/revocation and the agreed support boundaries.

The original distinguishes build effort from elapsed calendar time and external review. Preserve that dependency distinction without publishing fixed day counts or guaranteed launch dates.

Ask for an itemized quote and a separate operating estimate.

Catalogue adaptation, Cloud-Native Starter foundations, custom build and ongoing work have different boundaries. Ask for written inclusions, exclusions, dependencies, acceptance, change control, rights and support terms. Published examples are not an offer or a reliable quote for a new application.

Application complexity, integrations, data quality/volume, identity, private networking, regulated controls, multi-region recovery and migration change effort. Running costs include compute capacity, storage, databases, logs, transfer, gateways, backup, AI usage and licenses. Compare the same workload and recovery assumptions across options.

Azure Cost Management budgets monitor spending and alert; creating a budget does not itself stop all resources. Any automation to restrict or stop a service needs separately reviewed scope and consequences. Reservations, commitments and Azure Hybrid Benefit require current eligibility, license and financial approval, not assumed savings.

Keep the Marvel record and its lineage conflicts visible.

The supplied Marvel example is a content-and-commerce record, separate from the industrial-IoT migration scenario. It lists ASP, Azure, SQL, Java, jQuery and Bootstrap. These are recorded stack labels, not evidence of current versions, a verified client relationship, production traffic or a reusable foundation ready for delivery.

The record says there was no ready-made base, yet also says seventeen of twenty-one modules were reused and four were custom. It records three applications and consoles across development, staging and production, plus six integrations. The three-application count is distinct from the three environments. Keep both lineage statements and all scope counts as unverified specifications. Ask what was reused, from where, under which rights, what each module/environment/integration contains and what evidence the receiver can inspect.

The source also mentions Heineken and reviews concerning Maxx, ServerProGuard/MX Security and PAS. Those names and review snippets do not verify this Azure work, its outcomes or a current endorsement. No client identity, delivery count, award, review score or corporate-registration assertion is adopted as verified evidence here.

Verify evidence and write the promises into the agreement.

The source’s ownership, NDA, payment and acceptance promises need written scope and evidence. Inherited component licenses and third-party provider terms still apply.

Industry labels change the acceptance requirements.

Twelve practical questions to settle before implementation.

What counts as an Azure application?

An application that uses specifically configured Azure services. Name which interfaces, APIs, compute and data components are included, rather than assuming the cloud label defines a finished product.

Which languages and frameworks are supported?

Choose current supported . NET or other runtimes and framework versions from the workload and hosting mode. The recorded stack is not a promise that every historical runtime remains supported.

Can an existing application migrate?

Assess dependencies, compatibility, data, identity and provider integrations first. Rehost, replatform and refactor can be combined; acceptance and recovery need rehearsals.

Who owns the code and data?

Agree source/component rights, accounts, export, backups and administrative access in writing. Third-party licenses and service agreements do not disappear at handover.

Can you integrate Microsoft services?

Define the particular APIs, tenant, permissions, consent, licensing and user/data boundaries. Existing Microsoft identity is a starting condition, not permission for every integration.

How is the system secured?

Review the actual identity, application authorization, network, secret, dependency, logging and recovery design and test evidence. No cloud plan or single scan proves complete security.

Is a reusable base available?

Inspect the proposed base and its provenance, supported versions, tests and gaps. Catalogue apps, starter infrastructure and custom features are different scopes.

How long and how much?

Obtain a written scope review and itemized quote with dependencies, review responsibilities and acceptance. Do not infer a fixed calendar commitment or operating bill from an example.

How does ongoing support work?

Name availability, communication, incident ownership, maintenance, changes, exclusions and notice terms. Verify the current agreement rather than treating a source badge as a grant.

Are US projects supported?

Set region, data flows, collaboration requirements and actual contracting/support arrangements. Unverified office, staffing and response claims are not used as evidence.

Can AI features be added?

Scope model/deployment, data access, processing location, evaluation and action boundaries. Private endpoint settings and application permissions require verification.

What must handover prove?

A receiving team should be able to rebuild, deploy, operate, rotate access and recover the agreed system using supplied artifacts and authorized accounts. Record the acceptance evidence and remaining limits.

Primary references for technical qualification.

Official platform, framework and API documentation checked on 17 November 2026. These support the technical checks here, not Omnistu staffing, pricing, rights, delivery or client outcomes. Recheck installed versions and configuration before implementation.

Bring the domain, dependencies and receiving-team needs.

Describe the records, users, permitted actions, integrations, existing code and operating constraints. Agree base/custom boundaries, acceptance evidence, current quote and handover before implementation.

Discuss Azure requirements β†—