asish.comTechnical articles by Asish Punnose
Cloud architecture

From inventory to cutover with Azure Catalyst

A worked migration plan for a three-tier application, from the first discovery scan to the moment the team can safely switch traffic.
Asish Punnose · 20 November 2026

What changed for Azure Migrate?

Microsoft’s overview now calls the service Azure Catalyst, formerly Azure Migrate. It brings discovery, assessment and migration into one project. The classic experience lacks the newer application and cross-workload views. The preview Catalyst agent can help interpret project data and explore planning options. Migration execution takes place in the portal.

Start with one transaction

Imagine a distributor running an ASP.NET order portal on VMware. The web tier writes orders to SQL Server. A Windows service generates a dispatch file at midnight. The business owner defines success as an order arriving once in the warehouse before the morning shift. That definition immediately puts the file share, the service account and the scheduled job inside the migration boundary. An inventory listing only the web and database servers would miss the most important acceptance test.

Choose the right discovery evidence

The appliance collects configuration and performance observations over time. The collector offers snapshot discovery for restricted environments, and an inventory import can establish an initial list. For the distributor, a spreadsheet is enough to assign owners and identify candidate servers. Sizing the SQL tier needs a representative workload window. Include the dispatch run and month-end processing. Mark any period without observations so the estimate carries an explicit assumption.

Turn assessment into a target decision

Assess readiness, sizing, estimated running cost and network dependencies. SQL Server on an Azure VM, Azure SQL Managed Instance and Azure SQL Database are possible SQL assessment targets. For the example, list the database features, jobs and external file operations the application uses. Rehearse those operations on the candidate platform. Moving the web tier to App Service could simplify host maintenance, but the background Windows service still needs an execution environment and a way to reach the share.

Build a business case the owner can challenge

Use the current estate as the baseline. Separate recurring hosting costs from migration engineering, temporary replication and the period when both environments run. For an Australian business case, express each scenario in AUD and record the Azure region, licence assumptions, utilisation window and exchange-rate date where relevant. Run a second scenario with a month-end peak and a longer coexistence period. If the preferred target changes, the team knows which assumptions to validate before committing.

Design the migration wave around the dependency

Microsoft documents different migration mechanisms for VMware, Hyper-V and physical servers. Choose the supported path for each source. In this example, place the portal, database and dispatch service in one coordinated wave even if their replication methods differ. Give the warehouse integration its own test owner. If the destination cannot receive rehearsal files, arrange a test inbox and compare its output with a known-good dispatch file.

Rehearse the point of no return

Run a rehearsal in an isolated environment. Create an order, amend its quantity, cancel a second order and trigger dispatch. Check order identifiers, totals, file contents and duplicate handling. Time the final synchronisation and record who can stop the cutover. Before production writes begin, returning traffic to the source may be straightforward. After the target accepts a new order, rollback also needs a tested way to reconcile that order. Agree on that decision with the business owner before the change window.

Close the migration with evidence

After switching traffic, reconcile the first real dispatch against the orders accepted in Azure. Check monitoring, backup recovery and on-call ownership. Retain the source for the agreed recovery period and record the conditions for decommissioning it. For this workload, the migration is complete when the warehouse can process the order and the operations team can recover it. A running VM is only one milestone.

Microsoft Learn · Azure Catalyst overview

Cloud architecture

Designing a publishing workflow with D1 and R2

A failed upload should never leave readers looking at half a release. Give each revision an immutable body and make publication a single database decision.
Asish Punnose · 20 November 2026

Model the release

Consider a publisher with a homepage and ten Markdown stories. An editor corrects one story while another editor previews a redesign. If both operations overwrite a file called latest.md, the preview can change beneath the reviewer. Give every saved body an immutable object key in R2. In D1, keep a revision record that identifies its project, parent revision and object key. D1 supplies the relational catalogue. R2 holds the article bodies and artwork.

Switch the pointer

Write the objects first and verify they can be read. Then change the published revision using a conditional update that matches both project ID and the previously published revision. Check the affected row count. A zero means another editor has published in the meantime. Present that conflict for review. A failed object upload leaves the previous release visible. A failed database update may leave an unused object, which a later cleanup can reclaim once references have been checked.

Prove that rollback works

Build the homepage and article links from the same revision manifest. Include its identifier in cache keys for immutable content and give the public entry point an explicit freshness policy. In staging, interrupt a release just after its final upload. Open a story from the public homepage, then from the draft preview. Each should resolve within its own revision. Finally, restore the previous published pointer and measure how long readers take to see it. That measurement tells you what rollback actually means to your users.

Cloudflare D1 documentation

Development

Building a Rust MCP tool on Cloudflare Workers

Start with one read-only tool and follow a request from its JSON arguments to the revision it returns.
Asish Punnose · 20 November 2026

Make one operation useful

For a publishing platform, a good first tool is get_revision. Give it a project ID and a revision ID. Return a small manifest with the revision title, page paths and asset references. The caller can use that manifest to decide what to edit next. Keeping the response small also makes the operation practical when a project contains large images.

Draw the runtime boundary

Cloudflare’s Rust tooling compiles Worker code to WebAssembly. Keep argument parsing and manifest validation in ordinary Rust functions. Put the platform-specific request handling, storage bindings and response conversion at the edge of the crate. Treat MCP as its own protocol layer. A JSON endpoint becomes useful to an MCP client when the server also handles the appropriate lifecycle, tool discovery and tool calls for its supported protocol version.

Test the contract before adding writes

Start with a fixture containing two projects whose revision names coincide. Derive identity from the authenticated request and constrain the lookup by authorised project. Exercise a missing revision, malformed arguments and an unavailable storage binding. Return errors the client can distinguish without exposing internal object keys or credentials. Once that path works, design save_revision separately with an expected parent revision and an idempotency key. Retrying a client call should produce one logical edit.

Cloudflare’s Rust Workers guide

AI engineering

Finding the AI workflows your organisation actually runs

A list of model endpoints tells you little about who relies on their output. Connect technical evidence to the business decision it supports.
Asish Punnose · 20 November 2026

Begin with one business decision

Take invoice extraction. A service reads a supplier document, predicts fields and places a draft in a review queue. The inventory entry should identify who owns that workflow, what data enters it, where the result goes and who can release a payment. Two applications using the same model may need different controls because their outputs trigger different actions.

Record what each source can establish

Use authorised deployment inventories to identify configured services and approved gateway metadata to identify recent calls. A deployed resource shows availability. A recent call shows activity. Neither establishes the business purpose. Ask the application owner to confirm it. Record source, observation time and confidence separately. Keep prompt text and customer documents out of discovery records when metadata answers the question.

Turn the register into a review queue

Link each workflow to an owner, a review date and a small evaluation set. For invoice extraction, include a credit note, a blurred total and two suppliers with similar names. Record which errors require manual review. When discovery finds a new model version or a changed destination, raise a review item with the before-and-after evidence. Measure progress by the number of active workflows with a confirmed owner and a tested decision boundary. NIST’s AI RMF provides a broader framework for organising that work.

NIST AI Risk Management Framework

HomeArchitectureCloudSecurityAI engineeringDatabasesDevelopment
Cloud architecture

What changes when your API moves to the edge?

Moving request handling closer to users changes latency, caching and data locality. Trace the full path to the database before choosing where to run your API.
Asish Punnose

Follow a catalogue request

A Brisbane reader opens a catalogue served from Sydney. An edge handler can return a cached public description nearby. If it then makes three sequential calls to Sydney for price, inventory and delivery, those round trips still sit on the critical path.

Separate the reads

Give public descriptions their own cache policy. Fetch customer-specific prices through an authenticated route. Keep stock reservations close to the database transaction that decides whether a unit is available.

Measure the whole journey

Compare warm and cold cache requests from the same client region. Record time to first byte, origin trips and the age of the data returned. A faster median can hide slower checkout requests.

HomeArchitectureCloudSecurityAI engineeringDatabasesDevelopment
Databases

Inside a PostgreSQL query plan

Compare estimated and actual row counts to see where the planner misjudged the work. Check buffers before deciding whether an index will help.
Asish Punnose

Start with a question

Suppose the latest 20 orders for one tenant take a second to load. First capture the exact filter, sort order and representative tenant size. A plan for a tenant with three orders can look quite different from one with three million.

Read from the scans upwards

On a representative test database run EXPLAIN (ANALYZE, BUFFERS) on the SELECT. Find the scan that feeds the sort. Compare estimated and actual rows. For repeated nodes, actual times and rows are averages per loop. ANALYZE executes the statement.

Test one change

For a filter on tenant_id ordered by created_at, test a composite index beginning with tenant_id then created_at. Compare rows visited and buffer activity as well as elapsed time. Include the additional write cost in the decision.

HomeArchitectureCloudSecurityAI engineeringDatabasesDevelopment
API engineering

Where tokenisation fits in an API

Identify which sensitive fields need substitutes, who can resolve them and how the mapping is protected.
Asish Punnose

Choose the boundary

Consider a support system that needs to recognise a returning customer using a sensitive membership number. At intake, a restricted service can exchange the number for an opaque reference. Downstream systems can associate cases with the reference.

Design the return journey

List the few workflows that require the original number. Give each a specific permission to resolve the token, scope the lookup to the tenant and record the purpose of the lookup. Possession of a reference alone should never authorise disclosure.

Follow a failed request

Send synthetic test data through validation failures, retries and error reporting. Inspect logs and dead-letter queues for the original value. A tokenised database offers little protection if the intake payload survives in telemetry.

HomeArchitectureCloudSecurityAI engineeringDatabasesDevelopment
Architecture

Tracing requests across services without the guesswork

Carry a trace identifier across service boundaries and inspect the spans that account for the longest delays.
Asish Punnose

Start at the slow request

A checkout request takes 1.8 seconds. The gateway log reports success and the database dashboard looks normal. Reconstruct that single request before averaging it into a dashboard.

Keep the context

Propagate trace context from the gateway to the orders service. Include it in queue metadata so a consumer can associate later work with the originating request. Record operation names and durations without customer payloads.

Read the critical path

Two parallel calls lasting 300 milliseconds each can add roughly 300 milliseconds to elapsed time. Three sequential retries can cost far more. Inspect the waterfall, change the slow dependency or retry policy, then compare traces under similar load.

HomeArchitectureCloudSecurityAI engineeringDatabasesDevelopment
Cloud

Using private endpoints to lock down cloud access

Map private DNS resolution and network routes alongside the endpoint so clients reach the intended service.
Asish Punnose

Start at the client

Imagine an internal API reading a blob through its usual storage hostname. A private endpoint gives the target service a private address on your virtual network. The API still needs the correct name resolution, network reachability and data permissions.

Walk the route

Resolve the storage hostname inside the API runtime. Check that it resolves to the intended private address and that the endpoint targets the required storage subresource. Test an authorised read using the workload identity.

Verify both access paths

Review public network access separately. Test the same operation from an external network using an appropriately controlled test identity. Keep the two results together so reviewers can see which path is allowed and why.

HomeArchitectureCloudSecurityAI engineeringDatabasesDevelopment
Security

Designing for tenant isolation in multi-tenant systems

Derive tenant scope from authenticated identity and enforce it at every data access boundary.
Asish Punnose

Trace one invoice

Imagine two tenants each have an invoice numbered 42. A lookup by invoice number alone is ambiguous. Resolve the authenticated user's membership, establish the active tenant, then carry that scope through every read and write.

Check secondary paths

Include tenant identity in cache keys, export jobs and object paths. A correctly scoped database query can still leak a report if two tenants share the same cached filename. Apply equivalent checks when generating download links.

Make isolation testable

Create two test tenants with matching invoice numbers and different totals. Exercise list, detail, update and export operations as each tenant. Assert that attempted cross-tenant changes leave both records intact.

HomeArchitectureCloudSecurityAI engineeringDatabasesDevelopment
Development

Using Rust for infrastructure tools that last

Design command-line tools around explicit inputs, clear errors and predictable exit codes.
Asish Punnose

Design the command first

For an inventory tool, separate the human-readable report from structured output consumed by automation. Write a sample invocation and its expected JSON before choosing crates. Treat field names and exit codes as part of the interface.

Isolate the core

Parse arguments at the boundary. Pass typed configuration into a function that transforms inventory records. Keep network calls and terminal formatting separate so the transformation can run against a small local fixture.

Plan for partial failure

If one subscription is unreachable, identify it in the result and return a documented status. Test empty input, expired credentials and interrupted output. A scheduled job should be able to distinguish an empty inventory from an incomplete scan.

HomeArchitectureCloudSecurityAI engineeringDatabasesDevelopment
Cloud

When to reach for Azure Functions – and when not to

Evaluate event triggers, execution duration and startup latency against your workload.
Asish Punnose

Model the event

A receipt processor begins when a document arrives. It needs a document identifier, a retry policy and a durable record of completion. A queue-triggered function is a candidate when each unit of work can be handled independently.

Select the hosting plan

Estimate execution duration, concurrency, memory and network requirements before selecting a Functions hosting option. Scaling behaviour and supported capabilities vary by plan. Measure the first request after idle as well as steady traffic.

Test a duplicate

Deliver the same document event twice. Use a unique processing key and record the committed result so a retry cannot create a second payable. For a long-running worker with stable utilisation, compare the operational cost of a continuously running service.

HomeArchitectureCloudSecurityAI engineeringDatabasesDevelopment
AI engineering

Building an AI governance baseline that works in practice

Record ownership, evaluation criteria and review decisions for each model-backed workflow.
Asish Punnose

Inventory one workflow

Start with a model that extracts invoice fields. Record the business owner, intended users, input data, output destination and who can approve a payment. A wrong total and an incorrect supplier identifier have different consequences.

Build a small evaluation set

Include ordinary invoices, credit notes, blurred scans and examples with several tax rates. Label expected values and measure errors by field. Set an explicit rule for which results require human review.

Make changes reviewable

Version the model configuration, prompt and evaluation set together. Before rollout, compare the candidate with the current version on identical inputs. Record the decision, responsible reviewer and rollback procedure.

HomeArchitectureCloudSecurityAI engineeringDatabasesDevelopment
Development

What Cloudflare Workers makes easy for API teams

Place lightweight request handling close to callers and measure the round trip to your origin.
Asish Punnose

Choose a narrow edge task

A public documentation API can handle redirects, normalise paths and serve cacheable responses near readers. A Worker gives the team a place to perform that request handling before contacting the origin.

Count the origin calls

Draw the path for a cache miss. If a request needs authentication, metadata and content from one distant region, combine independent work where practical. Measure origin latency separately from handler execution time.

Ship with a fallback

Start with one public route. Preserve query parameters that affect the representation, define freshness explicitly and test origin failures. Compare cache hits, error rates and end-to-end latency before moving another route.