How we optimise DNN queries for large data sets

Large data sets can make an otherwise responsive DotNetNuke portal feel slow, especially when module lists grow, reports combine many joins, or background jobs compete with customer traffic. Here, DNN refers to DotNetNuke, not a neural network. The goal is to reduce rows scanned, data transferred and processing time while preserving accuracy and responsiveness.

Aricie starts with the business action, then measures the database work behind it. A tenant searching invoices, a partner loading properties through Budg-Immos and an administrator reviewing activity in Acoléa have different filters, permissions and latency targets. A generic benchmark can conceal the operation that actually damages the experience.

The warning signs are often familiar: pages grow slowly, reports time out, lock waits climb, or the application works in development but struggles with production volume. Large result sets, missing indexes, stale statistics and oversized transactions can combine to create each problem. Optimisation therefore needs both query-level evidence and an understanding of how DNN modules use the data.

Aricie combines execution-plan analysis, schema design, application changes and measured testing. The result is a repeatable process that can be applied to custom modules, Adylic integrations and data-heavy features in AricieGrid. It also gives technical teams and business owners a shared view of the performance gains they are paying for.

Start with the execution plan

For a SQL Server-backed DNN installation, begin with the actual execution path, including the parameters supplied by the module. Query Store, execution-plan telemetry and server-side traces reveal whether time is spent scanning, sorting, joining or waiting. Comparing a representative statement with its cached plan also shows whether parameter changes produce an unsuitable plan.

Prioritise queries by frequency, duration and user impact rather than by an isolated slow-query score. Optimise the small group responsible for most elapsed time, record a baseline and retest with the same data volume. A plan that looks expensive may be acceptable; an ordinary query executed hundreds of thousands of times can be the real constraint.

Return only the data you need

Use explicit column lists instead of selecting every field, and push filtering into SQL wherever the rules can be represented safely. Stable projections reduce network traffic and memory pressure, while carefully chosen joins prevent one broad portal screen from pulling an entire transactional history. DNN modules should also avoid repeating the same lookup for every row.

Parameterised statements protect data and improve plan reuse. Review predicates for sargability: a range that can seek an index is usually preferable to one that forces a scan. Where an object-relational mapper generates the SQL, inspect lazy loading and accidental one-to-many queries, because N+1 patterns can multiply an apparently small request into hundreds of database calls.

Build indexes around real access patterns

A single index rarely serves every filter and sort order. Composite indexes should reflect the columns used together by frequent DNN queries, with equality filters, range predicates and sort columns matched to the access pattern. Covering indexes can include extra columns needed for display, avoiding extra lookups, but their write cost and storage footprint should be checked against actual usage.

Remove or consolidate redundant indexes only after measuring their effect on writes. Update statistics when data distributions change, and test execution plans after index changes rather than assuming an improvement. AricieGrid grids and report filters often need different access paths, so each should be tuned against its own common parameter values and expected result size.

Move heavy work outside user requests

Interactive pages should return a bounded amount of data. Keyset pagination can continue from the last key of the previous page, which avoids the increasing cost of large OFFSET values when ordering is stable. For exports, processing in batches keeps transactions and memory usage controlled while allowing progress to be recorded and failures to be retried safely.

Long reports, imports and notifications can run as background work with status stored in the database. This prevents a web request from holding locks or exhausting a connection pool. Cached reference data may reduce repeated reads, but cache invalidation and tenant separation must be designed first. Aricie applies these patterns to custom modules and considers both peak load and recovery after a failed job.

Fit Australian operating conditions

Australian deployments add practical constraints that should shape the test plan. Sydney and Melbourne host major cloud regions, while organisations in Brisbane and Perth may experience different latency patterns and connectivity requirements. Teams must also consider Australian time zones, local support windows, Australian Privacy Principles and contractual data-residency needs without assuming every workload belongs in a single location.

Aricie’s delivery model can support Australian organisations through its office locations in France, including bases in Mureils, Paris, Lyon and Grenoble. This gives stakeholders in Australia access to DNN expertise, regular progress reporting in agreed time zones and training for internal technical teams, while local requirements remain under the client’s control.

Prove the gain with production-scale testing

Test with representative volume, realistic parameter spread and the permissions used in production. Local market context affects usability as well as speed: this mobile pokies Australia review illustrates how Australian rules, devices and user expectations can shape acceptance of a digital service. DNN testing should apply the same market-specific lens to local formats, currency and access patterns.

Measure server metrics and user-facing outcomes together. Track execution time, logical reads, CPU, lock waits, connection-pool pressure, error rates and percentile page latency before and after each change. Keep Query Store evidence with the release record, then watch for plan regressions after new data volumes arrive. A solution is ready only when speed improves without stale results, security leaks or disrupted tenant boundaries.

Contact Aricie for a structured performance assessment of your DNN modules. The team can review execution plans, index design, background processing and Australian deployment requirements, then establish measurable acceptance criteria before any production change.