Services
Senior engineering for the systems your business runs on.
We bring deep Microsoft-stack experience — .NET, ASP.NET Core, Blazor and SQL Server — to business-critical software: building new systems, modernizing aging ones, fixing performance and connecting the applications around them.
- .NET
- ASP.NET Core
- Blazor
- SQL Server
- REST APIs
Service lines
Jump to the service you need
Each service below covers when you need it, what you gain, what we do and what you receive.
Custom Software Engineering
Business applications designed around how your organization actually works — its documents, approvals and exceptions — and engineered to stay maintainable for years.
When you need it
- Critical work runs on spreadsheets, email and manual re-entry.
- Packaged software forces workarounds for how you really operate.
- Disconnected tools hold different versions of the same data.
- A specific operation — lot tracking, job costing, multi-stage production — has no good off-the-shelf fit.
Who it is for: Organizations whose processes have outgrown spreadsheets or packaged software, and teams that need a system built around a specific operation.
What you gain
- Fits your workflow
- Screens, documents and approval paths that match how your teams already work, so adoption comes naturally.
- One source of truth
- Data entered once, validated at the source and shared across departments instead of copied between files.
- Room to grow
- A modular design that takes on new users, sites and business units without a rewrite.
- Yours to understand
- Clean, documented code and agreed ownership, so the system never becomes a black box.
Technical capabilities
- Requirements & process mapping
- Workshops, document walkthroughs and process maps that turn how work really happens into clear specifications.
- ASP.NET Core & Blazor applications
- Secure, responsive web applications that work on desktops, tablets and shop-floor terminals.
- Domain modeling
- Business rules, validations and calculations modeled explicitly, so they can be tested and changed safely.
- Role-based security
- Permissions by role, department and site, with audit trails on sensitive records.
- Documents & operational reports
- Printable documents, exports and reports designed with the people who use them every day.
- Automated testing & CI/CD
- Unit and integration tests, with repeatable build and release pipelines.
Typical deliverables
- Process maps and a scoped specification
- Working software, released in reviewed increments
- Source code, database scripts and deployment pipeline
- Technical and user documentation
- Handover and training for your team
How it runs
Discovery first, then delivery in short increments. You review working software every few weeks rather than waiting for a big reveal at the end.
Legacy ERP Modernization
A safe, staged path from aging desktop and web systems to modern .NET — preserving the business rules your teams rely on while the business keeps running.
Who it is for Organizations running core operations on VB6, WinForms, ASP.NET Web Forms, Access or an aging in-house ERP that is getting harder to support.
What you gain
- Business continuity
- Modules move in planned stages with fallbacks, so operations never depend on a single cutover weekend.
- Rules preserved
- Hidden business logic is found, documented and carried forward — not lost in a rewrite.
- Data you can trust
- Every migration is reconciled against the legacy system before it is signed off.
- A platform with a future
- Supported, modern .NET that is easier to secure, host, extend and staff.
How a staged migration runs
-
Stage 01
Assess & map
Inventory modules, business rules, reports, integrations and data quality. Agree the order of migration.
-
Stage 02
Lay the foundation
Stand up the new platform with shared data access and sync, so old and new see the same records.
-
Stage 03
Migrate module by module
Replace one business area at a time behind the same data. Users move over in planned steps.
-
Stage 04
Run in parallel & reconcile
Operate old and new side by side for agreed periods. Reconcile stock, balances and reports until they match.
-
Stage 05
Cut over & retire
Switch fully, archive legacy data for reference and decommission the old system.
When you need it
- Only one or two people understand the system, and they are stretched.
- The platform is out of support, or hard to secure, host or hire for.
- Users need browser or mobile access the current system cannot provide.
- Every change is slow and risky because nothing is documented or tested.
Technical capabilities
- Legacy assessment
- Code, database and usage review to map modules, dependencies, reports and hidden business rules.
- VB6, WinForms & Web Forms to ASP.NET Core and Blazor
- Screens and logic re-engineered onto a clean, maintainable architecture.
- Strangler-style migration
- New modules replace old ones gradually behind shared data, instead of one big-bang switch.
- Data migration & reconciliation
- Scripted, repeatable migrations with cleansing, mapping, record counts and balance checks.
- Parallel runs
- Old and new systems operated side by side for agreed periods until their outputs agree.
- Database upgrades
- Older SQL Server versions and Access back ends moved onto supported, well-structured SQL Server.
Typical deliverables
- Modernization assessment and staged roadmap
- Documented business rules and data mappings
- Migrated modules, released stage by stage
- Reconciliation reports for every data migration
- Archive and decommissioning plan for the old system
How it runs
We start with an assessment and a roadmap you approve stage by stage. Each stage has its own scope, acceptance checks and rollback plan.
SQL Server Performance Consulting
Query tuning, indexing strategy and health reviews for SQL Server — so slow screens, reports and month-end processes stop holding your teams back.
When you need it
- Screens and reports that once took seconds now take minutes.
- Month-end close, payroll runs or overnight jobs overrun their window.
- Users hit timeouts, blocking or deadlock errors at busy times.
- Performance changes from day to day with no obvious cause.
Who it is for: Teams whose ERP, reporting or line-of-business applications run on SQL Server and have become slow, unpredictable or prone to timeouts.
- Measure Capture baselines for the slowest screens, reports and jobs — durations, reads, waits.
- Diagnose Execution plans, wait statistics, Query Store history and blocking chains.
- Fix Index changes, query rewrites and configuration, tested away from production first.
- Verify Re-measure the same workload and document what changed and why.
What you gain
- Faster daily work
- Effort aimed at the screens, reports and jobs your users actually wait on.
- Root causes, not guesswork
- Every change backed by evidence from execution plans, wait statistics and Query Store — before anyone buys more hardware.
- Performance that holds
- Stable plans and sensible maintenance, so improvements last after the engagement ends.
- Knowledge your team keeps
- Findings explained in plain language, with scripts and guidance your team can reuse.
Technical capabilities
- PLANExecution plan analysis
- Reading actual plans to find scans, spills, key lookups and poor cardinality estimates.
- INDEXIndexing strategy
- Designing, consolidating and removing indexes based on the real workload, not rules of thumb.
- QUERYQuery & procedure rewrites
- Set-based rewrites, SARGable predicates, and fixes for implicit conversions and row-by-row logic.
- PARAMParameter sniffing & plan stability
- Diagnosing plan regressions and stabilizing them with Query Store, targeted hints or code changes.
- LOCKSBlocking & deadlock analysis
- Tracing lock chains and deadlock graphs, then tuning transactions and isolation levels.
- MAINTHealth checks & maintenance
- Index and statistics maintenance, tempdb and configuration review, backups and integrity checks.
Typical deliverables
- Baseline measurements of the slowest workloads
- Prioritized findings, each with its evidence
- Tested index, query and configuration changes
- Before-and-after comparison on the same workload
- Maintenance and monitoring recommendations
How it runs
Usually a focused review: measure, diagnose, fix the highest-impact issues, then verify against the original baseline. Ongoing tuning can continue under a support agreement.
API Integration
Reliable connections between your ERP and the systems around it — banks, e-commerce platforms, attendance devices, government portals and partners — so data moves without re-keying.
Who it is for Businesses where staff copy data between systems by hand, or where existing integrations fail silently and are hard to trace.
What you gain
- No more re-keying
- Data entered once flows to where it is needed, with fewer errors and delays.
- Failures you can see
- Every message logged, retried when it is safe to and flagged when it needs a person.
- Change without chaos
- A clear integration layer, so replacing one system does not break the others.
- Careful with credentials
- Secrets stored securely, access scoped to what each connection needs, traffic encrypted.
- Banks Statements & payment files
- E-commerce Orders, stock & prices
- Logistics Shipments & tracking
- Partners Supplier & customer files
- Government portals Tax & regulatory filings
- Attendance devices Punches & shifts
- Messaging Email, SMS & alerts
- Business apps CRM, HR & legacy systems
When you need it
- Staff re-key orders, payments or attendance from one system into another.
- File imports break whenever a partner changes a column or format.
- Nobody notices a failed integration until the numbers are wrong.
- A new platform, bank or portal needs to connect to your ERP.
Technical capabilities
- REST/JSON APIs
- APIs designed, built and documented with ASP.NET Core, including versioning and authentication.
- Webhooks & events
- Receiving and publishing events, with signature checks and idempotent processing.
- File & EDI-style imports
- CSV, Excel, XML and fixed-format files validated, mapped and imported with clear error reports.
- Banks & payment files
- Statement imports, payment file generation and reconciliation against your ledger.
- E-commerce, devices & portals
- Order and stock sync with online stores, attendance device data, and government or tax portal submissions.
- Monitoring, retries & audit logs
- Queues, retry policies, dead-letter handling and dashboards that show what moved and what failed.
Typical deliverables
- Integration map of systems, data flows and owners
- API specifications (OpenAPI) and data mappings
- Tested integrations with error handling and retries
- Monitoring, alerts and an operations runbook
How it runs
We map each data flow end to end and agree who owns which data. Then we build, test with real sample files and messages, and watch closely after go-live.
Database Architecture
Data models, schemas and data platforms designed for integrity, auditability and growth — the foundation every screen, report and integration depends on.
When you need it
- The same customer, item or employee exists in several versions.
- Reports disagree because data is stored inconsistently.
- Nobody can say who changed a record, or when.
- Volumes are growing and the current design will not keep up.
Who it is for: New systems that need a sound data foundation, and existing databases that have grown without a plan.
What you gain
- Integrity built in
- Keys, constraints and validation that stop bad data at the door instead of cleaning it up later.
- A clear audit trail
- A history of who changed what and when, for the records that matter.
- Designed for growth
- Structures that handle more transactions, more sites and years of history gracefully.
Technical capabilities
- Relational data modeling
- Normalized schemas with clear ownership of entities such as items, lots, parties and ledgers.
- Master data design
- Item, customer, supplier and employee masters with codes, hierarchies and approval rules.
- Audit & history
- Temporal tables, change tracking and audit logs wherever traceability is required.
- Partitioning & archiving
- Strategies for large transaction tables and many years of history.
- Security & access
- Least-privilege roles, row-level security and protection for sensitive columns.
- Backup, recovery & availability
- Recovery objectives agreed with you, then backups, tested restores and availability designed to meet them.
Typical deliverables
- Logical and physical data models
- Schema scripts with migration history
- Data dictionary and naming conventions
- Security, backup and recovery plan
How it runs
We study how data is created and used before drawing a single table. Designs are walked through with your team and versioned as scripts from day one.
Business Workflow Automation
Approvals, notifications and routine processing automated end to end — so people spend their time on decisions, not on chasing signatures and re-entering data.
Who it is for Operations and finance teams where requests wait in inboxes, approvals happen on paper and routine steps depend on someone remembering.
What you gain
- Faster turnaround
- Requests route automatically to the right approver, with reminders when they stall.
- Rules applied consistently
- Limits, delegations and segregation of duties enforced the same way every time.
- Full visibility
- The status of every request visible to the people who need it, with a complete history.
- Fewer manual steps
- Scheduled jobs and integrations take care of routine processing and postings.
- Stores Purchase request Submitted
- Line manager First approval Approved
- Finance Budget check Budget available
- Plant head Above approval limit Escalated automatically
- Purchasing Purchase order Issued and emailed to vendor
Rules applied automatically
- Amounts above the approval limit go to the plant head.
- Requests waiting more than a day remind the approver, then escalate.
- Every decision is time-stamped in the audit trail.
When you need it
- Purchase requests, leave or payments wait days for a signature.
- Nobody can see where a request is stuck, or who has it.
- Reminders, recurring reports and postings depend on someone remembering.
- Approval rules live in people’s heads rather than in the system.
Technical capabilities
- Multi-level approvals
- Routing by amount, department, site or document type, with delegation and escalation.
- Notifications & reminders
- Email and in-app alerts, daily digests and escalation when requests stall.
- Scheduled & background jobs
- Recurring postings, imports, report runs and data housekeeping handled automatically.
- Configurable rules & limits
- Approval limits and business rules that authorized users can maintain without code changes.
- Document generation
- Purchase orders, letters and statements generated from templates and stored with the record.
- Audit trails
- Who did what, when and why — recorded for every step of every request.
Typical deliverables
- Current and target workflow maps
- Configured approval rules and limits
- Automated jobs with monitoring
- Guides for requesters and approvers
How it runs
We map the workflow as it really runs today, exceptions included, agree the target rules with process owners, then automate in stages.
Business Intelligence & Analytics
Dashboards and reports that turn operational data into clear, trusted numbers for management — with every figure traceable to the transactions behind it.
When you need it
- Monthly reports take days of spreadsheet work to assemble.
- Departments bring different numbers to the same meeting.
- Management wants trends and exceptions, not long transaction lists.
- Production, inventory and finance data never sit in one view.
Who it is for: Management and finance teams who spend days assembling reports in spreadsheets, or who see different numbers from different sources.
- Transactions Vouchers, orders, lots and attendance from source systems
- Validated model Cleaned, reconciled and modeled for reporting
- Agreed KPIs One definition per measure, with an owner
- Dashboards Summaries with drill-down to the source
What you gain
- One version of the numbers
- Agreed KPI definitions, calculated the same way in every report.
- Time back for analysis
- Reports refresh automatically instead of being rebuilt every month.
- Answers at the right level
- Executive summaries with drill-down to the documents behind each figure.
Technical capabilities
- KPI definition workshops
- Agreeing exactly how each measure is calculated, and who owns it.
- Reporting data models
- Star schemas, data marts and SQL Server views designed for fast, consistent queries.
- ETL & data pipelines
- Scheduled loads from your ERP, spreadsheets and other sources, with validation and reconciliation.
- Dashboards & operational reports
- Executive dashboards, departmental reports and exception lists built for how they are used.
- Drill-down & traceability
- From a summary figure down to the underlying vouchers, lots or orders.
- Report performance
- Indexing, aggregations and caching so dashboards stay quick as data grows.
Typical deliverables
- KPI catalog with agreed definitions
- Reporting data model and pipelines
- Dashboards and reports for each audience
- Automated data reconciliation checks
How it runs
We start from the decisions management needs to make, agree the measures, then build the data model and dashboards in short, reviewed iterations.
Application Support & Maintenance
Ongoing support, monitoring, fixes and enhancements for business-critical applications — including systems we did not build.
Who it is for Organizations that depend on a custom or legacy application and need dependable engineering support, whether or not the original developers are still around.
What you gain
- Continuity
- Engineers who know your system, with that knowledge written down rather than held by one person.
- Predictable attention
- Agreed priorities, one clear channel for requests and regular reviews.
- A system that keeps improving
- Small, regular improvements instead of slow decline.
- Corrective Investigating and fixing defects, with root-cause notes so they stay fixed.
- Preventive Monitoring, patching, backup checks and housekeeping before problems reach users.
- Adaptive Changes for new tax rules, regulations, platforms and integrations.
- Perfective Planned enhancements and performance improvements, prioritized with you.
When you need it
- The original developer or vendor is no longer available.
- Issues are fixed reactively, with no monitoring or plan.
- Tax rules, reports or processes change and the system must keep up.
- Your internal team needs senior backup on a critical application.
Technical capabilities
- Onboarding existing systems
- Code and database review, environment setup and documentation of how the system really works.
- Monitoring & alerting
- Application, job and database health checks, with alerts that reach the right people.
- Issue triage & fixes
- Prioritized by business impact and tracked from first report to release.
- Security updates & patching
- Framework, library and server updates, applied with testing.
- Release management
- Versioned releases, change notes and rollback plans.
- Planned enhancements
- Improvements agreed with you and delivered in regular, reviewed releases.
Typical deliverables
- System health assessment and onboarding notes
- Support process with priorities and channels
- Regular status and activity reports
- Maintained documentation and runbooks
How it runs
We begin with an onboarding review, agree priorities and communication, then work through a tracked queue with regular check-ins and periodic roadmap reviews.
How we engage
A clear path from first conversation to long-term support
Every engagement follows the same five steps. You know what happens next, what you will receive and when you will see working software.
-
Discover
We learn how your operation really works — documents, approvals, exceptions and pain points — and agree what success looks like.
You receive
- Findings summary
- Prioritized requirements
- Recommended approach
-
Design
We shape the solution: architecture, data model, screen flows and a delivery plan, reviewed with your team before building starts.
You receive
- Solution architecture
- Screen flows or prototypes
- Scope, milestones and estimate
-
Build
We deliver in short increments, with working software you can review, test and comment on as it grows.
You receive
- Regular working releases
- Demo and progress sessions
- Tested, reviewed code
-
Deploy
We migrate data, prepare environments, train users and stay close through go-live — with a rollback plan ready.
You receive
- Migrated, reconciled data
- Training and user guides
- Go-live checklist and rollback plan
-
Support
We stay on to monitor, fix, refine and extend the system as your business changes.
You receive
- Support channel and priorities
- Periodic health reviews
- Enhancement roadmap
Engagement models
Choose the way of working that fits
Most relationships start with a focused project and grow from there. Each model is scoped and agreed in writing before work begins.
- 01
Fixed-scope project
A defined outcome delivered against an agreed scope, milestones and acceptance criteria.
Choose it when
- Requirements are clear, or can be made clear in discovery.
- You need a firm plan and budget approval before work starts.
- The work has a natural end point — a new module, a migration or a performance review.
- Agreed scope
- Milestones
- Acceptance criteria
- 02
Dedicated engineering capacity
Engineers working as an extension of your team on a continuing basis, directed by your priorities.
Choose it when
- You have an ongoing roadmap rather than a single project.
- Priorities shift often and you need flexibility.
- Your in-house team needs senior .NET or SQL Server depth.
- Reserved capacity
- Your backlog
- Regular planning
- 03
Support & maintenance agreement
Ongoing care for a live system — monitoring, fixes, updates and small enhancements under agreed priorities.
Choose it when
- A business-critical system is live and must stay healthy.
- The original developers are no longer available.
- You want planned improvements instead of emergencies.
- Agreed priorities
- Monitoring
- Periodic reviews
Working with us
What working with us looks like
Good engineering is as much about how a project is run as the code itself. These are the habits we bring to every engagement.
Transparent progress
Regular demos and plain-language updates. You see working software, open issues and risks as they are — not only at milestones.
Documentation & knowledge transfer
Architecture notes, runbooks and user guides written as we go, with handover sessions so your team is never dependent on one person.
Clear ownership of code and documents
Ownership of source code, database scripts and documentation is agreed in writing at the start, so there are no surprises later.
Security-conscious engineering
Least-privilege access, careful handling of credentials and personal data, dependency updates and code review as part of normal work.
Maintainable code
Readable, tested, consistently structured code and versioned database changes — written for whoever maintains it next.
Start here
Tell us about the system you need — or the one holding you back.
Share where things stand today: the processes, the software you use and what is not working. We will come back with questions, then practical options.