The technical side

For developers: how we build software.

In short

PhonedTech builds software with proven, widely used tools. Every change goes through code review and automated tests before it ships, and what runs in production is monitored. At handover, your team gets the full code repository, documentation, written decision records and a list of every account and access. This page is written for developers and CTOs.

How we build

The principles we work by.

  1. Proven tools first

    We build with widely used, well-documented tools that your next developer already knows. Something new has to earn its place in your project.

  2. Simple before clever

    One well-chosen database and a background queue go a long way. We split a system into more services only when there is a clear reason, because every extra part has to be run and looked after.

  3. Yours from day one

    The code repository, the cloud account, the domain and the keys are in your company's name from the start. We work with our own access, which you can switch off at any time.

  4. Small changes, shipped often

    Work goes live in small pieces. Each change is tried on a test copy (staging) first and can be rolled back, so a release is routine, not an event.

  5. Decisions written down

    Every important decision gets a short written record: the context, the options and why we chose one. Whoever works on the system next doesn't have to guess.

  6. Secrets stay out of the code

    Passwords and API keys live in a secure vault, separate from the code, and each person and each service gets only the access it really needs.

The stack

What we build with.

The tools we reach for most often, and when. We choose for each project: if your team already runs on something solid, we usually build on it rather than replace it.

  • Frontend

    For everything users actually touch.

    • React / Next.jsSSR · ISR
    • Vue / Nuxtwhen DX wins
    • TypeScriptalways
    • React Nativecross-platform
    • Tailwind / CSS Modulesutility-first
  • Backend

    Servers, services, business logic.

    • Node.jsJS on both sides
    • Laravel · PHPfast to ship
    • Java · Spring Bootenterprise scale
    • Pythondata & ML
    • REST · GraphQLwhichever fits
  • Data

    Where your data is stored and kept consistent.

    • PostgreSQLdefault choice
    • Supabasepostgres + auth
    • MongoDBwhen schemaless wins
    • Rediscaches, queues
    • Pinecone · Weaviatevector search
  • Cloud

    Where it runs and how we know it's healthy.

    • AWSour default
    • Google Clouddata & ML focus
    • DigitalOceanwhen you don't need a big setup
    • Vercel · Cloudflareedge & static
    • Docker · Kubernetescontainers, orchestration
    • Terraforminfra-as-code
  • AI

    AI models that run inside live products.

    • OpenAIGPT-5, embeddings
    • Anthropic Claudelong context, tools
    • Open-weight modelsself-hosted
    • LangChain / LlamaIndexwhen useful
    • Vector DBspinecone · weaviate
  • Automation

    Less manual work in inboxes, spreadsheets and copy-paste.

    • n8nself-hosted ops
    • Makequick no-code flows
    • GitHub ActionsCI/CD
    • Cron + queueswhen it's serious
    • Custom orchestratorsfor AI pipelines
  • Observability

    Tools that show us what's happening and alert us only when something needs attention.

    • Grafana · Prometheusmetrics
    • Sentryerrors
    • Datadoghosted monitoring
    • OpenTelemetryvendor-neutral traces
    • PagerDutyon-call
  • Security

    Defaults that prevent the obvious mistakes.

    • OAuth 2 · OIDCauth standards
    • Auth0 / Clerkwhen it fits
    • Vaultsecrets
    • Pen-test coordinationwith an outside firm
  • Commerce & CMS

    When you don't need to build it from scratch.

    • Shopifythemes & headless
    • Sanity · Strapiheadless CMS
    • Stripebilling
    • Algolia · Typesensesearch
    • Resend · Postmarktransactional mail

Quality

Code review, testing and monitoring.

Code review

Every change goes through a pull request with a short note on what changed and why. Automated checks run first, then another engineer reviews the code before it's merged. Reviews catch bugs, and they also spread knowledge, so no part of your system lives in one person's head.

  • A pull request for every change, never a direct push to the main branch
  • Formatting, linting and tests run automatically on every pull request
  • Another engineer approves before the merge

Testing

Tests are written with the code, not after it. They run on every pull request and again before each release, and every change is tried on a staging copy before it reaches your users.

  • Unit tests for business rules and calculations
  • Feature and integration tests for the flows that matter, such as sign-up, payment and orders
  • End-to-end tests for the few paths that must never break
  • An accessibility check against WCAG before handover

Monitoring

Once it's live, we keep watching it. Errors are reported with the details needed to fix them, uptime is checked around the clock, and logs are kept so we can see what happened. Alerts go out only for real problems, so nobody learns to ignore them.

  • Error and crash reporting from day one
  • Uptime checks and alerts
  • Logs you can search
  • Regular backups

Handover

What your team receives.

At handover, or whenever you ask, your team gets everything it needs to run the system and change it without us.

  • The code repository

    The full repository with its whole history, in your organization's account on GitHub, GitLab or Bitbucket, including the build and deployment setup.

  • Documentation

    A README that gets a new developer running locally, an overview of how the parts fit together, how to deploy, and short guides for the things that can go wrong.

  • Decision records

    The important decisions in writing: the context, the options we weighed and why we chose one.

  • An access list

    Every account, service, domain and key the system depends on, who holds access to each and how to change it. When you're ready, we hand everything over and remove our own access.

For illustration: a handed-over repository, with the README, the access list, the documentation, the decision records and the tests.

Working with your team

Alongside your developers.

Already have developers? We can work inside your setup rather than next to it: your repository, your issue tracker, your chat and your code style.

  • Your engineers review our pull requests, and we can review theirs
  • We follow your rules for branches, releases and reviews
  • One senior engineer is your main contact from the first call to handover
  • Knowledge is shared as we go, through reviews, pairing and short walkthroughs, not saved for the last week

How we work together depends on you and the project: a fixed-price project, a monthly retainer, a part-time CTO, a dedicated team, or white-label work for agencies.

Questions from your tech team?

Bring them to a free 30-minute call with an engineer, or send them on WhatsApp or by email. One of our engineers reads every message and usually replies within one business day.