Skip to content
Services

Engineering, end to end.

Fourteen services covering the full life of a software system — from the first conversation about whether to build it, through design and delivery, to keeping it healthy years later. Most engagements combine three or four.

Process

Seven phases, and you can see all of them.

No black box between kickoff and delivery. Every phase has named deliverables and a duration you agreed to before it started.

  1. 01

    Discovery

    1–2 weeks

    We interview the people who'll use the thing, map the workflow as it actually runs, and write down the constraints. Nobody estimates before this.

    • Stakeholder and end-user interviews
    • Current-state workflow map
    • Technical and regulatory constraints
    • Success metrics agreed in numbers
  2. 02

    Planning

    1 week

    Scope, sequence and price, in a document you own. Risks are named up front rather than discovered in month three.

    • Written scope with explicit exclusions
    • Delivery plan with milestones
    • Risk register with mitigations
    • Fixed proposal — no hourly surprises
  3. 03

    UI/UX

    2–4 weeks

    Interface design and system design happen together. Every state gets designed — including empty, loading, error and offline.

    • Design system with tokens for both themes
    • Screens at mobile, tablet and desktop
    • Interactive prototype, user-tested
    • Accessibility reviewed before build
  4. 04

    Development

    4–16 weeks

    Two-week iterations against a board you can see. A deployed environment exists from week one and a demo lands every sprint.

    • Working software deployed continuously
    • Sprint demos with your stakeholders
    • Code review on every change
    • Live board — no status-report theatre
  5. 05

    Testing

    1–3 weeks

    Automated coverage, load testing at realistic peak, an accessibility audit and a security review. Before launch, not after.

    • Unit, integration and end-to-end suites
    • Load testing against projected peak
    • WCAG 2.2 AA audit and remediation
    • Dependency and access-control review
  6. 06

    Deployment

    1 week

    Staged rollout with monitoring live before traffic arrives, and a rollback path that has actually been tested.

    • Infrastructure as code, reproducible
    • Staged rollout with health checks
    • Monitoring and alerting live pre-launch
    • Runbooks and team training
  7. 07

    Support

    Ongoing

    We stay on. Response-time SLAs, proactive patching, and a quarterly review of where the system should go next.

    • Defined severity levels and response SLAs
    • Monthly dependency and security patching
    • Uptime and performance reporting
    • Quarterly roadmap review
How we work

Agile when it fits. Something else when it doesn't.

“We're Agile” is the default answer, and it's the wrong one for a regulated fixed-scope build or a support retainer. We run four models and recommend the one that suits your constraints — including the ones we'd rather not use.

A fixed, sequential discovery phase produces a scope and a price you can sign off. Delivery inside that scope then runs in two-week iterations. You get the budget certainty of a phased contract with the adaptability of an agile build.

Cadence
1–2 week discovery, then 2-week sprints
Commercials
Fixed price · milestone billing

We’d pick this when

  • You need a number to take to a board before work starts
  • The problem is understood but the solution detail isn't
  • Procurement requires fixed deliverables and a fixed price
  • You want to change priorities without renegotiating the contract

Not right for

Genuinely exploratory work where even the problem is unclear. If discovery can't produce a scope worth fixing, we'll tell you and propose continuous flow instead.

What you receive

  • Written scope with explicit exclusions
  • Fixed price and milestone plan
  • Sprint demos every two weeks
  • Change requests quoted before they enter a sprint
FAQ

Questions people ask before they hire us.

The ones that actually decide it. If yours isn't here, email us and we'll answer it directly.

Still unsure? hello@devsock.com

It depends on scope, so we don't publish a price list that would be wrong for everyone. As a rough guide: an MVP typically runs 6–12 weeks with a small team, a custom platform 12–24 weeks with a larger one, and consulting engagements 2–6 weeks. We run a paid discovery first, then give you a fixed scope and a fixed price. If your budget can't reach a useful outcome, we'll say so before you spend anything on discovery.

Next step

Ready to build something worth owning?

Tell us what you're trying to change about your business. We'll tell you whether software is the right lever, what it would take, and what it would cost — before you commit to anything.

  • 30 minutes

    No slide deck, no sales team

  • An engineer

    You speak to someone who builds

  • A straight answer

    Including when it's don't build it