Connect the programming allocation to a business rule.
An application milestone needs an observable result as well as an estimate. Use a conflicting amendment to agree the record boundary, recovery action and receiving evidence.
Protect the order that was actually saved
Two people can open the same work order before either submits a change. Ask the implementation to check the saved revision when accepting an amendment. A stale editor should see enough information to decide what to do next without silently replacing the other person’s quantity.
Make the recovery action deliberate
In RV31, Editor B sees the original quantity, the attempted quantity and the current saved quantity together. Loading the current order explicitly replaces B’s draft and refreshes its base revision. That action is separate from submitting a new amendment, so the receiving team can inspect both decisions.
Retain evidence beyond a success message
Keep the actor, work-order ID, base revision, attempted quantity and resulting saved state in the acceptance trace. Check the two unaffected work orders as well. The quoted milestone should identify the code, deployment instructions and application-specific tests that accompany the change.
Show the receiving team what happens when two editors save.
RV31 is an order amendment demo with three synthetic work orders and two editor snapshots. Save the first change, inspect the second editor’s conflict, then load the current order before submitting a new amendment.
Use the working case to prepare your quotation brief.
Attach a concrete record conflict and the expected recovery behaviour to the project discussion.
Replay WO-721 with two editor snapshots
Start with the overview, save Editor A’s quantity 10 and attempt Editor B’s quantity 12 from its original snapshot. Inspect the conflict before loading current into B. Submit 12 again from the refreshed snapshot and export the trace for the brief.
Run the order amendment demoChoose a provider-appropriate concurrency contract
Microsoft’s EF Core documentation describes concurrency tokens, conflict handling and the original, attempted and database values available to a resolution flow. Its SQL Server rowversion example is provider-specific. Use the reference with the application’s actual persistence provider when commissioning the change.
Read Microsoft’s concurrency conflict referenceKeep a DNN portal engagement identifiable
If the wider programme also includes a DNN installation, keep its portal, page and module work within the DNN engagement brief. General application amendments and a portal permission change have different acceptance records even when both use the Microsoft stack.
Discuss a dedicated DNN development engagementScope a Kentico website backlog separately
For an existing Kentico website, identify the installed CMS and its content or enquiry-form changes. Give that work its own platform inventory and receiving owner alongside the custom application milestone.
Commission a Kentico development engagementSix decisions for the ASP.NET engagement
Start with one amendment case, then extend the contracted acceptance scope to the application’s permissions, data and deployment environment.
Identify the framework and operating environment
Provide the actual .NET and ASP.NET releases, project structure, database provider, hosting arrangement and build instructions. Distinguish a .NET Framework application from ASP.NET Core before estimating changes. Confirm source ownership, third-party packages and the staging access process.
Define the record and the permitted amendment
Name the business action, record key, editable fields and user who may submit it. For RV31, WO-721 begins at quantity 8 and revision 12; WO-722 and WO-723 remain at 4 and 6. Agree validation, authorization and the point at which an amendment becomes saved.
Specify the conflict and recovery contract
Record the version read by each editor and decide how a stale submission is handled. RV31 blocks a second save against revision 12 after Editor A has created revision 13. The conflict view retains B’s attempted 12 alongside the original 8 and saved 10; loading current is an explicit next action.
Implement against the reviewed data provider
Choose and configure the concurrency mechanism for the actual persistence layer. Microsoft documents EF Core concurrency tokens and SQL Server-specific rowversion behaviour. Include endpoint responses, validation and permission checks in the application contract rather than assuming the demo’s readable revision number is a database type.
Rehearse the accepted amendment sequence
Have the receiving owner run the two-editor case in staging with synthetic records. A saves 10, stale B is blocked, B loads revision 13 and submits 12 to produce revision 14. Confirm the 22-unit total and the unchanged 4- and 6-unit records, then add installation-specific parallel-session and access checks.
Deliver the code and operating handover
Agree the release window, deployment owner, backup and recovery procedure, smoke checks and support contact. Retain the amended source, environment instructions and accepted test evidence. Separate the development allocation from any continuing maintenance or out-of-hours response commitment in the quotation.
Supply the information that determines the estimate
- State the allocation period, highest-priority milestone, target release window and communication overlap. Ask the quotation to name the billing basis, scope-change process and acceptance owner.
- Provide a sanitized project structure, framework and package inventory, database provider and build instructions. Arrange approved source and staging access separately from the initial enquiry; keep credentials and personal records out of the contact form.
- Describe the business transaction and its authorization boundary. Include field limits, record ownership, deletion behaviour and what a user should see after validation or a stale save.
- Identify dependencies outside the application team: identity administration, hosting, licensed components and partner endpoints. Name the party responsible for each access grant or vendor-side change.
Price integration, migration and ongoing operation explicitly
- For an upgrade, review the existing and target runtime, packages, hosting and persistence behaviour before choosing the migration path. Rehearse against a recoverable staging copy and agree data preservation and rollback responsibilities.
- For an API or external service, inspect its real contract before estimating authentication, mapping, retries and failure handling. An application integration needs its own authorized destination-side acceptance evidence.
- Extend the work-order case to your actual transaction boundaries: multi-field rules, deleted records, permission changes, simultaneous requests and any downstream side effects. Confirm which outcomes require a transaction or an additional idempotency rule.
- Agree who operates the application after release, how incidents are raised and what update or maintenance work is included. Confirm monitoring ownership, support hours and commercial terms for future backlog items.
Six records that make an amendment inspectable
RV31 gives the application owner and developer a small shared acceptance model.
| Record | Example inputs | Required output and control |
|---|---|---|
| Work-order identity | WO-721 / WO-722 / WO-723 | Apply the amendment to its named record and check the other two records stay unchanged. |
| Saved state | WO-721 quantity 8 / revision 12 | Compare the submitted base revision with the currently saved revision. |
| Editor snapshot | A and B both open revision 12 | Retain the quantity each editor originally read independently of subsequent saves. |
| Amendment attempt | A proposes 10 / B proposes 12 | Validate whole quantities from 1 to 50 and reject a stale base without an overwrite. |
| Resolution decision | Original 8 / attempted 12 / saved 10 | Loading current explicitly replaces B’s draft and refreshes its base to revision 13. |
| Acceptance trace | A saved r13 / B conflict / B refreshed / B saved r14 | Retain the resulting 22-unit total and the unchanged 4- and 6-unit records. |
Open both editor snapshots at revision 12 with WO-721 quantity 8. Save A’s 10: the saved revision becomes 13 and the three-order total is 20. Attempt B’s 12 against revision 12: the conflict preserves saved quantity 10 and total 20. Load current into B, replacing its draft with 10 at revision 13. Enter 12 and save again: revision 14, total 22. Saving the same quantity again records an unchanged result without a revision bump. Quantity 0 is rejected without changing the saved state. Export the trace, then reset to begin a separate exercise.
Ask providers to quote the same amendment boundary.
Use the record sequence to make the implementation, recovery and handover responsibilities comparable.
| Option | Published focus | Ask in your demo |
|---|---|---|
| SCAND | ASP.NET application development, legacy support and flexible engagement models. | Which deliverable proves a stale editor cannot replace the saved amendment, and how is the conflict resolved? |
| Plus8Soft | ASP.NET developer engagements covering applications, APIs and cloud delivery. | How does the quoted allocation cover original, attempted and saved values as well as the final release? |
| Innostax | Custom ASP.NET development with fixed-scope and hourly enquiry options. | Who accepts the two-editor sequence and checks the independent records before the milestone is handed over? |
Give each provider the same three records, the two snapshots and the intended recovery action. Ask for a quote covering the actual framework, persistence provider, API response policy and acceptance evidence. The RV31 trace makes the expected outcome replayable; the staging scope should add the application’s real authorization and transaction boundaries.
Category reference: Microsoft primary reference: EF Core concurrency tokens and conflict resolution. Microsoft reference last updated 5 July 2023, accessed 2 November 2026. Agree the provider-specific implementation and application response contract during the technical review.
Connect the application change to the wider project.
Keep the commissioned milestone, receiving team and integration boundaries visible alongside related marketplace engagements.
Explore Codeblix marketplace development engagementsAgree the programming engagement before allocation
Use the consultation to settle the application scope, commercial arrangement and receiving evidence.
What should I send when requesting dedicated ASP.NET programmers?
Describe the application, installed framework and database provider, the highest-priority change and the allocation you need. Include the release window, source ownership and acceptance owner. A representative business action and one failure case help Codeblix review the work before confirming capacity, responsibilities and a quotation.
Can the engagement cover an existing application rather than a new build?
Bring the current project structure, supported build instructions, packages and hosting constraints. Define the change to be delivered and the behaviour that must be preserved. The quotation can then separate investigation, implementation, regression checks and release assistance around that application.
How is the development allocation priced?
The estimate follows the reviewed backlog, framework constraints, dependencies and requested delivery responsibilities. Ask for the billing basis, allocation period, start conditions and treatment of additional requests in writing. Include deployment assistance and ongoing support explicitly when they form part of the engagement.
What can our acceptance team do in the order amendment demo?
Save a change from one editor, attempt a stale change from another, inspect the conflict and load the current record before submitting again. The demo retains the actor and revision sequence, rejects invalid quantities and checks the three-order total. Its export gives your team a concrete case to attach to the brief.
How should the application handle a conflicting save?
Agree the response and recovery path for the actual business action. Options depend on the record and the application contract. RV31 blocks the stale amendment and requires an explicit refresh before a new attempt; your implementation should also define permission checks, deleted records and any field-level resolution rules.
Can a framework upgrade or database change be included?
Identify the current and target environments and the data that must be retained. Scope package compatibility, build changes and persistence behaviour before estimating the migration. Agree a recoverable staging rehearsal, acceptance cases and the person responsible for the production release.
How will an external API or identity service be scoped?
Name the service owner, approved interface and permitted data. Review authentication, mapping, rejected responses and destination-side responsibilities before agreeing the integration. Include authorized test access and a specific acceptance milestone rather than assuming an existing connector.
What belongs in the final handover?
Request the changed source, build and deployment instructions, dependency inventory and accepted application cases. Retain the conflict and recovery evidence with the release record. Agree the operating contact, maintenance responsibilities and commercial route for later support or backlog work.