Application Development in Princeton, NJ

You do, in writing: the source code, the data and the documentation are your organisation’s assets, delivered and intelligible, with the engagement structured as a service relationship rather than a tenancy. This includes the unglamorous parts that tenancy-builders prefer to keep vague — build instructions, credentials and infrastructure definitions, the decision log — everything a competent successor needs to maintain the system without us. Establish this with any developer before the first invoice, in the agreement rather than in conversation: the time to discover you rented your core system is not the day you need to change providers, and organisations here, of all places, should not have to learn that empirically.

Sometimes by hardening, sometimes by rebuild — and the assessment, given in writing, tells you which and why. The evaluation reads the prototype the way diligence will: the data model’s honesty, the security’s reality, the shortcuts catalogued by the harm they can do, the parts worth keeping (often the validated logic and the data itself) separated from the scaffolding. Hardening is priced where it is genuine; a rebuild keeps the proven behaviour as its specification, which makes it cheaper and safer than a greenfield guess. What is refused is the cosmetic path — painting the prototype and calling it a product — because its bill arrives later, with interest, at the least convenient moment.

Security is engineered from the first commit, not audited in afterwards: data segregated by sensitivity, access by named identity and role, the audit trail designed with the data model, dependencies and components tracked, and the whole tested before production against the ways such systems actually fail. Where funders, clients or partners impose specific requirements, they enter the specification as named constraints with owners. The build’s documentation records the security decisions and their reasons — because in five years, ‘why is it built this way?’ deserves a better answer than a departed developer’s silence.

Less than they fear, at the moments that matter: discovery interviews and shadowing at the start (the specification is your work, so your people are its authors), short reviews of working software each cycle — an hour’s honest use beats a month of assumed requirements — and training on the finished tool with their own data. The cadence is designed around your calendar: terms, deadlines and launches are constraints the plan states rather than surprises it discovers. What the process asks most is candour about the exceptions — the workaround, the special case, the step everyone skips — because software built on the official process alone fails on contact with the real one.

The plan dates it honestly, by stages, before commitment: most organisational tools here reach their first working version — the piece that retires the worst workaround — in weeks, with the full scope staged by value after it. The estimate’s evidence is the specification itself: staged delivery means the dates are re-proven at every cycle rather than defended at the end. Slippage, when reality insists, is confessed early with its remedy and its arithmetic, because a plan leadership cannot trust is worse than a later date they can. Beware any quote that is both instant and confident; it has priced your software without reading your process.

No — maintenance is a standing arrangement, and for software meant to be kept it is the larger half of the engagement: the application monitored, patched and backed up; small changes — the new programme’s field, the report a funder now wants — made on rhythm rather than re-procured; the documentation extended with every change so the asset stays intelligible. The periodic review also watches the fit between the tool and the work as both evolve, proposing the improvements in order of value. Organisations may, of course, take maintenance in-house — the documentation exists precisely so that choice is real — but most find the standing arrangement is how the asset keeps compounding instead of quietly expiring.

Priced from the specification, in stages: discovery produces the document, the stages are priced against it with the first working version separated out, and maintenance is a standing rhythm priced to the asset’s scale. The comparison leadership should run is against the true cost of the alternatives — the subscription stack that almost fits (priced per seat, forever, in a currency of workarounds), the spreadsheet’s error rate at your volume, the grant-era tool’s risk premium. Custom software is not the cheap option; it is the owning option, and in a town that builds things to keep, the arithmetic usually understands itself.