NODOMIC

Software Engineering & Web Development

Two disciplines, kept apart on purpose. Web design and development, where the work has to be found, fast and easy to use. Software engineering, where it has to be correct, stay up and keep its data intact. We build our own sensing hardware end to end as well — which is why the software here is written to hold up outside a demo.

The Concrete Block Calculator in use: a 40 by 8 foot wall entered on the left, material estimates for blocks, mortar, sand and reinforcement on the right
concreteblockcalculator.com · a 40 × 8 ft wall, estimated

Four areas most projects land in — one on the web side, three on the engineering side.

Web design & development

Software engineering

If your project sits between these — a data pipeline, an internal tool, an integration nobody wants to own, a system that needs rescuing — it is still worth a conversation. The work is chosen by whether we can do it well, not by whether it fits a service page.

Web development and software engineering are not the same trade. We do both, and it is worth being precise about which one a project needs.

Web design & developmentSoftware engineering
What gets deliveredA site: structure, templates, content, and the front end around them.A system: a data model, APIs, services, and the jobs running behind them.
What decides successWhether it is found, how fast it loads, and whether a visitor does the thing.Whether it is correct, stays up, and keeps its data intact.
The hard constraintsCrawlers, browsers, devices, bandwidth, and a performance budget measured in milliseconds.Concurrency, state, partial failure, security, and every other system it has to talk to.
How it typically failsA migration drops rankings the site spent years earning, and nobody notices for six weeks.A race condition corrupts data quietly, and the backup already contains it.
Where the state livesMostly outside it: search indexes, content, caches, other people’s platforms.Inside it, and it has to stay consistent.
What it is tested againstReal devices, Search Console, Core Web Vitals, and the crawler.Test suites, load, deliberate failure injection, and telemetry from production.

Plenty of projects stand in both columns. ChatLino is a site people visit and a backend that has to be right; the calculators are public web pages carrying real domain logic. That is the case for keeping both disciplines under one roof — not for pretending they are one discipline.

What carries across is the habit rather than the toolkit: design the failure case before the happy path, and test against reality instead of mocks. Which of the two a project actually needs is worth settling before anyone writes a quote, and it is the first thing we work out with you.

A new domain, from zero to page one in twelve months

The site started with no history, no links and no brand. For its first four months search engines barely showed it; from January, impressions and clicks climbed month after month — on a tool people come back to use, not an article they skim.

Google Search Console chart for concreteblockcalculator.com, September 2025 to September 2026: daily clicks and impressions flat near zero until January, then rising steadily through the summer
Google Search Console · daily clicks (blue) and impressions (purple) · 12 months to September 2026
Impressions in search
1.65M
Clicks from search
24.8K
Average position
6.8
Visitors who use the tool
46.5%

Live and in use — not mockups.

Software that has to run on a device you can't reach teaches habits ordinary software never demands.

Our own work covers the whole stack. Wavegrasp runs from MEMS microphones and custom circuit boards through real-time firmware to signal processing on the device. ChatLino runs an extensive backend of APIs, workflows and integrations behind a multichannel product. The calculators put real domain logic in front of tens of thousands of calculations a month. That span is rare, and it is why the software here is written the way it is.

A device in a field cannot be patched on a Friday afternoon. Its clock drifts, its power is finite, its inputs are noisy, and its failures are physical rather than logged. Building for that means designing the failure case first, testing against reality instead of mocks, and being able to debug a system when the debugger is an oscilloscope. Those habits do not switch off when the project is a web platform: they show up as a migration that keeps rankings a site spent years earning, an automation whose error branch was drawn before its success branch, and a public calculator that still returns the right answer at the edge of its range.

Wavegrasp — device

SIGNAL

MEMS microphone, analog front end

FIRMWARE

real-time capture, on-device DSP

TRANSPORT

LVDS clock + data, multi-node sync

ChatLino · calculators — platform

BACKEND

APIs, workflows, integrations

INTERFACE

web front ends and tools people use

Every layer above was designed, written and brought up in-house — the device layers for Wavegrasp, the platform layers for ChatLino and the calculators. Most teams own one or two of these and integrate the rest.
Two Wavegrasp acoustic sensor nodes on tripods, connected by a cable across the floor between them

Our own system

Wavegrasp

A network of acoustic sensing nodes that detects and localizes low-altitude drones without relying on the target's control, video or telemetry links. Each node listens on an eight-microphone array and computes direction locally, so what travels between nodes is a bearing rather than raw audio.

Explore Wavegrasp

So we take two kinds of work. Projects where software meets a physical device, where that experience is the reason to hire us. And ordinary software — backends, integrations, internal platforms, customer-facing products — where it simply means the work is done by engineers used to systems that have to hold.

Four ways to start, and no account layer between you and the people writing the code.

01

Team extension

We join your existing team and work in your stack, your repo, your process. Useful when you have direction but not enough hands.

Outsourcing →
02

Project takeover

We inherit an existing codebase — usually one that outgrew whoever wrote it — document what is actually there, and take it forward.

03

Full build

From requirements to a running system, with the handover written as we go rather than assembled at the end.

04

MVP

A first version built to answer one question — software, and hardware where the idea depends on it.

MVP development →

First step: a scoping session

A first conversation is technical, not a sales call. Bring the problem, the constraints, and whatever exists already — you get an honest read on scope, approach, and whether we are the right people for it.

Have a project in mind?

Discuss a project →