ASP.NET Core Applications|Business Web Platforms|Secure HTTP Services
When your customers or staff complete real business work in a browser, the application behind it has to keep records correct, enforce who may do what and remain supportable after launch. Sphere 10 builds customer portals, staff workspaces and business integrations on ASP.NET Core and C#, backed by SQL Server or PostgreSQL, and delivers them ready to host.
What we build
Shape the application around the task. A public information page, a screen where staff edit many records and a system-to-system integration need different designs. We choose the page style and interfaces to suit the work each one performs.
Secure sign-in and access. We connect sign-in to your identity provider, including Microsoft Entra ID. The server checks permission and business rules on every request, whatever the browser shows.
Protect your records. Related changes are saved together. A duplicate submission, or two people editing the same record, produces a clear outcome instead of quietly lost data.
Make it supportable. Logging and health checks let your support staff trace a failed action in the browser to the server operation that handled it.
Illustration of a request crossing validation, application and persistence boundaries.
What you receive
Source code with build instructions and database setup.
A reproducible deployment package for Windows (IIS) or Linux hosting.
A documented interface for the other systems that call the application.
Release verification steps and a rollback sequence.
How we engage
Show us the action a user must complete and the record that proves it happened. That gives the design a concrete acceptance target. At acceptance we demonstrate complete workflows with valid, invalid and unauthorised requests, session expiry, phone layouts and your expected data volume, on the real hosting arrangement.
Technologies & Integration
ASP.NET Core and OpenAPI — Build controller or Minimal API contracts, request/response schemas, validation outcomes and integration documentation.
OpenID Connect authentication — Configure code-flow sign-in, protected session settings and identity-provider callbacks alongside API authorization.
EF Core transactions — Own database units of work, concurrency behaviour and migrations; select NHibernate where its mappings suit the application.
Kestrel and Nginx hosting — Deliver the process manager, reverse proxy, forwarding configuration and TLS-aware application host.
C# Web Interfaces|Business Workspaces|Typed Data Workflows
Staff who work with records all day need screens that are quick to use and predictable when something goes wrong. Sphere 10 builds Blazor applications in C# for administration workspaces, guided processes, dashboards and complex editing screens, with clear behaviour when a save fails, a connection drops or a colleague changes the same record.
What we build
Operator workspaces. Menus, screens, dialogs and wizards are organised around what each operator is responsible for. Imports, exports and other long operations show progress and can be cancelled.
Predictable editing. Every editable record has defined draft, save, cancel and conflict behaviour. When two people change the same record, the editor keeps the draft and explains the conflict.
Screens that cope with volume. Grids and lookups search, sort and page on the server, so they stay usable with realistic amounts of data.
The right hosting model. Blazor can run on the server, in the browser or inside an installed application. We choose from your connectivity, response-time and data-access needs.
A maintained starting point. Our Sphere10 Framework supplies Blazor data grids, validated editing, dialogs and wizards. Where you prefer Telerik UI for Blazor, we integrate it the same way.
Illustration of a Blazor editing workspace keeping transient state separate from persistence.
What you receive
Source components, theme configuration and deployment instructions.
Reusable components your team can extend.
The scenarios and test data used to verify the workspace.
How we engage
Tell us when a value is a draft, when a record counts as saved and what should happen if the connection disappears. Those answers shape the design. Acceptance covers editing and cancelling, failed saves, permission changes, narrow screens and a disconnected or expired session, measured on real data-heavy screens.
Technologies & Integration
Blazor render modes — Select server, WebAssembly, Auto or static rendering and define prerendering and interactive-state boundaries.
Blazor Hybrid — Reuse suitable Razor components through a native .NET host and WebView with platform-specific service implementations.
Telerik UI for Blazor — Integrate selected data grids, forms and export components with server-side query, validation and permission contracts.
Playwright for .NET — Exercise sign-in, navigation, record editing, validation and responsive browser behaviour against the delivered application.
Notion as Your CMS|Owned Website Output|Custom Themes
Your team can run the whole website from Notion without learning a separate content management system. Sphere 10 builds the site with Local Notion, our own .NET publishing application, which turns your Notion pages, databases and media into a consistent public website whose source, theme and generated output you own.
What we build
An authoring structure that matches the site. Pages, sections, galleries, menus, header and footer each have a clear home in Notion. Page addresses and breadcrumbs follow from your titles and hierarchy.
A custom theme. Editors write with ordinary Notion headings, paragraphs, images, lists and columns. Colours, typography, link behaviour and phone layout live in a versioned theme, so the design stays consistent across the site.
Shared navigation and footers. Contact details or a menu destination are updated once and appear everywhere.
A publication process you can inspect. Content and original media are downloaded, rendered, previewed and published as separate, checked stages. Each release keeps the material needed to roll back.
Illustration of native authoring, rendering and served verification as distinct stages.
What you receive
A complete website for your services, products, articles, documentation or resource library.
The theme sources and hosting configuration.
Authoring conventions for your editors, with focused Notion views.
An operating guide for publishing and diagnosing an update that did not arrive.
How we engage
Bring representative articles, service offerings, product pages and navigation. We settle the structure and theme on those before content is multiplied. At acceptance an editor updates real content and we follow that change through preview to the hosted page, checking links, breadcrumbs, media, keyboard focus and phone layouts.
Technologies & Integration
Notion data sources and blocks — Model CMS records and native ancestry while retaining original Page and block identity through publication.
Notion request limits — Implement paginated, rate-aware source reads and bounded retries with explicit failure and refresh evidence.
HTTP caching — Coordinate cache policy, validators and asset generations so page content and media resolve to the intended release.
Cloudflare cache control — Define origin/CDN behaviour and verify served pages and assets after a deployment or cache change.
Browser Applications|Typed API Contracts|Responsive Workflows
Dashboards, customer portals and interactive workflows often need the responsiveness of an application that runs in the browser. Sphere 10 builds single-page applications with React and TypeScript, Angular, Vue or Blazor WebAssembly, connected to ASP.NET Core services that keep authority over permissions, business rules and your records.
What we build
Navigation that behaves like the web. Links can be copied and shared, the back button works, and unsaved work is handled deliberately when a user moves away.
Defined behaviour when things go wrong. Slow responses, expired sessions, interrupted connections and concurrent edits each have a designed outcome. An older response never overwrites a newer selection.
Rules enforced on the server. A hidden or disabled button is a convenience for the user. The service checks identity, record access and the business rule again for every operation.
Releases you can operate. The browser application and its service are versioned together, with caching configured and monitoring that links a user's task to the work behind it.
Illustration of browser drafts and navigation separated from authoritative application records.
What you receive
The client source code and a documented, versioned service interface.
Responsive layouts with keyboard navigation and accessible feedback for errors.
A build pipeline and regression scenarios.
Documentation for environment settings, caching and recovery from a failed deployment.
How we engage
Bring the task flow and the difficult cases: interrupted work, concurrent edits and missing data. We define what the user sees and can safely do in each state before building a large set of screens. Acceptance tests direct links, back and forward navigation, returning from sign-in, slow responses and touch use on representative devices.
Technologies & Integration
React and TypeScript — Define component ownership, draft state and server-result boundaries with typed API contracts.
Angular routing — Build routed application areas, navigation outcomes and URL state around the task and authorization model.
Vue and Pinia — Manage shared client state deliberately while keeping query results and server authority explicit.
ASP.NET Core OpenAPI — Expose typed service operations, validation/error contracts, paging and concurrency results for the browser client.
Reliable Order Workflows|Reliable Checkout|Business Integration
An online order touches payment, stock, dispatch, accounting and customer service, and all of them have to agree on what happened. Sphere 10 builds custom .NET and nopCommerce stores, or connects your Shopify or WooCommerce storefront to your order, stock and accounting systems.
What we build
Clear ownership of products, prices and stock. We establish which system is responsible for each commercial value and when it becomes binding, including account pricing, unavailable items and expired prices.
Payments reconciled to an order ledger. Stripe, Adyen or PayPal notifications are verified and matched to your orders. Authorised, captured, refunded and disputed amounts are tracked separately, and a repeated or late notification cannot create a second order or release stock twice.
Fulfilment and customer communication. Warehouse, dispatch, accounting and customer notifications follow recorded order changes, including partial fulfilment and adjustments.
Tools for your staff. Searchable order history and views of outstanding payments, failed fulfilment and unmatched events let support resolve exceptions with the evidence in front of them.
Illustration of a commerce ledger reconciling provider events before fulfilment.
What you receive
The storefront or portal, payment connections and administration screens.
The agreed connections to your stock, accounting and dispatch systems.
Customer notifications tied to order status.
Deployment, activation and reconciliation instructions.
How we engage
Bring examples of a normal purchase, a cancellation, a refund, a renewal and an unavailable item. We use them to define the order lifecycle before checkout is built. Acceptance includes failed and uncertain payments, duplicate notifications, abandoned checkout and, for subscriptions, renewals. Development uses the payment providers' test facilities, and going live is a separately configured release step.
Technologies & Integration
nopCommerce — Extend a .NET commerce platform with owned product rules, checkout integration and business-system adapters.
Shopify APIs — Map catalogue, customer, order and fulfilment identities between Shopify and the authoritative business records.
WooCommerce development — Implement catalogue/order integrations and scoped extensions around the selected WordPress commerce installation.
Stripe webhooks — Verify event authenticity, retain provider identifiers and reconcile repeated or delayed payment notifications.
Adyen webhooks — Integrate provider-specific notification validation and payment-state reconciliation alongside the order ledger.
Fast Public Websites|Simple Hosting|Controlled Publishing
When visitors mainly read, follow links and get in touch, a static website gives you fast pages, simple hosting and controlled publishing. Sphere 10 delivers service and product sites, documentation, resource libraries and campaign pages as plain HTML, CSS, JavaScript and media, authored in Notion through our Local Notion product or generated from source control with Astro, Hugo or Eleventy.
What we build
A site planned around visitor tasks. We map the paths visitors take, such as finding a service, comparing products, reading an article and making an enquiry, and the pages each path needs.
Reusable page families. Article, product, service and landing pages share one visual system. We test templates with real long headings, lists and images before approving them.
Dynamic parts kept separate. Enquiry forms and account functions connect to their own services, so the public site stays simple.
Pages and media published together. Each release is reviewed as one unit, with caching, redirects, search metadata and social-preview images configured on your chosen host and content delivery network.
Illustration of editorial source and versioned assets reaching a checked static publication.
What you receive
The site source, generated pages and hosting configuration.
Prepared media and reusable templates.
Authoring instructions and publishing commands for your team.
A rollback procedure and the materials to recover a release.
How we engage
We start from representative pages and visitor tasks, which reveal the navigation, page families and publishing roles the site needs, and choose an editorial workflow your organisation can maintain routinely. Acceptance covers the complete list of public pages at desktop and phone widths, keyboard use, long content, old bookmarks and missing pages, checked on the served site.
Technologies & Integration
Astro static rendering — Choose prerendered pages and deliberately bounded dynamic routes or interactive components for the publication.
Hugo — Build reusable content types, navigation and generated HTML from a maintained source-controlled site.
Eleventy — Create static content/template pipelines with clear ownership of layouts, data and generated assets.
Cloudflare cache control — Coordinate CDN and origin caching with versioned media, HTML updates and verified public routes.
Business Services|Data and Integration|Reliable Application Logic
Behind every portal, mobile app and integration is a service that must complete business operations correctly, including when a request is cut off, a server restarts or an outside provider is unavailable. Sphere 10 develops C# backends on ASP.NET Core and .NET with SQL Server or PostgreSQL, and delivers them with the diagnostics and configuration needed to run them.
What we build
Named business operations. Callers receive operations such as approving an invoice, each with its required authority and a documented interface, instead of open access to your database.
Safe repeats and recovery. Every operation has an identity, so a repeated request resumes, returns the earlier result or is rejected. An uncertain result from a provider stays visible until it is reconciled.
Background and integration work. Imports, messaging, caching and calls to other providers run with defined time limits and retry rules, and continue correctly after a restart.
Services that explain their work. Logs, tracing and health checks identify the affected operation and record. Your operators can inspect incomplete work and take the permitted recovery action.
Illustration of a .NET service owning records and external effects through explicit state.
What you receive
Source code, data mappings and integration adapters as one coherent implementation.
Interface documentation for browser, mobile and integration clients.
Deployment configuration and database migrations.
Stated operational limits, test data and recovery instructions.
How we engage
Name the operation, the record that proves it completed and the response needed while the outcome is still uncertain. That establishes the service contract. Acceptance includes unauthorised access, conflicting updates, malformed requests, interrupted external calls and a restart during processing, run against realistic data with bottlenecks measured.
Technologies & Integration
ASP.NET Core OpenAPI — Define HTTP operations, schemas and validation/error contracts consumed by browser, mobile and integration clients.
gRPC on .NET — Build typed service-to-service contracts with explicit deadlines, cancellation and compatibility rules.
Redis — Implement a defined cache or coordination role with deliberate keys, expiry, invalidation and failure behaviour.
NHibernate transactions — Control session and local transaction ownership, concurrency checks and persistence behaviour for the selected provider.
OpenTelemetry .NET — Correlate service, database and messaging work through traces, metrics and actionable operating diagnostics.
Choosing cloud services commits you to recurring cost and operating work, so the choice should follow from your application and the team that will run it. Sphere 10 designs AWS and Azure environments for .NET applications, data services and integrations, and delivers them as definitions that can recreate the environment.
What we do
Select services from the requirement. We compare managed hosting, containers, Kubernetes and virtual machines on Azure and AWS, along with database and storage options, against your traffic, data sensitivity and integrations. The design records why each service is present.
Make the commitment visible. Recurring-cost assumptions, region placement, provider-specific dependencies and the work needed to change them are documented before implementation.
Control access. Each component receives only the access it needs through the provider's service identities, with no long-lived credentials inside the software package. We test that a denied operation is denied.
Plan recovery. We state which failures the design addresses, what must be restored together and how the application recovers.
Illustration of application configuration, identity and retained state inside an operated cloud environment.
What you receive
Infrastructure definitions in Bicep or Terraform, with the differences between development, staging and production documented.
Topology diagrams and a clear account of the resources your team will operate.
Monitoring signals tied to real workflows, and measured limits.
Deployment instructions and a runbook for the agreed recovery scenario.
How we engage
Bring your expected users, data locations, external dependencies and recovery priorities. We map those before choosing provider services and prove important dependencies before a production release relies on them. Acceptance recreates the environment, then exercises a deployment, a failed dependency, secret rotation where in scope and restoration of the agreed state.
Technologies & Integration
Azure App Service and architecture — Evaluate managed .NET hosting, configuration, network integration and the operating boundary around application releases.
Amazon ECS — Design task definitions, service deployment, container configuration and the selected EC2 or Fargate compute model.
Bicep — Define reviewed Azure resources and their environment-specific parameters as maintained source.
Terraform — Maintain provider-specific infrastructure, state ownership, environment changes and reproducible deployment inputs.
