Skip to content

Engineering standards

The software engineering standards behind every build

Founders and CTOs need to know a studio can build software their company will run on, not only a demo. These are the eight standards we hold every project to, from architecture decisions to handover, and the evidence each one leaves for you to check.

What they are

What are software engineering standards?

Software engineering standards are the written rules a team follows on every project: how decisions are recorded, how code is reviewed, tested, secured, and released, and how ownership passes to the client. Pixelact, which designs and builds MVPs, web apps, internal tools, and AI systems for funded startups, applies eight such standards to every project, from architecture decisions to handover.

The standards

What we hold every project to

Each standard lists the practices behind it, so you can check them in your own repository.

  1. Standard 01

    Architecture and decisions

    A named lead owns the architecture, and every choice that would be expensive to reverse is written down with its reasons before the code depends on it.

    In practice

    • Each project has a named lead who is accountable for the architecture and approves changes to it.

    • We design the data model first. For SaaS products, tenants, roles, and billing plans are in the schema from the first migration, because adding them under live customers means rewriting it.

    • Choices that are costly to reverse, such as the database, hosting, or authentication provider, are recorded as architecture decision records in the repository: the context, the options, the decision, and its consequences.

    • Our defaults are TypeScript across the stack and Postgres for data. When your team or your data calls for something else, we change the default and record why.

    • Slow work such as data imports, bulk email, and long AI tasks runs in background jobs with retries, not inside a web request.

    • Decisions agreed on a call are written into the tracker or a decision record the same day, so nothing depends on memory.

    Project docs · DecisionsAccepted
    Options considered
    PostgresExact totals
    MongoDBLoose links
    FirebaseHard to leave
    Why
    Orders and invoices must add up exactly.
    Cost
    One more service to run and back up.
    Revisit
    If search slows as the data grows.
    docs/decisions/004-database.md
  2. Standard 02

    Code review: AI drafts, engineers decide

    Our code review process sends every change to the main branch through a reviewed pull request. AI tools can draft code and a first round of comments, and an engineer reads the full diff and decides what merges. Our AI code review workflow shows each step.

    In practice

    • The main branch is protected. Nothing reaches it without a pull request, a passing CI run, and an engineer's approval.

    • An AI reviewer may flag issues first. Its comments are input for the engineer reviewing, and an AI approval never counts as the review.

    • The author must be able to explain every line, including lines an AI tool drafted. Code nobody can explain does not merge.

    • Pull requests stay small and do one thing, with a description of what changed, why, and how it was tested.

    • Changes to sign-in, permissions, billing, tenant data, or database migrations get a separate security pass before merge.

  3. Standard 03

    Testing and CI

    Our software testing standards put automated checks on every pull request, and a failing check blocks the merge. Tests go where a failure would cost money or trust, not where they raise a coverage number.

    In practice

    • CI runs type checks, lint, formatting, and the test suite on every pull request, and the merge waits until all of them pass.

    • Sign-up and sign-in, permissions, billing, and the core workflow are tested first, because those failures reach customers and revenue.

    • Every tenant-scoped feature has a test proving that one customer account cannot read or change another account's data.

    • A bug fix starts with a test that fails because of the bug, so the same bug cannot quietly return.

    • Queries and migrations are tested against a real Postgres database in CI, not a mock.

    • Tests drafted with AI are reviewed like any other code. A test that would still pass with the feature broken gets rewritten.

  4. Standard 04

    Security

    Our secure software development practices build security into each change instead of adding it before launch. The startup security checklist lets you check the same basics in your own product.

    In practice

    • Authorization is enforced in the API on every route, not only hidden in the interface. Tenant data is isolated with Postgres row-level security or one tested data-access layer.

    • Secrets live in your hosting provider's secret store or a secrets manager, never in the repository. A leaked key is rotated at the provider, because deleting it leaves it in git history, as our guide to exposed API keys explains.

    • Lockfiles are committed, dependency updates arrive as reviewed pull requests, and CI flags dependencies with known high-severity vulnerabilities.

    • We use the OWASP Top 10 and the OWASP Application Security Verification Standard as the shared vocabulary for security requirements and findings.

    • Access follows least privilege: separate credentials for each environment, production access only for the people who need it, and two-factor sign-in on every account we use.

    • Real customer data stays off local machines and out of AI tools unless you approve it in writing. Development and test environments use generated or anonymized data.

  5. Standard 05

    Deployment and rollbacks

    Releases run through the pipeline, never from a laptop, and every release has a way back that was tried before anyone needed it. Our guide to safe releases and rollbacks covers the method in detail.

    In practice

    • Deploys run from CI off the main branch, and the build tested on staging is the build promoted to production.

    • Each pull request gets a preview environment you can click through, and staging uses the same configuration as production.

    • Database migrations live in version control and change the schema in backward-compatible steps, so the previous version of the code still runs if we roll back.

    • Risky features ship behind feature flags, so they can be switched off without a redeploy.

    • Before launch, we test the rollback path and restore a backup, so both are known to work instead of only being scheduled.

    • Error tracking, structured logs, and uptime checks are in place before real users arrive, and we watch them after every release.

    Releases · ProductionRolling out
    Rolloutv1.5.0
    Preview10% of usersEveryone
    Errors, last hourAlert line
    History
    • v1.5.0Checkout redesignLive
    • v1.4.2Invoice totals fixPrevious
    • v1.4.1Faster searchEarlier
  6. Standard 06

    Documentation

    Documentation is written for the next engineer, kept in the repository, and updated in the same pull request as the code it describes.

    In practice

    • A README takes a new engineer from a fresh clone to a running app in one sitting, with every command listed.

    • An .env.example file lists every environment variable with a short description and no real values.

    • Runbooks cover deploys, rollbacks, restoring a backup, and the incidents most likely to happen.

    • API contracts are documented from the code, with OpenAPI or typed schemas, so the docs and the behavior stay in step.

    • Pull request descriptions and decision records explain why the code looks the way it does, so the history answers questions later.

  7. Standard 07

    Maintainability

    Code should stay cheap to change after we leave. That means plain structure, strict types, few dependencies, and debt that is written down instead of hidden.

    In practice

    • TypeScript runs in strict mode, and CI enforces formatting and lint rules, so reviews discuss design instead of style.

    • Names describe what code does, each function does one job, and dead code is deleted rather than commented out.

    • Every new dependency is justified in its pull request. We choose well-maintained, widely used libraries over new or niche ones.

    • Shared code is extracted once three real places need it, not for reuse that might never come.

    • Known technical debt is logged in the tracker with its cost and the reason to fix it now or later, never left in a TODO comment.

    • Dependencies and runtimes are upgraded on a schedule, in small steps, rather than in one large jump a year later.

  8. Standard 08

    Handover and ownership

    You own the repository and the accounts from the first day, and handover means any engineer can pick up the product and keep building without us.

    In practice

    • The repository, hosting, domains, and third-party services are set up in your accounts during onboarding, and we work in them as invited members.

    • By default, you pay providers directly. If we cover a small cost to save time, we invoice it at cost with receipts.

    • Code and IP transfer to you once the final invoice is paid.

    • Handover includes a walkthrough of the code, the runbooks, and the open decisions with whoever takes over.

    • When the engagement ends, we remove our own access and rotate any credentials we used.

    • The stack uses standard open source tools and no private framework, so the code never depends on knowledge only we hold.

Why do software engineering standards matter for funded startups?

#

Software engineering standards matter because a funded startup's code has to survive the next stage: more customers, a first engineering hire, and often a technical review before the next round. Code built without them can work on demo day and still be slow and risky to change a year later.

Each standard above keeps a later cost small. Written decisions mean your first hire doesn't have to reverse-engineer them. Tests and CI mean a new feature doesn't quietly break billing. Accounts in your name and a documented handover mean the product does not depend on us to keep running. We publish the process so you can judge it on evidence instead of taking it on trust.

What are our AI-assisted development standards?

#

Our AI-assisted development standards are simple: AI tools write first drafts, and engineers decide what ships. We use AI to draft code, tests, documentation, and first-pass review comments, which is part of why milestones move quickly. The review, testing, and security standards on this page apply to that code exactly as they apply to code typed by hand.

Review matters because AI output looks finished before it is. Veracode's 2025 GenAI Code Security Report tested more than 100 large language models on 80 coding tasks and found that the generated code introduced security vulnerabilities in 45 percent of cases. Building a first version with these tools is a sensible speed trade. Reviewing and testing what they produce is how that speed carries into production.

WorkWhat AI tools doWhat an engineer does
CodeDraft functions, migrations, and boilerplateReads the full diff, explains every line, and approves the merge
TestsSuggest cases and write test scaffoldingChecks that each test fails when the feature breaks
ReviewFlag likely bugs and inconsistenciesDecides which comments matter and owns the approval
Customer dataWork with generated or anonymized test dataAsks for your written approval before real data goes into any AI tool
Where AI tools help and where an engineer decides

When AI is part of the system we build, such as search over company documents, the proposal also states its limits: which data it may use and how it is expected to fail.

What do we never claim?

#

We never claim that software is 100 percent secure, bug-free, or compliant because we built it. Standards lower risk. They don't remove it, and saying otherwise would make this page less useful to you.

  • No security promises. We close common, documented risks and tell you plainly which ones remain.
  • No compliance sign-off. SOC 2, HIPAA, and GDPR obligations are yours, assessed with your auditors and legal advisors, and we build to the requirements they set.
  • No unmeasured numbers. We don't quote performance or uptime figures we haven't measured on your system.
  • No coverage theater. A test suite proves what it tests and nothing more, so we don't present a percentage as proof of quality.
  • No unlimited scope. Retainers buy fixed monthly capacity, and change requests are quoted before work starts.
  • No relabeled proof. Products we built for ourselves are labeled Studio Demonstration or Open Source, never Client Work.

How can you verify our engineering standards?

#

You can check every standard on this page before and during a project, because each one leaves evidence in a repository.

  1. 01Read our open source codeCommitscape and Hexlode are public on GitHub. Their repositories keep numbered decision records in docs/adr, every pull request runs type checks, lint, tests, and CodeQL scanning, and dependency audits run whenever dependencies change and once a day.
  2. 02Ask for the sample audit reportOur software audit has a sample report made from one of our own products, so you can judge how we read code before you pay for anything.
  3. 03See the evidence on a callAsk us to open a pull request with its CI run, a decision record, or a deploy guide from our own repositories, and we walk you through the reasoning behind it.
  4. 04Start with a small paid stepA pilot sprint for a technical proof or an automated workflow is built in your repository under the same standards, so you see the reviews, CI runs, and decision records on your own code before a bigger commitment.
  5. 05Check your repository as we buildPull requests, CI history, decision records, and runbooks sit in your accounts throughout the build. The software partner evaluation checklist lists the questions to ask any partner, including us.

FAQ

Questions about our standards

AI, code review, testing, security, and what we can and can't promise.

Yes. AI tools draft code, tests, and documentation, and an engineer reads every diff, can explain every line, and decides what merges. If your company limits which AI tools may see its code, for example because of a customer contract or an internal security policy, tell us before kickoff. We use only the tools your policy allows and write that rule into the repository's contributing guide, so every contributor follows it.

Yes. The repository is yours, so your engineers can read, comment on, and approve pull requests from the first day. If you want one of them to approve every change in an area they own, such as billing or a data pipeline, we add a CODEOWNERS rule so their review is required before merge. We agree the review rules at kickoff and write them into the repository, so both teams follow the same ones.

We don't set a coverage percentage, because the number can rise while sign-in, billing, and permissions stay untested. We read the coverage report to find risky code with no tests, then pick the right kind of test: unit tests for business rules, integration tests against a real database for queries and APIs, and a few end-to-end browser tests, for example with Playwright, for sign-up and checkout.

No one can honestly promise that. We can commit to the practices on this page and to a written list of the risks we know remain. When an enterprise customer or an investor asks for evidence, an independent penetration test is worth paying for, because testers who did not write the code look for what its authors missed. We can help you scope the test and fix what it finds.

No. They are our own written practice, not a third-party certification, and we don't offer compliance sign-off. They do leave a written trail, such as reviewed pull requests, CI history, and access settings, that your compliance work can draw on. For a public reference to compare any supplier against, NIST's Secure Software Development Framework, SP 800-218 sets out secure development practices in detail.

Yes, scaled to what the pilot must prove. Pilot code lives in your repository and goes through review and CI like any other change. A technical proof or automated workflow is tested on the part it proves, while a clickable prototype is held to a lighter bar because it exists to test an idea with users. The pilot readout says which code can carry into a build.

Yes. When your team already has conventions for branching, review, testing, or deployment, we follow them and raise any gap we see in writing instead of quietly working around it. Where your rules and ours differ, we agree at kickoff which one applies and record it in the repository, so every engineer on the product works the same way.

That is common for products built fast, and speed was a sensible priority at that stage. A software audit shows which gaps matter most, ranked by risk and by the work each fix takes. If the product needs a rescue, a fixed-price stabilization sprint scoped from the audit adds the safety net first, such as CI, tests on critical paths, and a tested rollback, before any larger changes.

Start a project

Tell us what you're building.

Share a few details in a short form, or book a discovery call if you're not sure where to start.

On the discovery call

  1. 01What prompted this now, and where things stand
  2. 02What a good outcome looks like
  3. 03Whether we're a fit, and what a next step could be

45 minutes. No slides, and no long questionnaire.